#!/usr/bin/env python3
import os
import sys
import asn1tools

def strformat(str) :
    newstr = str
    if 'long' == str :
        newstr = 'Long'
    if 'private' == str :
        newstr = 'private0'
    if '-' in str :
        newstr = str.replace('-', '_')

    return newstr 

class ASNCodec:
    def __init__(self, asn_file_name):
        self._asn_file = asn_file_name
        self._asn_support_types = ['BOOLEAN', 'INTEGER', 'BIT STRING']
        self._template_str = {}
        self._basic_type_definition = ''
        self._basic_type_transform_data_group = ''
        self._data_type_definition = ''

        self._data_type_h_fb = open('src/data_type.h', 'w')
        self._common_c_fb = open('src/common.c', 'w')
        self._common_h_fb = open('src/common.h', 'w')
        self._data_element_c_fb = open('src/data_element.c', 'w')
        self._data_element_h_fb = open('src/data_element.h', 'w')
        self._msg_frame_c_fb = open('src/msg_frame.c', 'w')
        self._msg_frame_h_fb = open('src/msg_frame.h', 'w')

        self.get_templates()

    def get_templates(self) -> None:
        for type in self._asn_support_types :
            template_str = {'c': '', 'h': ''}
            template_c_file = 'template/' + type + '.c'
            template_h_file = 'template/' + type + '.h'
            with open(template_c_file, 'r') as f:
                template_c_str = f.read()
                template_str['c'] = template_c_str
            with open(template_h_file, 'r') as f:
                template_h_str = f.read()
                template_str['h'] = template_h_str
            self._template_str[type] = template_str

    def write_common_c_file(self, str) -> None:
        self._common_c_fb.write(str)

    def write_common_h_file(self, str) -> None:
        self._common_h_fb.write(str)

    def update_common_file(self) -> None:
        template_common_c_str = ''
        template_common_h_str = ''
        template_data_type_h_str = ''

        with open('template/common.c', 'r') as f:
            template_common_c_str = f.read()

        with open('template/common.h', 'r') as f:
            template_common_h_str = f.read()

        with open('template/data_type.h', 'r') as f:
            template_data_type_h_str = f.read()

        self.write_common_h_file(template_common_h_str.replace('template', self._basic_type_definition))
        self.write_common_c_file(template_common_c_str.replace('template', self._basic_type_transform_data_group))

        self._data_type_h_fb.write(template_data_type_h_str.replace('template', self._data_type_definition))

    def write_element_c_file(self, str) -> None:
        self._data_element_c_fb.write(str)

    def write_element_h_file(self, str) -> None:
        self._data_element_h_fb.write(str)

    def handle_asn_type_bitstring(self, name, value) ->None :
        # bitstring type definition
        data_mask_type_str = ''
        size_str = ''
        bits_unused_str = ''
        template_str = ''

        bitstring_type_definiton_str = '\n/* DE_'+ name +' union */\n'
        bitstring_type_definiton_str += 'typedef union _DE_'+ name +'_t\n'
        bitstring_type_definiton_str += '{\n'
        
        if value['size'][0] <= 8 :
            data_mask_type_str = 'uint8_t'
            size_str = '1'
            bits_unused_str = str(8 - value['size'][0])
            bitstring_type_definiton_str += '    uint8_t word;\n'
            bitstring_type_definiton_str += '    struct {\n'
            bitstring_type_definiton_str += '#if(__BYTE_ORDER == __LITTLE_ENDIAN)\n'
            for member in value['named-bits'] :
                bitstring_type_definiton_str += '        uint8_t '+ strformat(member[0]) +' :1;\n'
            if len(value['named-bits']) < 8 :
                reserved_member_count = 8 - len(value['named-bits'])
                bitstring_type_definiton_str += '        uint8_t reserveds :'+ str(reserved_member_count) +';\n'
            # else
            bitstring_type_definiton_str += '#elif(__BYTE_ORDER == __BIG_ENDIAN)\n'
            if len(value['named-bits']) < 8 :
                reserved_member_count = 8 - len(value['named-bits']) 
                bitstring_type_definiton_str += '        uint8_t reserveds :'+ str(reserved_member_count) +';\n'
            for i in range(0, value['named-bits'].__len__())[::-1] :
                bitstring_type_definiton_str += '        uint8_t '+ strformat(value['named-bits'][i][0]) +' :1;\n'
            bitstring_type_definiton_str += '#else\n'
        elif value['size'][0] <= 16 :
            data_mask_type_str = 'uint16_t'
            size_str = '2'
            bits_unused = 16 - value['size'][0]
            bits_unused_str =  str(bits_unused)
            bitstring_type_definiton_str += '    uint16_t word;\n'
            bitstring_type_definiton_str += '    struct {\n'
            bitstring_type_definiton_str += '#if(__BYTE_ORDER == __LITTLE_ENDIAN)\n'
            for member in value['named-bits'] :
                bitstring_type_definiton_str += '        uint8_t '+ strformat(member[0]) +' :1;\n'
            if len(value['named-bits']) < 16 :
                reserved_member_count = 16 - len(value['named-bits'])
                bitstring_type_definiton_str += '        uint8_t reserveds :'+ str(reserved_member_count) +';\n'
            # else
            bitstring_type_definiton_str += '#elif(__BYTE_ORDER == __BIG_ENDIAN)\n'
            if len(value['named-bits']) < 16 :
                reserved_member_count = 16 - len(value['named-bits']) 
                bitstring_type_definiton_str += '        uint8_t reserveds :'+ str(reserved_member_count) +';\n'
            for i in range(0, value['named-bits'].__len__())[::-1] :
                bitstring_type_definiton_str += '        uint8_t '+ strformat(value['named-bits'][i][0]) +' :1;\n'
            bitstring_type_definiton_str += '#else\n'
        elif value['size'][0] <= 32 :
            data_mask_type_str = 'uint32_t'
            size_str = '4'
            bits_unused_str = str(32 - value['size'][0])

            bitstring_type_definiton_str += '    uint32_t word;\n'
            bitstring_type_definiton_str += '    struct {\n'
            bitstring_type_definiton_str += '#if(__BYTE_ORDER == __LITTLE_ENDIAN)\n'
            for member in value['named-bits'] :
                bitstring_type_definiton_str += '        uint8_t '+ strformat(member[0]) +' :1;\n'
            if len(value['named-bits']) < 32 :
                reserved_member_count = 32 - len(value['named-bits'])
                bitstring_type_definiton_str += '        uint8_t reserveds :'+ str(reserved_member_count) +';\n'
            # else
            bitstring_type_definiton_str += '#elif(__BYTE_ORDER == __BIG_ENDIAN)\n'
            if len(value['named-bits']) < 32 :
                reserved_member_count = 32 - len(value['named-bits'])
                bitstring_type_definiton_str += '        uint8_t reserveds :'+ str(reserved_member_count) +';\n'
            for i in range(0, value['named-bits'].__len__())[::-1] :
                bitstring_type_definiton_str += '        uint8_t '+ strformat(value['named-bits'][i][0]) +' :1;\n'
            bitstring_type_definiton_str += '#else\n'
        elif value['size'][0] <= 64 :
            data_mask_type_str = 'uint64_t'
            size_str = 8
            bits_unused_str = str(64 - value['size'][0])
            bitstring_type_definiton_str += '    uint64_t word;\n'
            bitstring_type_definiton_str += '    struct {\n'
            bitstring_type_definiton_str += '#if(__BYTE_ORDER == __LITTLE_ENDIAN)\n'
            for member in value['named-bits'] :
                bitstring_type_definiton_str += '        uint8_t '+ strformat(member[0]) +' :1;\n'
            if len(value['named-bits']) < 64 :
                reserved_member_count = 64 - len(value['named-bits']) 
                bitstring_type_definiton_str += '        uint8_t reserveds :'+ str(reserved_member_count) +';\n'
            # else
            bitstring_type_definiton_str += '#elif(__BYTE_ORDER == __BIG_ENDIAN)\n'
            if len(value['named-bits']) < 64 :
                reserved_member_count = 64 - len(value['named-bits'])
                bitstring_type_definiton_str += '        uint8_t reserveds :'+ str(reserved_member_count) +';\n'
            for i in range(0, value['named-bits'].__len__())[::-1] :
                bitstring_type_definiton_str += '        uint8_t '+ strformat(value['named-bits'][i][0]) +'            :1;\n'
            bitstring_type_definiton_str += '#else\n'
        
        bitstring_type_definiton_str += '#error Endian undefined!!!\n'
        bitstring_type_definiton_str += '#endif\n'
        bitstring_type_definiton_str += '    } bit;\n'
        bitstring_type_definiton_str += '} DE_'+ name +'_t, *DE_'+ name +'_t_ptr;\n'


        self._data_type_definition += bitstring_type_definiton_str

        template_str = self._template_str[value['type']]['c'].replace('template0', data_mask_type_str)
        template_str = template_str.replace('template1', size_str)
        template_str = template_str.replace('template2', bits_unused_str)
        
        # handle encode
        template3_str = ''
        template4_str = ''
        if value['size'][0] <= 8 :
            # handle encode
            for member in value['named-bits'] :
                template3_str += '    data_mask = (Element_ptr->bit.'+ strformat(member[0]) +' << '+ str(8 - int(member[1])) +');\n'
            template3_str += '    element_ptr->buf[0] = (data_mask & 0xFF);\n'

            # handle decode
            template4_str += '    data_mask = element_ptr->buf[0];\n'
            template4_str += '    /* Decode data mask to bits . */\n'
            for member in value['named-bits'] :
                template4_str += '    Element_ptr->bit.'+ strformat(member[0]) +' = (data_mask >> '+ str(8 - int(member[1])) +') & 0x01;\n'
        elif value['size'][0] <= 16 :
            # handle encode
            for member in value['named-bits'] :
                template3_str += '    data_mask |= (Element_ptr->bit.'+ strformat(member[0]) +' << '+ str(16 - int(member[1])) +');\n'
            template3_str += '    element_ptr->buf[0] = ((data_mask >> 8) & 0x00FF);\n'
            template3_str += '    element_ptr->buf[1] = (data_mask & 0xFF);\n'

            # handle decode
            template4_str += '    data_mask = element_ptr->buf[0];\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[1]);\n'
            template4_str += '    /* Decode data mask to bits . */\n'
            for member in value['named-bits'] :
                template4_str += '    Element_ptr->bit.'+ strformat(member[0]) +' = (data_mask >> '+ str(16 - int(member[1])) +') & 0x01;\n'
        elif value['size'][0] <= 32 :
            # handle encode
            for member in value['named-bits'] :
                template3_str += '    data_mask |= (Element_ptr->bit.'+ strformat(member[0]) +' << '+ str(32 - int(member[1])) +');\n'
            template3_str += '    element_ptr->buf[0] = ((data_mask >> 24) & 0xFF);\n'
            template3_str += '    element_ptr->buf[1] = ((data_mask >> 16) & 0xFF);\n'
            template3_str += '    element_ptr->buf[2] = ((data_mask >>  8) & 0xFF);\n'
            template3_str += '    element_ptr->buf[3] = (data_mask & 0xFF);\n'
            # handle decode
            template4_str += '    data_mask = element_ptr->buf[0];\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[1]);\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[2]);\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[3]);\n'
            template4_str += '    /* Decode data mask to bits . */\n'
            for member in value['named-bits'] :
                template4_str += '    Element_ptr->bit.'+ strformat(member[0]) +' = (data_mask >> '+ str(32 - int(member[1])) +') & 0x01;\n'
        elif value['size'][0] <= 64 :
            # handle encode
            for member in value['named-bits'] :
                template3_str += '    data_mask |= (Element_ptr->bit.'+ strformat(member[0]) +' << '+ str(32 - int(member[1])) +');\n'

            template3_str += '    element_ptr->buf[0] = ((data_mask >> 56) & 0xFF);\n'
            template3_str += '    element_ptr->buf[1] = ((data_mask >> 48) & 0xFF);\n'
            template3_str += '    element_ptr->buf[2] = ((data_mask >> 40) & 0xFF);\n'
            template3_str += '    element_ptr->buf[3] = ((data_mask >> 32) & 0xFF);\n'
            template3_str += '    element_ptr->buf[4] = ((data_mask >> 24) & 0xFF);\n'
            template3_str += '    element_ptr->buf[5] = ((data_mask >> 16) & 0xFF);\n'
            template3_str += '    element_ptr->buf[6] = ((data_mask >>  8) & 0xFF);\n'
            template3_str += '    element_ptr->buf[7] = (data_mask & 0xFF);\n'
            # handle decode
            template4_str += '    data_mask = element_ptr->buf[0];\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[1]);\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[2]);\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[3]);\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[4]);\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[5]);\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[6]);\n'
            template4_str += '    data_mask = ((data_mask << 8) | element_ptr->buf[7]);\n'
            template4_str += '    /* Decode data mask to bits . */\n'
            for member in value['named-bits'] :
                template4_str += '    Element_ptr->bit.'+ strformat(member[0]) +' = (data_mask >> '+ str(64 - int(member[1])) +') & 0x01;\n'
        template_str = template_str.replace('template3', template3_str)
        template_str = template_str.replace('template4', template4_str)
        template_str = template_str.replace('template', strformat(name))

        self.write_element_c_file(template_str)

        template_str = self._template_str[value['type']]['h'].replace('template', strformat(name))
        self.write_element_h_file(template_str)

    def handle_asn_type(self, name, value) -> None:
        if 'INTEGER' == value['type'] :
            # self.write_element_h_file('typedef long DE_' + name + '_t;\n')
            # self.write_common_h_file()
            self._data_type_definition += 'typedef double DE_' + strformat(name) + '_t;\n'

            self._basic_type_definition += '    DE_'+ strformat(name) +',\n'
            self._basic_type_transform_data_group += '    {          1,           1,           0,          1.0,          1.0  }, /* DE_' + name + '. Unit: 1 day & 1 day. */}\n'

            template_str = self._template_str[value['type']]['c'].replace('template', strformat(name))
            self.write_element_c_file(template_str)

            template_str = self._template_str[value['type']]['h'].replace('template', strformat(name))
            self.write_element_h_file(template_str)
        elif 'BIT STRING' == value['type'] :
            self.handle_asn_type_bitstring(strformat(name), value)
        elif 'ENUMERATED' == value['type'] :
            print('ENUMERATED')
        elif 'BOOLEAN' == value['type'] :
            # self.write_element_h_file('typedef long DE_' + name + '_t;\n')
            # self.write_common_h_file()
            self._data_type_definition += 'typedef uint8_t DE_' + name + '_t;\n'

            template_str = self._template_str[value['type']]['c'].replace('template', name)
            self.write_element_c_file(template_str)

            template_str = self._template_str[value['type']]['h'].replace('template', name)
            self.write_element_h_file(template_str)


    def handle_asn_imports(self, imports) -> None:
        print('')

    def handle_asn_types(self, types) -> None:
        for key, value in types.items() :
            # print('{} {}'.format(key, value))
            self.handle_asn_type(key, value)

    def handle_asn_values(self, values) -> None:
        print('')

    def handle_asn_object_classes(self, classes) -> None:
        print('')

    def handle_asn_object_sets(self, sets) -> None:
        print('')

    def handle_asn_module(self, module) -> None:
        for key, value in module.items():
            if "imports" == key :
                self.handle_asn_imports(value)
            elif "types" == key :
                self.handle_asn_types(value)
            elif "values" == key :
                self.handle_asn_values(value)
            elif "object-classes" == key :
                self.handle_asn_object_classes(value)
            elif "object-sets" == key :
                self.handle_asn_object_sets(value)
            # print('key:{} value:{}'.format(key, value))

    def handle(self) :
        with open(self._asn_file) as fin:
            asnmodules = asn1tools.parse_string(fin.read())
            for key, value in asnmodules.items() :
                self.handle_asn_module(value)
            # print(asninfos)
        self.update_common_file()

def main(argv):
    # os.makedirs('src',exist_ok=True)
    # os.makedirs('src/codec',exist_ok=True)

    # with open('src/codec/data_element.c', 'w+') as f:
    #     f.write('hello world')
    #     f.write('hello world0000')
    #     f.close()
    asn_handle = ASNCodec('CSAE-157-2020.asn')
    asn_handle.handle()




if __name__ == '__main__':
    main(sys.argv[1:])