#!/usr/bin/python
# -*- coding: GBK -*-
#×÷Õߣºifo
# Change Log: ÐÞ¸ÄÀà¼Ü¹¹        2011-9-9    Alee

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

DUMP_MAPDATA = False


class  tagFLCOMMONHEADERS:
    
    Signature = 0       # (DWORD Signature )     // ±êÖ¾
    Numbering = 0       # (DWORD Numbering )     // 񅧏
    OSVersion = 0       # (DWORD OSVersion )     // °æ±¾
    Copyright = ""      # (char Copyright[64] )     // °æȨÉùÃ÷
    CreationTime = 0        # (double CreationTime )     // ´´½¨Ê±¼ä
    LastWriteTime = 0       # (double LastWriteTime )     // ×îºóÒ»´ÎÐÞ¸Äʱ¼ä
    BuildVersion = 0        # (DWORD BuildVersion )     // ¸Äд´ÎÊý
    Ressource = 0       # (DWORD Ressource )     // ×ÊÔ´ÀàÐÍ
    ResVersion = 0      # (DWORD ResVersion )     // ×ÊÔ´°æ±¾
    AddonsResCount = 0      # (DWORD AddonsResCount )     // ¸½¼Ó×ÊÔ´ÊýÁ¿
    Reserved = ""       # (char Reserved[20] )     // ¶ÔÆëÖÁ 128 byte(s)
    
    def __init__(self):
        self.Clear()

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

        self.Signature, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Numbering, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.OSVersion, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Copyright, _pos = CommFunc.ReadString(_lpData, _pos, 64)
        self.CreationTime, _pos = CommFunc.ReadDouble(_lpData, _pos)
        self.LastWriteTime, _pos = CommFunc.ReadDouble(_lpData, _pos)
        self.BuildVersion, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Ressource, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ResVersion, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AddonsResCount, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Reserved, _pos = CommFunc.ReadString(_lpData, _pos, 20)

        if _Len != 0 and _pos != _Len:
            Log4P.Warn("Error in tagFLCOMMONHEADERS : %s "% binascii.b2a_hex(_lpData))
            return 0
        return _pos

    def Clear(self):
        self.Signature = 0
        self.Numbering = 0
        self.OSVersion = 0
        self.Copyright = ""
        self.CreationTime = 0
        self.LastWriteTime = 0
        self.BuildVersion = 0
        self.Ressource = 0
        self.ResVersion = 0
        self.AddonsResCount = 0
        self.Reserved = ""
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 4
        length += 64
        length += 8
        length += 8
        length += 4
        length += 4
        length += 4
        length += 4
        length += 20
        return  length;

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Signature)
        data = CommFunc.WriteDWORD(data, self.Numbering)
        data = CommFunc.WriteDWORD(data, self.OSVersion)
        data = CommFunc.WriteString(data, 64, self.Copyright)
        data = CommFunc.WriteDouble(data, self.CreationTime)
        data = CommFunc.WriteDouble(data, self.LastWriteTime)
        data = CommFunc.WriteDWORD(data, self.BuildVersion)
        data = CommFunc.WriteDWORD(data, self.Ressource)
        data = CommFunc.WriteDWORD(data, self.ResVersion)
        data = CommFunc.WriteDWORD(data, self.AddonsResCount)
        data = CommFunc.WriteString(data, 20, self.Reserved)
        return data

    def OutputString(self):
        DumpString = ''':
                            Signature:%d,
                            Numbering:%d,
                            OSVersion:%d,
                            Copyright:%s,
                            CreationTime:%d,
                            LastWriteTime:%d,
                            BuildVersion:%d,
                            Ressource:%d,
                            ResVersion:%d,
                            AddonsResCount:%d,
                            Reserved:%s
                            '''\
                            %(
                            self.Signature,
                            self.Numbering,
                            self.OSVersion,
                            self.Copyright,
                            self.CreationTime,
                            self.LastWriteTime,
                            self.BuildVersion,
                            self.Ressource,
                            self.ResVersion,
                            self.AddonsResCount,
                            self.Reserved
                            )

        return  DumpString


#ÕÏ°­±íÐÅÏ¢
class  tagMapObs:
    Width = 0       # (DWORD Width )
    Height = 0      # (DWORD Height )
    def __init__(self):
        self.Clear()

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

        self.Width, _pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Height, _pos = CommFunc.ReadDWORD(_lpData, _pos)

        if _Len != 0 and _pos != _Len:
            Log4P.Warn("Error in tagMapObs : %s "% binascii.b2a_hex(_lpData))
            return 0
        return _pos

    def Clear(self):
        self.Width = 0
        self.Height = 0
        return

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

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Width)
        data = CommFunc.WriteDWORD(data, self.Height)
        return data

    def OutputString(self):
        DumpString = ''':
                            Width:%d,
                            Height:%d
                            '''\
                            %(
                            self.Width,
                            self.Height
                            )

        return  DumpString
    
    
