#!/usr/bin/python
# -*- coding: GBK -*-
#
##@package AIManager.py
# Ä£¿éµÄ¼òҪ˵Ã÷:AI¹ÜÀíÆ÷
# @author:ifo
# @date 2011-09-06 10:00
# @version 1.0
#
# change log:
#     ÐÞ¸ÄÄ£¿é£¬¶Ô´úÂë½øÐÐÓÅ»¯ÒÔ±ãÌá¸ßÐÔÄÜ        2011-9-6        Alee
#
# Ä£¿éÏêϸ˵Ã÷:AI¹ÜÀíÆ÷
#
#---------------------------------------------------------------------
#µ¼Èë
from Protocol import PacketsReceived, PacketsReceivedPY
import copy
import os
import logging

import ConfigurationReader.ConfigIniReader 


#Èç¹û²»ÔÚ¶àÏß³ÌÏÂÔËÐУ¬Ôò¹Ø±ÕÕâ¸öÏ¿ÉÒÔÌá¸ßЧÂÊ
RUN_IN_MT = True

import CommFunc

[
    IsNeedParser,
    RegForm,
    IsRegisted,
] = range(3)



def ImportPy( name, symbol ):
    #logging.debug( "ImportPy: from %s import %s" % ( name, symbol ) )
    mod = __import__( name, globals(), locals(), [symbol], -1)
    mod = getattr(mod, symbol )
    return mod

    

_AIManager__gAIPyMod = {}

def LoadAllAI():
    global _AIManager__gAIPyMod
    
    pyPath = os.getcwd()
    pyPath += "\\AI\\AIFile\\"
    logging.debug( "AIFile Path:%s" % pyPath )
    
    files = os.listdir(pyPath)
    for file in files:
        if len(file) < 2 or file[:2] != "AI":
            continue
        fileName = file.split( "." )[0]
        if _AIManager__gAIPyMod.has_key( fileName ):
            continue

        AIMod = ImportPy( "AI.AIFile."+fileName , fileName )
        _AIManager__gAIPyMod[fileName] = AIMod
    
LoadAllAI()

    
    
class AIManager():
    def __init__(self, robot):
        self.robot = robot
        self.PackDataDict = {}
        self.PackKeyDict = PacketsReceived.ChNetPackDict    #·â°ü×Öµä
        self.PYPackKeyDict = PacketsReceivedPY.ChNetPackDict

        config =  ConfigurationReader.ConfigIniReader.GetConfig()
        self.usePsyco = config.GetUsePsyco()
        
        self.aiInsts = []

        #³õʼ´´½¨»úÆ÷ÈËʱ£¬²»×Ô¶¯´´½¨ËùÓÐAIµÄʵÀý£¬¶øÊÇÔÚÊ×´ÎSetAIActiveΪTrueʱ¶¯Ì¬´´½¨
#        GenerateAIInstancesFunc = self.ApplyPsyco( self.GenerateAIInstances )
#        GenerateAIInstancesFunc()
        
    def ApplyPsyco(self, func ):
        if self.usePsyco:
            import psyco
            func = psyco.proxy( func )
        return func
        
    def GenerateAIInstances(self):
        for mod in __gAIPyMod.values(): 
            aiInst  = mod( self.robot )
            logging.debug( "Generate AI Instance %s for Robot(%s)" \
                           % ( aiInst.AIName(), str(self.robot)) )
            aiInst._RegisterPacket( self )
            self.aiInsts.append( aiInst )
    
    def GenerateAIInstance(self, aiName ):
        if __gAIPyMod.has_key( aiName ):
            aiInst = __gAIPyMod[aiName]( self.robot )
            logging.debug( "Generate AI Instance %s for Robot(%s)" \
                           % ( aiInst.AIName(), str(self.robot)) )
            aiInst._RegisterPacket( self )
            self.aiInsts.append( aiInst )
            return aiInst
        else:
            return None
        
            
    def ProcessAI(self):
        for aiInst in self.aiInsts:
            aiInst.Tick()
            
    def SetAIActive(self, aiNameList, bActive ):
        logging.debug( "SetAIActive(%s) for aiList:%s" % ( bActive, str(aiNameList) ) )
        bFind = False
        for aiName in aiNameList:
            for aiInst in self.aiInsts:
                if aiName == aiInst.AIName():
                    aiInst.SetActive( bActive )
                    bFind = True
                    break
            #ûÓÐÕÒµ½ÏàÓ¦µÄAI£¬³¢ÊÔ¶¯Ì¬´´½¨
            if ( not bFind ) and bActive:
                aiInstNew = self.GenerateAIInstance( aiName )
                if aiInstNew:
                    aiInstNew.SetActive( bActive )
                
        
    
    def RegNetMsg(self, packHead, callFuncName, isNeedParse = True):
        #䶨ÒåµÄ·â°üÍ·
        if packHead not in self.PackKeyDict and packHead not in self.PYPackKeyDict:
            return
        
        #²»¿Éµ÷ÓõĻص÷º¯Êý
        if not callable(callFuncName):
            return
    
        #´Ë·â°üµÄ×¢²áÐÅÏ¢×Öµä    
        curPackHeadRegList = self.PackDataDict.get(packHead, None)
        if curPackHeadRegList == None:
            curPackHeadRegList = [ False, [], False ]
            self.PackDataDict[packHead] = curPackHeadRegList
            
        #Ìí¼Ó±¾´Î×¢²á
        if callFuncName not in curPackHeadRegList[RegForm]:
            curPackHeadRegList[RegForm].append(callFuncName)
            
        #¸üд˷â°üµÄIsNeedParser״̬
        curPackHeadRegList[IsNeedParser] = curPackHeadRegList[IsNeedParser] or isNeedParse
        
        #¸üд˷â°üµÄIsRegisted״̬
        if not curPackHeadRegList[IsRegisted]:
            curPackHeadRegList[IsRegisted] = True
            
    def OnPacketData(self,serverPack, length = 0):
        OnPacket = self.ApplyPsyco( self.OnPacketDataInternal )

        OnPacket( serverPack, length )

            
    def OnPacketDataInternal(self,serverPack, length = 0):
        #·â°üÍ·½âÎö£¬ÓÅ»¯
        headData = serverPack[1] + serverPack[0]
        curPackHead = CommFunc.ReadWORD(headData, 0)[0]
            
        #È¡´Ë°üÍ·×¢²áÐÅÏ¢
        curPackHeadRegDict = self.PackDataDict.get(curPackHead, None)
        #ÎÞ´Ë·â°ü×¢²áÐÅÏ¢
        if curPackHeadRegDict == None:
            return
        
        #»ñÈ¡Ò»¸ö¿ÕµÄ·â°üʵÀý
        curPackData = self.PackKeyDict.get(curPackHead, None)
        if not curPackData:
            curPackData = self.PYPackKeyDict.get(curPackHead, None)
            if not curPackData:
                return

        #»áÔÚ¶àÏß³ÌÏÂÔËÐУ¬ËùÒÔ±ØÐë½øÐÐÉ±´
        if RUN_IN_MT:
            curPackData = copy.deepcopy(curPackData)
            
        #if curPackData.GetLength() != length:
        #    logging.warning( "ERROR length. Need:%d actually:%d  head=%s" % ( curPackData.GetLength(), length, curPackHead) )
        
        #½âÎö²¢·Ö·¢·â°ü
        needParse = curPackHeadRegDict[IsNeedParser]
        if needParse:
            curPackData.ReadData(serverPack)
        for regFormInfo in curPackHeadRegDict[RegForm]:
            regFormInfo(curPackData)