#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
#
##@package proiSpecialProcess
#
# @todo: gm¹¤¾ßdbÖ´ÐÐÎļþ
# @author xmnathan
# @date 2009-06-04 15:30
# @version 2.0
#
# ÏêϸÃèÊö: 
# @change: "2012-06-14 18:00" wdb gm¹¤¾ßµ÷Õû
# @change: "2012-06-19 15:00" wdb ³õʼ»¯funcName
# @change: "2012-07-12 18:00" wdb Ôö¼Ó±àÂëÊôÐÔ
# @change: "2012-07-30 11:30" wdb GM»Ø¸´Ï¸»¯£¬´úÂëÓÅ»¯
# @change: "2014-09-23 12:00" hxp ¸öÈ˲¹³¥ÃüÁîÐÅÏ¢Ôö¼Ó²éѯÍæ¼ÒIDÐÅÏ¢ÍƸøGameServer
# @change: "2014-09-29 11:00" hxp ÐÞ¸´Ð޸ĸöÈ˲¹³¥ÃüÁî×ÖµäʱÖÐÎıàÂë´íÎóÎÊÌâ
# @change: "2014-10-11 16:30" hxp »»ÐбàÂë´íÎó´¦Àí
# @change: "2015-02-10 20:30" xmnathan Ôö¼ÓGameServer»Ø°ü´¦Àíº¯Êý
# @change: "2015-10-28 14:00" hxp ·µ»Ø¸ñʽʹÓÃjson
# @change: "2017-04-26 16:30" hxp ת»¯±àÂë¸ñʽ´¦Àíµ¥ÒýºÅ
#------------------------------------------------------------------------------ 
#"""Version = 2017-04-26 16:30"""
#------------------------------------------------------------------------------ 

from GMToolPyInterface import *
from DBCommon import GlobalFunctions
from Commands import GMCommon
import Commands
import copy
import os
import traceback
import json

from MangoDBCommon import fix_incomingText
from Collections import DataServerPlayerData
from Collections.CollectionDefine import *
from Common import (CommFuncEx, mylog)
from Protocol import MMORPGPack
      
################################################################## 
                ####### pythonÂß¼­Èë¿Ú ####### 

## µ¼ÈëGMÈ«²¿ÃüÁî
#  @param importDir ·¾¶Ãû
#  @return None
#  @remarks º¯ÊýÏêϸ˵Ã÷.
def ImportCommandAll(importDir):
    curPath = GlobalFunctions.getAppPath()
    for root, dirs, files in os.walk("%s\\%s"%(curPath, importDir)):
        for file in files:
            fileName = os.path.join(root, file)
            fileName = fileName.replace(curPath, "")
            fileName = fileName[1:len(fileName)]
            if fileName.find("__init__") >= 0:
                continue
            
            curFileList = fileName.split(".")
            fileName = curFileList[0]
            ext = curFileList[1]
            if ext not in ['pyc', 'py']:
                continue
            
            fileName = fileName.replace("\\",".")
            __import__(fileName)

ImportCommandAll("GMToolLogicProcess\\Commands")