class   MapNameInfoType:
    def __init__(self):
        self.MapFileName = ''
        self.MapID = 0
        self.MapName = ''
    
    def ReadFromList(self, curList):
        self.MapFileName = curList[0]
        self.MapID = CommFunc.ToIntDef(curList[1])
        self.MapName = curList[2]
        return
    
    def __str__(self):
        DumpString = "MapFileName:%s," \
                            "MapID:%d," \
                            "MapName:%s" \
                            %( \
                            self.MapFileName, \
                            self.MapID, \
                            self.MapName \
                            )

        return  DumpString
    
    
class MapData():
    def __init__(self, mapID):
        self.aStarPath = IPY_AStar.IPY_AStar()
        self.mapDataHead = tagFLCOMMONHEADERS()
        self.mapObs = tagMapObs()
        self.mapID = mapID

    def GetAStarPath(self):
        return self.aStarPath
    
    def ReadFromFile(self, filepath ):
        f = open(filepath,'rb')
        buf = f.read()
        pos = self.mapDataHead.ReadData(buf)
        pos = self.mapObs.ReadData(buf, pos)
        
        obsPos = pos
        self.DataList=[]#mapdatalist
        for j in range(self.mapObs.Height):
            self.DataList.append([])
            for i in range(self.mapObs.Width):
                curValue, pos = CommFunc.ReadBYTE(buf, pos)
                self.DataList[j].append(curValue)
                
        mapObsData, pos = CommFunc.ReadString(buf, obsPos, len(buf) - obsPos)
    
        #ÉèÖÃÕÏ°­±í
        self.aStarPath.SetMap(mapObsData, self.mapObs.Width, self.mapObs.Height)
        
        
    
    #Check Is Block    
    def IsBlockPoint( self,posX, posY ):  
        data = self.GetMapFilePointValue( posX, posY )
        if not data:
            return True
        
        return 0 != data
             
    def __str__(self):
        data="MapDataDump:\n MapID:%d Width:%d Height:%d\n" \
            % ( self.mapID, self.mapObs.Width, self.mapObs.Height )
        for y in range(len(self.DataList)):
            for x in range(len(self.DataList[y])):
                data += str(self.DataList[y][x])
            data+="\n"

        return data
        
    #return mapPointValue
    def GetMapFilePointValue(self, posX, posY):
        if posY >= self.mapObs.Height \
            or posX >= self.mapObs.Width:
            logging.warning( "Out of Range in map:%d pos:(%d,%d)" % ( self.mapID, posX, posY ))
            return None
        
        return self.DataList[posY][posX]
    
        
    
class MapDataReader:
    def __init__(self, PyBaseRoot, mapsPath, postFix ):
        self.mapNameInfo = {}
        self.mapDataDict = {}
        self.mapsPath = PyBaseRoot + mapsPath
        self.postFix = postFix
        
        self.ReadMapIDTxt()
        self.ReadAllMapData()
             
    def ReadMapIDTxt(self ):
        mapIdTxtPath = os.path.join(self.mapsPath, 'MapID.txt')
        logging.debug( "MapID.txt path:%s" % mapIdTxtPath )
        f = file(mapIdTxtPath)
        mapTxt = f.readlines()
        for line in mapTxt:
            curList = line.split('\t')
            infoType = MapNameInfoType()
            infoType.ReadFromList(curList)
            self.mapNameInfo[infoType.MapID] = infoType
            logging.debug( "Dump....%s" % str(infoType) )
            
    def ReadAllMapData(self):
        for mapID in self.mapNameInfo.keys():
            self.mapDataDict[mapID] = self.__ReadMapData( mapID )
    
    def __ReadMapData( self, mapID ):
        curMapPath = os.path.join(self.mapsPath, self.mapNameInfo[mapID].MapFileName + self.postFix)
        logging.debug( "MapFileReader: reading [%d]%s ..." % ( mapID, curMapPath ) ) 
        data = MapData( mapID )
        data.ReadFromFile( curMapPath )
        return data
    
    def GetMapDataByID(self,mapID):
        return self.mapDataDict[mapID]
    
    def GetAllMapData(self):
        return self.mapDataDict
    
    #Check Is Block    
    def IsBlockPoint(self,mapID,posX,posY):  
        mapData = self.GetMapDataByID(mapID)
        if not mapList:
            logging.warning( "NO DATA for map %d" % mapID )
            return True
        return mapData.IsBlockPoint( posX, posY )
    

    def __str__(self):
        data = "MapPath:%s\n" % self.mapsPath
        data += "MapFilePostFix:%s\n" % self.postFix
        data += "MapNameInfo:\n"
        for mapID in self.mapNameInfo.keys():
            data += "%d:%s\n" %( mapID, str(self.mapNameInfo[mapID]) )
        for mapID in self.mapDataDict.keys():
            data += "%d:%s\n" % ( mapID, str(self.mapDataDict[mapID]) )
        return data
        
    

__gRobotsMapData = None

def ReadMapData( PyBaseRoot,):
    global __gRobotsMapData
    if not __gRobotsMapData:
        __gRobotsMapData =  MapDataReader( PyBaseRoot, ConfigIniReader.GetConfig().GetMapFilePath(),\
                                          ConfigIniReader.GetConfig().GetMapFilePostFix())
        if DUMP_MAPDATA:
            logging.debug( "%s", str(__gRobotsMapData) )
        
        
def GetMapData():
    global __gRobotsMapData
    return __gRobotsMapData


        
if __name__ == "__main__":
    pass