#!/usr/bin/python
# -*- coding: GBK -*-
#
#
##@package RobotBase
# @todo: ÓÃÓÚ±£´æµ¥¸ö»úÆ÷ÈËʵÌåµÄÏà¹ØÊý¾ÝºÍÖ÷ÒªµÄ²Ù×÷½Ó¿Ú
#
# @author:Alee
# @date 2010-01-13 15:30
# @version 1.0

# ¼òҪ˵Ã÷: ÓÃÓÚ±£´æµ¥¸ö»úÆ÷ÈËʵÌåµÄÏà¹ØÊý¾ÝºÍÖ÷ÒªµÄ²Ù×÷½Ó¿Ú
# ÏêϸÃèÊö :None

import logging
from ConfigurationReader.RobotConfigParam import RobotConfigParams
from ConfigurationReader.ConfigIniReader import GetConfig
from AI import AIManager
import PlayerData
from binary.PyNetwork import *

from Protocol.PacketsSend import tagCClientPackVersion
from Protocol.PacketsSend import tagCFakePack, tagCGameServerGeneralPack

VER = "2010-01-13 15:30"

DUMP_NETWORK_USAGE = False


## RobotBase
#
# RobotBase
class RobotBase(object):
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def __init__(self, asioMgr, tokenInfo ):
        self.__mgr = asioMgr
        self.__peer = 0
        self.__reason = 0
        self.__params = tokenInfo
        self.__aimgr = AIManager.AIManager(self)
        self.__playerinfo = PlayerData.PlayerData()
        self.__isloginok = False
        self.__connectCnt = 0
        self.__destroy = False  # Òò¸÷ÖÖÒâÍâ·¢Éú¶Ï¿ª£¬Íâ²ã¹ÜÀíͨ¹ý´ËÅжÏÔÚ¶ÓÁÐÖÐÈ¥³ý
        if DUMP_NETWORK_USAGE:
            self.allrecv = 0
            self.allsend = 0
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def __del__(self):
        self.DestroyRobot()
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def __str__(self):
        return "Robot_%s" % self.GetRobotConfig()[1]
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def SetIsLoginOK(self,isloginok):
        self.__isloginok = isloginok
        if not isloginok:
            self.SetAIActive( ["AIOnlineReply"], False )
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None      
    def SetLastDisconnectReason(self, reason ):
        self.__reason = reason;
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def GetLastDisconnectReason(self):
        return self.__reason;
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def ClearDisconnectReason(self):
        self.SetLastDisconnectReason( 0 )
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def SetAIActive(self, aiList, bActive ):
        self.__aimgr.SetAIActive( aiList, bActive )
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def StatusString(self):
        statusStr = ""
        if self.GetIsLoginOK():
            statusStr += "LoginOK "
        else:
            statusStr += "NOT Login "
            
        if self.IsConnected():
            statusStr += "Connected "
        else:
            statusStr += "NOT Connected "
            
        if 0 != self.GetLastDisconnectReason():
            statusStr += "DisconnectReason:%d " % self.GetLastDisconnectReason()
            
            
        return statusStr
            
    # ¿ÉÒԴݻٵĶÔÏó
    def GetNeedDestroy(self):
        return self.__destroy
    
    def SetNeedDestroy(self, result):
        self.__destroy = result
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None 
    def GetIsLoginOK(self):
        return self.__isloginok
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def GetRobotConfig(self):
        #(token accid mac)
        return self.__params
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def SetPlayerInfo(self,playerinfo):
        self.__playerinfo = playerinfo
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def GetPlayerInfo(self):
        return self.__playerinfo    
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def GetAIMgr(self):
        return self.__aimgr
            
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None   
    def DestroyRobot(self):
        self.SetIsLoginOK( False )
        if 0 != self.__peer:
            self.__playerinfo = PlayerData.PlayerData()
            self.__mgr.DestroyPeer( self.__peer )
            self.__peer = 0
            return True
        else:
            return False
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def IsConnected(self):
        if 0 == self.__peer:
            return False
        else:
            return self.__mgr.IsConnected( self.__peer )
        
    ## ÖØÁ¬´ÎÊý
    #  @param None : None
    #  @return bool
    #  @remarks None
    def GetReconnectCount(self):
        return max( self.__connectCnt - 1, 0 )
        
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def GetPeerValue(self):
        #return 0
        return self.__mgr.GetValueOfPeer( self.__peer )
    
    
    ## RobotBase
    #  @param None : None
    #  @return bool
    #  @remarks None
    def ReCreateRobot(self):
        if self.IsConnected():
            logging.warning( "Robot is Connected, Click Disconnect first to reconnect." )
            return False
        
        
        if self.DestroyRobot():
            logging.warning( "0!=self.__peer, destroy it first on recreating robot..." )
            
        #´´½¨Á¬½Ó
        ip = GetConfig().GetServerIP()
        port = GetConfig().GetServerPort()
        logging.debug( "Connect to %s:%d", ip, port )
        self.__peer = self.__mgr.CreatePeer()
        logging.info( "create __peer:0x%08X",  self.GetPeerValue() )
        
        #×¢²á»Øµ÷
        logging.debug( "register callback function for 0x%08X" % self.GetPeerValue() )
        self.__mgr.RegisterCallback(self.__peer, Callback_Event_OnGetPacket, self.InternalOnPacket )
        self.__mgr.RegisterCallback(self.__peer, Callback_Event_OnPacketError, self._OnPacketError )
        self.__mgr.RegisterCallback(self.__peer, Callback_Event_OnPacketCRCError, self._OnPacketCRCError )
        self.__mgr.RegisterCallback(self.__peer, Callback_Event_OnOutputMsg, self._OnOutputMsg )
        self.__mgr.RegisterCallback(self.__peer, Callback_Event_OnSocketError, self._OnSocketError )
        self.__mgr.RegisterCallback(self.__peer, Callback_Event_OnConnected, self._OnConnected )
        
        #Æô¶¯AILoginout
        self.SetAIActive( [ "AILoginout" ], True )
        self.SetAIActive( [ "AIPlayerActPlayer" ], True )
        
        self.__mgr.ConnectPeer( self.__peer, ip, port )
        
        self.__connectCnt += 1
        
        #µ÷ÓÃÖØÔØʵÏÖ
        self._RecreateRobot()
        
        return True
        
    ## ¹©×ÓÀàÖØÔصÄÖØд´½¨»úÆ÷ÈËʵÏÖ
    #  @param None : None
    #  @return bool
    #  @remarks None
    def _RecreateRobot(self):
        pass
        

    ## ¿É¹©ÖØÔصÄÁ¬½Ó³É¹¦»Øµ÷º¯Êý
    #  @param None : None
    #  @return bool
    #  @remarks None   
    def _OnConnected(self):
        #logging.info( "robot connect successfully. peer 0x%08X" % self.GetPeerValue()  )
        
        clientPackVer = tagCClientPackVersion()
        clientPackVer.Version = GetConfig().GetVersionNo()
        logging.debug("tagCClientPackVersion %d"%(clientPackVer.Version)) 
        self.Send(clientPackVer)
        
        self.SetAIActive( ["AIOnlineReply"], True )
        #Æô¶¯AILoginIn
        #self.SetAIActive( [ "AILoginIn" ], True )
    
    
    ## ½âÎöµ½ÍêÕû°üºó»á»Øµ÷´Ëº¯Êý
    #  @param None : None
    #  @return bool
    #  @remarks None 
    def InternalOnPacket(self, data, dataLen ):
        if DUMP_NETWORK_USAGE:
            self.allrecv += dataLen
            #===================================================================
            # logging.debug( "%s receive %d bytes data. recvAll:%d sendAll:%d bytes ALL:%d" \
            #              % ( str(self), dataLen, self.allrecv, self.allsend, self.allrecv+self.allsend ) )
            #===================================================================
        self.__aimgr.OnPacketData(data, dataLen)
        #µ÷ÓÃ×ÓÀàµÄÖØÔØ
        self._OnPacket(data, dataLen)
    
    
    ## ¹©×ÓÀàÖØÔصĴ¦Àí·â°üµÄʵÏÖ
    #  @param None : None
    #  @return bool
    #  @remarks None 
    def _OnPacket(self, data, dataLen ):
        pass
    
    
    ## ¿ò¼ÜÖÜÆÚÐԻص÷´Ëº¯Êý
    #  @param None : None
    #  @return bool
    #  @remarks None
    def InternalOnProcess( self ):
        #µ÷ÓÃ×ÓÀàµÄÖØÔØ
        self._OnProcess()
    
    
    ## ¹©×ÓÀàÖØÔصĴ¦Àí·â°üµÄʵÏÖ
    #  @param None : None
    #  @return bool
    #  @remarks None
    def _OnProcess( self ):
        pass
    

    ## ֪ͨÍⲿÐÅÏ¢
    #  @param None : None
    #  @return bool
    #  @remarks None
    def _OnOutputMsg(self, msg, msglen ):
        pass
        #logging.debug( "Info outside msg:%s len:%d" % ( msg, msglen ) )
    
    
    ## ½â°ü´íÎó,¹©×ÓÀàÖØÔصĴ¦Àí·â°üµÄʵÏÖ
    #  @param None : None
    #  @return bool
    #  @remarks None
    def _OnPacketError(self, data, len ):
        logging.error( "ERROR in unpack data [%s] len:%d" % (data, len) )
     

    ## CRCУÑé´íÎó,¹©×ÓÀàÖØÔصĴ¦Àí·â°üµÄʵÏÖ
    #  @param None : None
    #  @return bool
    #  @remarks None
    def _OnPacketCRCError(self, crc, packet, len ):
        logging.error( "ERROR in crc checked. crc:%u packet[%s] len:%d" % (crc, packet, len) )
        
    
    ## ÍøÂç´íÎó,¹©×ÓÀàÖØÔصĴ¦Àí·â°üµÄʵÏÖ
    #  @param None : None
    #  @return bool
    #  @remarks None
    def _OnSocketError(self, ErrorMsg, ErrorOp ):
        logging.error( "ERROR in Socket. __peer:0x%08X ErrorMsg:%s ErrorOp:%d" % (self.GetPeerValue(), ErrorMsg, ErrorOp) )
        self.__destroy = True
    

    ## ·¢ËÍ,½Ó¿ÚµÄsendPackΪij¸ötagXXXÀàµÄʵÀý
    #  @param None : None
    #  @return bool
    #  @remarks None
    def Send(self, sendPack ):
        if DUMP_NETWORK_USAGE:
            self.allsend += sendPack.GetLength()
            logging.debug( "%s send %d bytes data. recvAll:%d sendAll:%d ALL:%d" % \
                          ( str(self), sendPack.GetLength(), self.allrecv, self.allsend, self.allrecv+self.allsend ) )
            
        try:
            self.__mgr.SendData( self.__peer, sendPack.GetBuffer(), sendPack.GetLength() )
        except:
            print self.__peer, sendPack.OutputString()
        
    
    ## py×Ô¶¨Òå°ümapserver°ü
    def SendMapServerPYPack(self, sendPack):
        pyPack = tagCFakePack()
        pyPack.Clear()
        buf = sendPack.GetBuffer()
        pyPack.MsgLen = len(buf)
        pyPack.Msg = buf
        
        if DUMP_NETWORK_USAGE:
            self.allsend += pyPack.GetLength()
        self.__mgr.SendData( self.__peer, pyPack.GetBuffer(), pyPack.GetLength() )
        
        
    ## py×Ô¶¨Òå°ügameserver°ü
    def SendGameServerPYPack(self, sendPack):
        pyPack = tagCGameServerGeneralPack()
        pyPack.Clear()
        buf = sendPack.GetBuffer()
        pyPack.DataLen = len(buf)
        pyPack.Data = buf
        
        if DUMP_NETWORK_USAGE:
            self.allsend += pyPack.GetLength()
        
        self.__mgr.SendData( self.__peer, pyPack.GetBuffer(), pyPack.GetLength() )