# gmÃüÁî¹ÜÀí
_GMCmdOrderMgr = None
#################
#GMÃüÁî·Ö·¢´¦ÀíÈë¿Ú#
#################
## GMÃüÁî·Ö·¢´¦ÀíÈë¿Ú
#  @param None 
#  @return None
def OnGMToolCommand(pack):
    mylog.info('ProjSpecialProcess OnGMToolCommand IN')
    #GM¹¤¾ß½Ó¿ÚÃüÁî
    #¶ÁÈ¡·â°üÊý¾Ý
    recvPack = RecvPackProtocol.tagGMCommand()
    recvPack.ReadData(pack.getBuffer())
    
    orderLen = recvPack.OrderLen
    orderId = recvPack.OrderId
    cmdLen = recvPack.CmdLen
    cmd = recvPack.Cmd
    uerDataLen = recvPack.UserDataLen
    userData = recvPack.UserData
    #-----------------------
    #ÏîÄ¿×é¸ù¾ÝÃüÁîÀàÐͽøÐд¦Àí
    #-----------------------
    mylog.info('GM Tool Cmd->%s,orderId->%s'%(cmd, orderId))
    funcName = ''
    try:
        # »ñµÃgmÃüÁîÐÅÏ¢
        gmCmdDict = eval(cmd)          
        funcName = gmCmdDict.get(GMCommon.Def_GMKey_Type, '')  

        if funcName == None:                        
            GMCommandResult(orderId, gmCmdDict, GMCommon.Def_GMCmdNone)
            return
        
        # ת»»±àÂë¸ñʽ
        cmdDict = ChangeEncodIng(gmCmdDict) 
        if cmdDict == {}:
            GMCommandResult(orderId, gmCmdDict, GMCommon.Def_EncodeFail)
            return
        
        gmCmdManger = GMCmdManger()
        gmCmdManger.gmCmdDict = cmdDict
        gmCmdManger.funcName = funcName
        gmCmdManger.orderId = orderId
        gmCmdManger.userData = userData
        gmCmdManger.pack = copy.deepcopy(pack)
        gmCmdManger.gmCmdDictUnEncode = gmCmdDict
        
        # ÃüÁî¼ÓÈë¹ÜÀíÆ÷
        GetGMOrderMgr().AddCmd(orderId, gmCmdManger)
        # Ö´ÐÐÃüÁî
        gmCmdManger.GMToolCommand()
        
    except BaseException:
        mylog.info('GM cmd error - > %s'%(traceback.format_exc()))
        # ɾ³ý¸ÄgmÃüÁî
        GetGMOrderMgr().PopCmd(orderId)
        GMCommandResult(orderId, funcName, GMCommon.Def_GMDBEntranceFail)
        return 
   
    
    #test
    #ת·¢ËùÓÐÊý¾Ý¿â
#    SendDBRequest(CommonDefine.gstGMToolCmdSysDBRequest,OrderLen,OrderId,CmdLen,Cmd)
#    SendDBRequest(CommonDefine.gstGMToolCmdLogDBRequest,OrderLen,OrderId,CmdLen,Cmd)
#    SendDBRequest(CommonDefine.gstGMToolCmdUserDBRequest,OrderLen,OrderId,CmdLen,Cmd)
#    SendLogicProcessRequest(CommonDefine.gstGMToolCmdLogicProcessRequest,OrderLen,OrderId,CmdLen,Cmd)
    #ת·¢GameServer
    #SendGMToolCommandToGameServer(pack)
    
    #»Ø¸´GM¹¤¾ß
    #SendToGMToolCommandResult(OrderLen,OrderId,CmdLen,Cmd,UserDataLen,UserData)
        
    #-----------------------
    mylog.info('ProjSpecialProcess OnGMToolCommand Done')
    return

def OnGMToolCommandResult(pack):
    #GM¹¤¾ß½Ó¿ÚÃüÁî
    #¶ÁÈ¡·â°üÊý¾Ý
    sendpack = SendPackProtocol.tagGMCommandResult()
    sendpack.ReadData(pack.GetBuffer())
    
    
    
    #·µ»ØÐ޸ĺóµÄ°ü
    return pack

################
# Sys¿âÇëÇó´¦Àí  #
################
## Sys¿âÇëÇó´¦Àí
#  @param None 
#  @return None
def OnGMToolCmdSysDBRequest(sysdb,pack):
    mylog.info('ProjSpecialProcess OnGMToolCmdSysDBRequest IN')
    #¶ÁÈ¡·â°üÊý¾Ý
    recvPack = RecvPackProtocol.tagGMCommandDBRequest()
    recvPack.ReadData(pack.getBuffer())
    OrderLen = recvPack.OrderLen
    OrderId = recvPack.OrderId
    DataLen = recvPack.DataLen
    Data = recvPack.Data
    #-----------------------
    #ÏîÄ¿×é¶Ô×Ô¶¨ÒåÇëÇó½øÐд¦Àí
    #-----------------------
    
    
    
    #-----------------------
    mylog.info('ProjSpecialProcess OnGMToolCmdSysDBRequest Done')
    return


