from json import dump,load
from struct import pack as compile_bytes, unpack, calcsize as struct_size

class RomStructure:
    format = "<"
    fields = "".split()
    def __init__(self,data):
        self.data=data
    def compile(self):
        return compile_bytes(self.format,*map(self.data.get,self.fields))
    @classmethod
    def size(self):return struct_size(self.format)
    @classmethod
    def decompile(self,bytes):
        return dict(zip(self.fields,unpack(self.format,bytes)))
    @classmethod
    def load_from(self,source,location):
        return self.decompile(source[location:location+self.size()])

class MapMetaStructure(RomStructure):
    format = "<IIIIHHBBBBHBB"
    fields =("map_data event_data map_scripts connection_header music index label "
            +"flash_thing weather type unknown show_label battle_type").split()

class MapConnectionStructure(RomStructure):
    format = "<IIBBH"
    fields = "type offset bank number filler".split()

class MapConnectionHeader(RomStructure):
    format = "<II"
    fields = "size location".split()

if __name__=="__main__":
    get_offset = lambda ptr:ptr&0x00FFFFFF
    from sys import argv;argv=argv[1:]
    from pprint import pprint
    i,end = 0,len(argv)
    while i<end:
        arg,i = argv[i],i+1
        if arg[arg.rfind("."):]==".gba":#found the Rom
            try: bytes = open(arg,'rb').read()#read the bytess
            except: raise
            else:
                while i<end:
                    arg,i = argv[i],i+1
                    try:offset = get_offset(int(arg,16))
                    except:raise
                    else:
                        data=MapMetaStructure.load_from(bytes,offset)
                        print("Map@",hex(offset))
                        for key,value in data.items():
                            if(isinstance(value,int)):print(key,hex(value))
                            else:print(key,value)
                            if key=='connection_header':
                                connection_header = MapConnectionHeader.load_from(bytes,get_offset(value))
                                print(connection_header['size'],"connections @",connection_header['location'])
                                for ci in range(connection_header['size']):
                                    offset = get_offset(connection_header['location']+ci*MapConnectionStructure.size())
                                    map_connection = MapConnectionStructure.load_from(bytes,offset)
                                    pprint(map_connection)
                        print("\nRecompiling:")
                        print(MapMetaStructure(data).compile())
                        print("="*80)