# This file is used to process section data generated by `objdump -s`
import re


class Section(object):
    """
    One Section of section table. contains info about section name, address and raw data
    """
    SECTION_START_PATTERN = re.compile(b'Contents of section (.+?):')
    DATA_PATTERN = re.compile(b'([0-9a-f]{4,8})')

    def __init__(self, name, start_address, data):
        self.name = name
        self.start_address = start_address
        self.data = data

    def __contains__(self, item):
        """ check if the section name and address match this section """
        if (item['section'] == self.name or item['section'] == 'any') \
                and (self.start_address <= item['address'] < (self.start_address + len(self.data))):
            return True
        else:
            return False

    def __getitem__(self, item):
        """
        process slice.
        convert absolute address to relative address in current section and return slice result
        """
        if isinstance(item, int):
            return self.data[item - self.start_address]
        elif isinstance(item, slice):
            start = item.start if item.start is None else item.start - self.start_address
            stop = item.stop if item.stop is None else item.stop - self.start_address
            return self.data[start:stop]
        return self.data[item]

    def __str__(self):
        return '%s [%08x - %08x]' % (self.name, self.start_address, self.start_address + len(self.data))

    __repr__ = __str__

    @classmethod
    def parse_raw_data(cls, raw_data):
        """
        process raw data generated by `objdump -s`, create section and return un-processed lines
        :param raw_data: lines of raw data generated by `objdump -s`
        :return: one section, un-processed lines
        """
        name = ''
        data = ''
        start_address = 0
        # first find start line
        for i, line in enumerate(raw_data):
            if b'Contents of section ' in line:  # do strcmp first to speed up
                match = cls.SECTION_START_PATTERN.search(line)
                if match is not None:
                    name = match.group(1)
                    raw_data = raw_data[i + 1:]
                    break
        else:
            # do some error handling
            raw_data = [b'']  # add a dummy first data line

        def process_data_line(line_to_process):
            # first remove the ascii part
            hex_part = line_to_process.split(b'  ')[0]
            # process rest part
            data_list = cls.DATA_PATTERN.findall(hex_part)
            try:
                _address = int(data_list[0], base=16)
            except IndexError:
                _address = -1

            def hex_to_str(hex_data):
                if len(hex_data) % 2 == 1:
                    hex_data = b'0' + hex_data  # append zero at the beginning
                _length = len(hex_data)
                return ''.join([chr(int(hex_data[_i:_i + 2], base=16))
                                for _i in range(0, _length, 2)])

            return _address, ''.join([hex_to_str(x) for x in data_list[1:]])

        # handle first line:
        address, _data = process_data_line(raw_data[0])
        if address != -1:
            start_address = address
            data += _data
            raw_data = raw_data[1:]
            for i, line in enumerate(raw_data):
                address, _data = process_data_line(line)
                if address == -1:
                    raw_data = raw_data[i:]
                    break
                else:
                    data += _data
        else:
            # do error handling
            raw_data = []

        section = cls(name, start_address, data) if start_address != -1 else None
        unprocessed_data = None if len(raw_data) == 0 else raw_data
        return section, unprocessed_data


class SectionTable(object):
    """ elf section table """

    def __init__(self, file_name):
        with open(file_name, 'rb') as f:
            raw_data = f.readlines()
        self.table = []
        while raw_data:
            section, raw_data = Section.parse_raw_data(raw_data)
            self.table.append(section)

    def get_unsigned_int(self, section, address, size=4, endian='LE'):
        """
        get unsigned int from section table
        :param section: section name; use "any" will only match with address
        :param address: start address
        :param size: size in bytes
        :param endian: LE or BE
        :return: int or None
        """
        if address % 4 != 0 or size % 4 != 0:
            print('warning: try to access without 4 bytes aligned')
        key = {'address': address, 'section': section}
        for section in self.table:
            if key in section:
                tmp = section[address:address + size]
                value = 0
                for i in range(size):
                    if endian == 'LE':
                        value += ord(tmp[i]) << (i * 8)
                    elif endian == 'BE':
                        value += ord(tmp[i]) << ((size - i - 1) * 8)
                    else:
                        print('only support LE or BE for parameter endian')
                        assert False
                break
        else:
            value = None
        return value

    def get_string(self, section, address):
        """
        get string ('\0' terminated) from section table
        :param section: section name; use "any" will only match with address
        :param address: start address
        :return: string or None
        """
        value = None
        key = {'address': address, 'section': section}
        for section in self.table:
            if key in section:
                value = section[address:]
                for i, c in enumerate(value):
                    if c == '\0':
                        value = value[:i]
                        break
                break
        return value