################
# Log¿âÇëÇó´¦Àí  #
################
## Log¿âÇëÇó´¦Àí
#  @param None 
#  @return None
def OnGMToolCmdLogDBRequest(logdb,pack):
    mylog.info('ProjSpecialProcess OnGMToolCmdLogDBRequest IN')
    #¶ÁÈ¡·â°üÊý¾Ý
    recvPack = RecvPackProtocol.tagGMCommandDBRequest()
    recvPack.ReadData(pack.getBuffer())
    OrderLen = recvPack.OrderLen
    OrderId = recvPack.OrderId
    DataLen = recvPack.DataLen
    Data = recvPack.Data
    #-----------------------
    #ÏîÄ¿×é¶Ô×Ô¶¨ÒåÇëÇó½øÐд¦Àí
    #-----------------------
    # ²éѯ·µ»Ø
    gmCmdOrderMgr = GetGMOrderMgr()
    cmdManger = gmCmdOrderMgr.GetCmd(OrderId)
    cmdManger.LogDBRequestResponse(logdb, Data)
    #-----------------------
    mylog.info('ProjSpecialProcess OnGMToolCmdLogDBRequest Done')
    return


################
# User¿âÇëÇó´¦Àí #
################
## User¿âÇëÇó´¦Àí
#  @param None 
#  @return None
def OnGMToolCmdUserDBRequest(userdb,pack):
    mylog.info('ProjSpecialProcess OnGMToolCmdUserDBRequest IN')
    #¶ÁÈ¡·â°üÊý¾Ý
    recvPack = RecvPackProtocol.tagGMCommandDBRequest()
    recvPack.ReadData(pack.getBuffer())
    OrderLen = recvPack.OrderLen
    OrderId = recvPack.OrderId
    DataLen = recvPack.DataLen
    Data = recvPack.Data
    #-----------------------
    #ÏîÄ¿×é¶Ô×Ô¶¨ÒåÇëÇó½øÐд¦Àí
    #-----------------------
    
    # ²éѯ·µ»Ø
    gmCmdOrderMgr = GetGMOrderMgr()
    cmdManger = gmCmdOrderMgr.GetCmd(OrderId)
    execType, execInfo = UpdatePackData(userdb, cmdManger)
    # Èç¹ûÊÇ´íÎóÀàÐÍÖ±½ÓÖ´Ðзµ»Ø½á¹û
    if execType < GMCommon.Def_ResultTypeMax:
        cmdManger.GMCmdExecuteResult(execType, execInfo)
        return
    cmdManger.UserDBRequestResponse(userdb, Data)    
    #-----------------------
    mylog.info('ProjSpecialProcess OnGMToolCmdUserDBRequest Done')
    return

