# -*- coding: GBK -*-
# ¶ÁÈ¡µØͼÇÐͼµã
# author: Alee
# Date: 2011.9.1
# history:  2011.9.1     Created

import string
import CommFunc
import binascii
import os
import logging
from ConfigurationReader import ConfigIniReader

DUMP_TRANSPORT = False


class  tagTransportRefresh:
    RefreshID = 0       # (DWORD RefreshID )
    MapID = 0       # (WORD MapID )
    PosX = 0        # (WORD PosX )     //×ø±ê
    PosY = 0        # (WORD PosY )
    Range = 0       # (WORD Range )     //·¶Î§
    TargetMapID = 0     # (WORD TargetMapID )     //Ä¿±êµØͼID
    TargetPosX = 0      # (WORD TargetPosX )     //Ä¿±ê×ø±ê
    TargetPosY = 0      # (WORD TargetPosY )
    count = 8
    def __init__(self):
        self.Clear()

        return
    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()

        self.RefreshID, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MapID, _pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosX, _pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosY, _pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Range, _pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TargetMapID, _pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TargetPosX, _pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TargetPosY, _pos = CommFunc.ReadWORD(_lpData, _pos)

        if _Len != 0 and _pos != _Len:
            logging.error("Error in tagTransportRefresh : %s "% binascii.b2a_hex(_lpData))
            return 0
        return _pos

    def Clear(self):
        self.RefreshID = 0
        self.MapID = 0
        self.PosX = 0
        self.PosY = 0
        self.Range = 0
        self.TargetMapID = 0
        self.TargetPosX = 0
        self.TargetPosY = 0
        self.count = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 2
        length += 2
        length += 2
        length += 2
        length += 2
        length += 2
        length += 2
        return  length;

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.RefreshID)
        data = CommFunc.WriteWORD(data, self.MapID)
        data = CommFunc.WriteWORD(data, self.PosX)
        data = CommFunc.WriteWORD(data, self.PosY)
        data = CommFunc.WriteWORD(data, self.Range)
        data = CommFunc.WriteWORD(data, self.TargetMapID)
        data = CommFunc.WriteWORD(data, self.TargetPosX)
        data = CommFunc.WriteWORD(data, self.TargetPosY)
        return data

    def ReadFromList(self, curList):
        self.RefreshID = CommFunc.ToIntDef(curList[0])
        self.MapID = CommFunc.ToIntDef(curList[1])
        self.PosX = CommFunc.ToIntDef(curList[2])
        self.PosY = CommFunc.ToIntDef(curList[3])
        self.Range = CommFunc.ToIntDef(curList[4])
        self.TargetMapID = CommFunc.ToIntDef(curList[5])
        self.TargetPosX = CommFunc.ToIntDef(curList[6])
        self.TargetPosY = CommFunc.ToIntDef(curList[7])
        self.count = 8
        return

    def __str__(self):
        DumpString = "Çл»µã¶¨Òå#tagTransportRefresh:"\
                            "RefreshID:%d,"\
                            "MapID:%d,"\
                            "PosX:%d,"\
                            "PosY:%d,"\
                            "Range:%d,"\
                            "TargetMapID:%d,"\
                            "TargetPosX:%d,"\
                            "TargetPosY:%d"\
                            %( \
                            self.RefreshID,\
                            self.MapID,\
                            self.PosX,\
                            self.PosY,\
                            self.Range,\
                            self.TargetMapID,\
                            self.TargetPosX,\
                            self.TargetPosY\
                            )

        return  DumpString
    
    
class TransportDataReader():
    def __init__(self, PyBaseRoot, mapDataPath ):
        self.__AllTransportData = {}
        
        mapTransportPath = os.path.join( PyBaseRoot, mapDataPath,'maptransport.txt' )
        f = file(mapTransportPath)
        lines = f.readlines()
        for line in lines:
            if line.strip() == '':
                continue
            items = line.split('\t')
            curData = tagTransportRefresh()
            if len(items) != 8:
                continue
            curData.ReadFromList(items)
            if self.__AllTransportData.has_key(curData.MapID) == False:
                self.__AllTransportData[curData.MapID] = []
            self.__AllTransportData[curData.MapID].append(curData)
        
    def GetAllTransportData(self):
        return self.__AllTransportData
    
    def GetTransportDataByMapID(self, mapID):
        if not self.__AllTransportData.has_key( mapID ):
            return []
        else:
            return self.__AllTransportData[mapID]
        
    def __str__(self):
        data = "TransportData Dump:\n"
        for mapID in self.__AllTransportData.keys():
            for transData in self.__AllTransportData[mapID]:
                data += str(transData)
                data += "\n"
        return data
    
    
__gTransportData = None

def ReadTransportData( PyBaseRoot ):
    global __gTransportData
    if not __gTransportData:
        __gTransportData =  TransportDataReader( PyBaseRoot,\
                         ConfigIniReader.GetConfig().GetMapFilePath())
        if DUMP_TRANSPORT:
            logging.debug( "%s", str(__gTransportData) )
        
        
def GetTransportData():
    global __gTransportData
    return __gTransportData