# -*- coding: utf-8 -*-
# Thanks to Herbert Oppmann (herby) for all your work!

from .ansi import RESET, RED
from .chksum import ChkSum
from .rgnbin import RgnBin
from struct import unpack
import configparser

RGN_SIG = b"KpGr"
DEFAULT_BUILDER = "SQA"

# RGN structure might be: RGN > BIN or RGN > RGN > BIN
# RGN = outside hull
# BIN = firmware + hwid + checksum

REGION_TYPES = {
    0x000a: "dskimg.bin",
    0x000c: "boot.bin",
    0x000e: "fw_all.bin",
    0x0010: "logo.bin",
    0x004e: "ZIP file",
    0x0055: "fw_all2.bin",
    0x00f5: "GCD firmware update file",
    0x00ff: "pk_text.zip",
}

class ParseException(Exception):
    pass

class Rgn:
    def __init__(self, filename: str=None):
        self.filename = filename
        self.struct = []
        if filename is not None:
            self.load()

    def load(self):
        if self.filename is None:
            return False
        last_tlv6 = None
        last_tlv7 = None
        with open(self.filename, "rb") as f:
            sig = f.read(4)
            if sig != RGN_SIG:
                raise ParseException("Signature mismatch ({}, should be {})!".format(repr(sig), repr(RGN_SIG)))
            self.version = unpack("<H", f.read(2))[0]
            while True:
                cur_offset = f.tell()
                header = f.read(5)
                if len(header) == 0:
                    #print("End of file reached.")
                    break
                (length, type_id) = unpack("<Lc", header)
                #print("Found record type: {} with {} Bytes length.".format(type_id, length))
                rec = RgnRecord.factory(type_id, length, offset=cur_offset)
                payload = f.read(length)
                rec.set_payload(payload)
                self.add_rec(rec)
            f.close()

    def add_rec(self, new_rec):
        self.struct.append(new_rec)

    def print_struct(self):
        """
        Prints the structure of the parsed RGN file
        """
        print("RGN File Version: {}".format(self.version))
        print("{} records.".format(len(self.struct)))
        for i, rec in enumerate(self.struct):
            print("#{:03d}: {}".format(i, rec))

    def print_struct_full(self):
        """
        Prints the structure of the parsed RGN file
        """
        self.print_struct()

    def validate(self, print_stats: bool=False):
        """
        Checks and verifies all checksums in the RGN.
        """
        return True
        # RGN has no checksum, but embedded BIN has

    def dump_to_files(self, output_basename: str):
        pass

    @staticmethod
    def from_recipe(recipe_file: str):
        pass

    def save(self, filename):
        pass

class RgnRecord():
    def __init__(self, type_id, expected_length, payload=None, offset=None):
        self.type_id = type_id
        self.length = expected_length
        self.is_binary = False
        self.payload = payload
        self.offset = offset
        self.is_parsed = False

    def set_payload(self, new_payload):
        self.payload = new_payload

    @staticmethod
    def factory(type_id, length: int = None, offset: int = None):
        if type_id == b"D":
            new_rec = RgnRecordD(type_id, length)
        elif type_id == b"A":
            new_rec = RgnRecordA(type_id, length)
        elif type_id == b"R":
            new_rec = RgnRecordR(type_id, length)
            new_rec.is_binary = True
        else:
            raise ParseException("Unknown record type: {} at offset 0x{:0x}".format(type_id, offset))
        new_rec.offset = offset
        return new_rec

    def __str__(self):
        rec_type = "Unknown"
        if self.type_id == b"D":
            rec_type = "Data Version"
        elif self.type_id == b"A":
            rec_type = "Application Version"
        elif self.type_id == b"R":
            rec_type = "Region"

        if self.length != 1:
            plural = "s"
        offset = ""
        if self.offset:
            offset = " at 0x{:x}".format(self.offset)
        lenstr = ""
        if self.length:
            lenstr = ", {:d} Byte{}".format(self.length, plural)
        return "RGN {} Record{}{}".format(rec_type, offset, lenstr)

class RgnRecordD(RgnRecord):
    """
    Data record (2 Bytes)
    - ushort - Version
    """

    def __init__(self, type_id, expected_length, payload=None, offset=None):
        super().__init__(type_id, expected_length, payload, offset)
        self.version = None

    def parse(self):
        if self.is_parsed:
            # already parsed
            return
        self.version = unpack("<H", self.payload)[0]
        self.is_parsed = True

    def __str__(self):
        txt = super().__str__()
        if not self.is_parsed:
            self.parse()
        txt += "\n  - Data Version: {}".format(self.version)
        return txt


class RgnRecordA(RgnRecord):
    """
    Application record
    - ushort - Application version
    - string - Builder
    - string - BuildDate
    - string - BuildTime
    """

    def __init__(self, type_id, expected_length, payload=None, offset=None):
        super().__init__(type_id, expected_length, payload, offset)
        self.version = None
        self.builder = None
        self.build_date = None
        self.build_time = None

    def parse(self):
        if self.is_parsed:
            # already parsed
            return
        self.version = unpack("<H", self.payload[0:2])[0]
        splits = self.payload[2:].split(b"\0", 2)
        self.builder = splits[0].decode("utf-8")
        self.build_date = splits[1].decode("utf-8")
        self.build_time = splits[2].decode("utf-8")
        self.is_parsed = True

    def __str__(self):
        txt = super().__str__()
        if not self.is_parsed:
            self.parse()
        txt += "\n  - Application Version: {}".format(self.version)
        txt += "\n  - Builder: {}".format(self.builder)
        txt += "\n  - Build time: {} {}".format(self.build_date, self.build_time)
        return txt

class RgnRecordR(RgnRecord):
    """
    Region record
    - ushort - Region ID
    - uint   - Delay in ms
    - uint   - Region size (is record length - 10)
    - byte[Region size] - Contents
    """

    def __init__(self, type_id, expected_length, payload=None, offset=None):
        super().__init__(type_id, expected_length, payload, offset)
        self.region_id = None
        self.delay_ms = None
        self.size = None

    def parse(self):
        if self.is_parsed:
            # already parsed
            return
        (self.region_id, self.delay_ms, self.size) = unpack("<HLL", self.payload[0:10])
        self.is_parsed = True

    def __str__(self):
        txt = super().__str__()
        if not self.is_parsed:
            self.parse()
        rgn_type = REGION_TYPES.get(self.region_id, RED + "Unknown" + RESET)
        txt += "\n  - Region ID: {:04x} ({})".format(self.region_id, rgn_type)
        txt += "\n  - Flash delay: {} ms".format(self.delay_ms)
        txt += "\n  - Binary size: {} Bytes".format(self.size)
        return txt