## ¸üаüÊý¾Ý
#  @param None 
#  @return None
def UpdatePackData(userdb, gmCmdManger):
    
    # ¸öÈ˲¹³¥GM¹¤¾ß
    # ÓÉÓÚGameServer´¦Àí¶à¸öÍæ¼Ò²¹³¥Í¬Ò»ÎïƷʱֻÊÕÒ»´ÎÃüÁî°ü´¦Àí£¨Ö»²åÈëÒ»ÌõÎïÆ·Êý¾Ý£©
    # ¹Ê´Ë´¦ÏȲé³ö¶à¸öÍæ¼ÒÕ˺Å/êdzƶÔÓ¦µÄplayerID£¬¸ü¸ÄÃüÁî×ÖµäÐÅÏ¢ºó£¬Ñ¹Èë°ü£¬ÔÙÍƸøGameServer
    if gmCmdManger.funcName == "GMT_AddPersonalCompensation":
        gmCmdDict = gmCmdManger.gmCmdDict
        playerList = gmCmdDict.get("playerList", '')
        playerList = playerList.split(",")
        
        if not playerList:
            return GMCommon.Def_ParamErr, ''
    
        playerIDList = []
        queryType = gmCmdDict.get(GMCommon.Def_GMKey_QueryType, '')
        if queryType == GMCommon.Def_GMKey_FamilyID:
            # ¸ù¾Ý¼Ò×åIDµÄ²»´¦Àí£¬Ö±½ÓÍÆ
            return GMCommon.Def_SendToGameServer, ""
        
        playerFind = gmCmdDict.get(GMCommon.Def_GMKey_PlayerFind, '')
        
        for playerFind in playerList:
            playerAccID = ""
            # Íæ¼ÒÐÕÃû
            if queryType == GMCommon.Def_GMKey_PlayerName:
                playerAccID = GMCommon.GetPlayerAccID(userdb, {'PlayerName':fix_incomingText(playerFind), 'IsDeleted':0})
            
            elif queryType == GMCommon.Def_GMKey_PlayerAccID:
                playerAccID = GMCommon.GetPlayerAccID(userdb, {'AccID':fix_incomingText(playerFind), 'IsDeleted':0})
            
            if playerAccID == '':
                return GMCommon.Def_NoTag, "%s can not found!" % str(playerFind)
            
            collection = userdb[UCN_DBPlayer]   
            dbPlayer = DataServerPlayerData.tagDBPlayer()
            dbPlayer.IsDeleted = 0
        
            loadOK = dbPlayer.adoLoadCEx(collection, {'AccID':fix_incomingText(playerAccID),
                                                          'IsDeleted':dbPlayer.IsDeleted})    
            if not loadOK:
                return GMCommon.Def_NoTag, "%s can not found!" % str(playerFind)
            
            playerIDList.append(dbPlayer.PlayerID)
    
        gmCmdManger.gmCmdDictUnEncode["PlayerIDList"] = str(playerIDList)
        
        updatePack = RecvPackProtocol.tagGMCommand()
        updatePack.OrderId = str(gmCmdManger.orderId)
        updatePack.OrderLen = len(updatePack.OrderId)
        updatePack.Cmd = str(gmCmdManger.gmCmdDictUnEncode)
        updatePack.CmdLen = len(updatePack.Cmd)
        updatePack.UserData = str(gmCmdManger.userData)
        updatePack.UserDataLen = len(updatePack.UserData)
        
        # ¸üÐÂpackÊý¾Ý
        mmoRPGPack = MMORPGPack.MMORPGPacket()
        mmoRPGPack.setBuffer(updatePack.GetBuffer())
        gmCmdManger.pack = mmoRPGPack
    
    return GMCommon.Def_SendToGameServer, ""


################
#Âß¼­Ïß³ÌÇëÇó´¦Àí #
################
## Âß¼­Ïß³ÌÇëÇó´¦Àí
#  @param None 
#  @return None
def OnGMToolCmdLogicProcessRequest(pack):
    mylog.info('ProjSpecialProcess OnGMToolCmdLogicProcessRequest IN')
    #¶ÁÈ¡·â°üÊý¾Ý
    recvPack = RecvPackProtocol.tagGMCommandDBRequest()
    recvPack.ReadData(pack.getBuffer())
    OrderLen = recvPack.OrderLen
    OrderId = recvPack.OrderId
    DataLen = recvPack.DataLen
    Data = recvPack.Data
    #-----------------------
    #ÏîÄ¿×é¶Ô×Ô¶¨ÒåÇëÇó½øÐд¦Àí
    #-----------------------
    
    #-----------------------
    mylog.info('ProjSpecialProcess OnGMToolCmdLogicProcessRequest Done')
    return

################################################################## 


## gmÃüÁîÖ´ÐÐ
#
# gmÃüÁîÖ´ÐÐ
class GMCmdManger:
    
    ## ³õʼ»¯
    #  @param self
    #  @return ·µ»ØÖµ
    def __init__(self):
        self.Clear()
        return
    
    
    ## ³õʼ»¯
    #  @param self
    #  @return ·µ»ØÖµ
    def Clear(self):
        self.gmCmdDict = {}
        self.funcName = ''
        self.orderId = 0
        self.userData = None
        self.pack = None
        self.gmCmdDictUnEncode = {} # δתÂëµÄcmd£¬¸Ä°üʱºòÓÃ
        return
    
    ## ÊÕµ½ÃüÁ¿ªÊ¼Ö´ÐÐ
    #  @param self
    #  @return None
    def GMToolCommand(self):
        callFunc = GetExecFunc(Commands, "%s.%s"%(self.funcName, "OnExec"))
        
        execType = GMCommon.Def_SendToGameServer
        execInfo = ''
        if callFunc != None:
            execType, execInfo = callFunc(self.gmCmdDict)
        
        # Ö´Ðнá¹û´¦Àí
        self.GMCmdExecuteResult(execType, execInfo)
        
    ## ²éѯlogdb
    #  @param self
    #  @param logdb
    #  @param data:×Ô¶¨ÒåÊý¾Ý
    #  @return None
    def LogDBRequestResponse(self, logdb, data):        
        callFunc = GetExecFunc(Commands, "%s.%s"%(self.funcName, "LogDBResponse"))
        
        execType = GMCommon.Def_GMCmdNone
        execInfo = ''
        if callFunc != None:
            execType, execInfo = callFunc(logdb, data, self.gmCmdDict)
            
        # Ö´Ðнá¹û´¦Àí
        self.GMCmdExecuteResult(execType, execInfo)
        
    ## ²éѯuserdb
    #  @param self
    #  @param userdb
    #  @param data:×Ô¶¨ÒåÊý¾Ý
    #  @return None
    def UserDBRequestResponse(self, userdb, data):     
        callFunc = GetExecFunc(Commands, "%s.%s"%(self.funcName, "UserDBResponse"))
        
        execType = GMCommon.Def_GMCmdNone
        execInfo = ''
        if callFunc != None:
            execType, execInfo = callFunc(userdb, data, self.gmCmdDict)
        
        # Ö´Ðнá¹û´¦Àí
        self.GMCmdExecuteResult(execType, execInfo)

    ##¡¡Ö´Ðзµ»Ø½á¹û´¦Àí
    #  @param self
    #  @param execType:²Ù×÷ÀàÐÍ
    #  @param execInfo:×Ô¶¨ÒåÊý¾Ý
    #  @return None
    def GMCmdExecuteResult(self, execType, execInfo):
        
        if execType == GMCommon.Def_DoQueryLogDB:
            SendDBRequest(CommonDefine.gstGMToolCmdLogDBRequest,
                           len(self.orderId), self.orderId, len(execInfo), execInfo)
                
        elif execType == GMCommon.Def_DoQueryUserDB:
            SendDBRequest(CommonDefine.gstGMToolCmdUserDBRequest,
                           len(self.orderId), self.orderId, len(execInfo), execInfo)
            
        elif execType == GMCommon.Def_SendToGameServer:
            SendGMToolCommandToGameServer(self.pack)
            # ɾ³ý¸ÄgmÃüÁî
            GetGMOrderMgr().PopCmd(self.orderId)

        else:
            #gmÃüÁî»Ø¸´£¬ ɾ³ý¸ÄgmÃüÁî
            GetGMOrderMgr().PopCmd(self.orderId)
            GMCommandResult(self.orderId, self.funcName, execType, execInfo)
        return 
    
## gmÃüÁî¹ÜÀí
#
# gmÃüÁî¹ÜÀí 
class GMCmdOrderMgr:

    ## ³õʼ
    #  @param self
    #  @return None
    def __init__(self):
        self.__CmdOrderdict={} #key:OrderID,Value:GMCmdManger
        return
    
    ## Ìí¼Ó
    #  @param self
    #  @param orderId:gm±êʶ
    #  @param cmdManger:Ìí¼ÓµÄgmÃüÁî
    #  @return None
    def AddCmd(self, orderId, cmdManger):
        if orderId in self.__CmdOrderdict.keys():
            mylog.warning("orderId = %s already exists,New cmd = %d"%(orderId, cmdManger.funcName))
            return False
        
        self.__CmdOrderdict[orderId] = cmdManger
        return True


    ##ɾ³ý
    #  @param self
    #  @param orderId:gm±êʶ
    #  @return None
    def PopCmd(self, orderId):
        return self.__CmdOrderdict.pop(orderId, None)
    
    ##²éÕÒ
    #  @param self
    #  @param orderId:gm±êʶ
    #  @return None
    def GetCmd(self, orderId):
        return self.__CmdOrderdict.get(orderId, None)

## gmÃüÁî¹ÜÀí
#  @param None 
#  @return ÃüÁî¹ÜÀíÆ÷
def GetGMOrderMgr():
    global _GMCmdOrderMgr
    
    if _GMCmdOrderMgr != None:
        return _GMCmdOrderMgr
    
    _GMCmdOrderMgr = GMCmdOrderMgr()
    return _GMCmdOrderMgr 
    
    
## º¯Êýµ÷ÓÃ
#  @param curCallObj ʵÀý£¨¿ÉÄÜÊÇij¸öÎļþÃû£© 
#  @param callName ʵÀýµÄij¸öÊôÐÔ
#  @return ÊôÐÔ
def ParseNameGetObj(curCallObj, callName):
    callList = callName.split(".")
    if len(callList) <= 1:
        return None
    
    for curCallName in callList:
        if hasattr(curCallObj, curCallName) != True:
            #ÎÞ´ËÊôÐÔ
            return None
        
        curCallObj = getattr(curCallObj, curCallName)
        
    return curCallObj

## Íⲿµ÷ÓõĻñÈ¡ÊôÐÔ£¬ÇÒÊÇ¿ÉÒÔcallµÄ
#  @param curCallObj ʵÀý£¨¿ÉÄÜÊÇij¸öÎļþÃû£© 
#  @param callName ʵÀýµÄij¸öÊôÐÔ
#  @return ¿ÉÒÔcallµÄÊôÐÔ
#  @remarks º¯ÊýÏêϸ˵Ã÷.
def GetExecFunc(curCallObj, callName):
    curCallObj = ParseNameGetObj(curCallObj, callName)
    
    if curCallObj == None:
        return None
        
    if callable(curCallObj) != True:
        #²»¿Éµ÷ÓÃ
        return None
    
    return curCallObj    
    
    
## »Ø¸´gm
# @param db: dbGameUserÊý¾Ý
# @param gmCmdDict: gmÃüÁîÊý¾Ý
# @param resultType: ½á¹ûÀàÐÍ 
# @param strMsg: ½á¹ûÐÅÏ¢
# @param useData: 
# @return None 
def GMCommandResult(orderId, gmCmd, resultType, strMsg=None, useData=''):
    resultDcit = {GMCommon.Def_GMKey_Type:gmCmd,
                   GMCommon.Def_GMKey_ResultType:resultType,
                    GMCommon.Def_GMKey_ResultMsg:strMsg}
    
    resultMsg = json.dumps(resultDcit, ensure_ascii=False)
    
    mylog.info("gm result:%s"%resultMsg)
    SendToGMToolCommandResult(len(orderId), orderId, len(resultMsg), resultMsg, len(useData), useData)
    return


## ת»»±àÂë¸ñʽ
# @param gmCmdDict: gmÃüÁîÊý¾Ý
# @return None 
def ChangeEncodIng(gmCmdDict):
    cmdDict = {}
    
    coding = gmCmdDict.get('coding', '')
    if coding == '':
        return cmdDict
    
    for key, value in gmCmdDict.items():
        
        if not isinstance(value, str):
            continue
        
        # Ôö¼Óu
        try:
            value = value.replace("\r\n", "`r")
            value = value.replace("\'", "\\'")
            translateStr = eval("u'%s'"%value)
            translateStr = translateStr.encode(coding)
        except:
            mylog.info('translateStr error! srcStr = %s '%repr(value))
            return cmdDict
        
        cmdDict[key] = translateStr
        
    return cmdDict