#!/usr/bin/env python3
#
# Copyright (c) 2020 Nuvoton Technology Corporation
#
# SPDX-License-Identifier: Apache-2.0

# This script will append/paste specific header to tell ROM code (Booter) of
# NPCX EC series how to load the firmware from flash to code ram
# Usage python3 ${ZEPHYR_BASE}/scripts/ecst.py
#                    -i in_file.bin -o out_file.bin
#                    [-chip <name>] [-v|-vv]
#                    [-nohcrc] [-nofcrc] [-ph <offset>]
#                    [-flashsize <1|2|4|8|16>]
#                    [-spimaxclk <20|25|33|40|50>]
#                    [-spireadmode <normal|fast|dual|quad>]

import sys
from colorama import init, Fore
from ecst_args import EcstArgs, exit_with_failure
from pathlib import Path

# ECST Version
ECST_VER = "2.0.1"

# Offsets inside the header
HDR_ANCHOR_OFFSET = 0
HDR_EXTENDED_ANCHOR_OFFSET = 4
HDR_SPI_MAX_CLK_OFFSET = 6
HDR_SPI_READ_MODE_OFFSET = 7
HDR_ERR_DETECTION_CONF_OFFSET = 8
HDR_FW_LOAD_START_ADDR_OFFSET = 9
HDR_FW_ENTRY_POINT_OFFSET = 13
HDR_FW_ERR_DETECT_START_ADDR_OFFSET = 17
HDR_FW_ERR_DETECT_END_ADDR_OFFSET = 21
HDR_FW_LENGTH_OFFSET = 25
HDR_FLASH_SIZE_OFFSET = 29
OTP_WRITE_PROTECT_OFFSET = 30
KEY_VALID_OFFSET = 31
FIRMWARE_VALID_OFFSET = 32
RESERVED_BYTES_OFFSET = 33
HDR_FW_HEADER_SIG_OFFSET = 56
HDR_FW_IMAGE_SIG_OFFSET = 60
FW_IMAGE_OFFSET = 64

SIGNATURE_OFFSET = 0
POINTER_OFFSET = 4
ARM_FW_ENTRY_POINT_OFFSET = 4

# Header field known values
FW_HDR_ANCHOR = 0x2A3B4D5E
FW_HDR_EXT_ANCHOR_ENABLE = 0xAB1E
FW_HDR_EXT_ANCHOR_DISABLE = 0x54E1
FW_HDR_CRC_DISABLE = 0x00
FW_HDR_CRC_ENABLE = 0x02
FW_CRC_DISABLE = 0x00
FW_CRC_ENABLE = 0x02
HDR_PTR_SIGNATURE = 0x55AA650E

BOOTLOADER_TABLE_MODE = "bt"

# SPI related values
SPI_MAX_CLOCK_20_MHZ_VAL = "20"
SPI_MAX_CLOCK_25_MHZ_VAL = "25"
SPI_MAX_CLOCK_33_MHZ_VAL = "33"
SPI_MAX_CLOCK_40_MHZ_VAL = "40"
SPI_MAX_CLOCK_50_MHZ_VAL = "50"

SPI_MAX_CLOCK_20_MHZ = 0x00
SPI_MAX_CLOCK_25_MHZ = 0x01
SPI_MAX_CLOCK_33_MHZ = 0x02
SPI_MAX_CLOCK_40_MHZ = 0x03
SPI_MAX_CLOCK_50_MHZ = 0x04

SPI_CLOCK_RATIO_1_VAL = 1
SPI_CLOCK_RATIO_2_VAL = 2

SPI_CLOCK_RATIO_1 = 0x00
SPI_CLOCK_RATIO_2 = 0x08

SPI_NORMAL_MODE_VAL = 'normal'
SPI_SINGLE_MODE_VAL = 'fast'
SPI_DUAL_MODE_VAL = 'dual'
SPI_QUAD_MODE_VAL = 'quad'

SPI_NORMAL_MODE = 0x00
SPI_SINGLE_MODE = 0x01
SPI_DUAL_MODE = 0x03
SPI_QUAD_MODE = 0x04

# Flash related values
FLASH_SIZE_1_MBYTES_VAL = "1"
FLASH_SIZE_2_MBYTES_VAL = "2"
FLASH_SIZE_4_MBYTES_VAL = "4"
FLASH_SIZE_8_MBYTES_VAL = "8"
FLASH_SIZE_16_MBYTES_VAL = "16"

FLASH_SIZE_1_MBYTES = 0x01
FLASH_SIZE_2_MBYTES = 0x03
FLASH_SIZE_4_MBYTES = 0x07
FLASH_SIZE_8_MBYTES = 0x0f
FLASH_SIZE_8_MBYTES = 0x0f
FLASH_SIZE_16_MBYTES = 0x1f

MAX_FLASH_SIZE = 0x03ffffff

# Header fields default values.
ADDR_16_BYTES_ALIGNED_MASK = 0x0000000f
ADDR_4_BYTES_ALIGNED_MASK = 0x00000003
ADDR_4K_BYTES_ALIGNED_MASK = 0x00000fff

NUM_OF_BYTES = 32
INVALID_INPUT = -1
HEADER_SIZE = 64
PAD_BYTE = b'\x00'
BYTES_TO_PAD = HDR_FW_HEADER_SIG_OFFSET - RESERVED_BYTES_OFFSET

# Verbose related values
NO_VERBOSE = 0
REG_VERBOSE = 1
SUPER_VERBOSE = 1

# Success/failure codes
EXIT_SUCCESS_STATUS = 0
EXIT_FAILURE_STATUS = 1

def _bt_mode_handler(ecst_args):
    """creates the bootloader table using the provided arguments.

    :param ecst_args: the object representing the command line arguments.
    """

    output_file = _set_input_and_output(ecst_args)
    _check_chip(output_file, ecst_args)

    if ecst_args.paste_firmware_header != 0:
        _check_firmware_header_offset(output_file, ecst_args)

    _copy_image(output_file, ecst_args)
    _set_anchor(output_file, ecst_args)
    _set_extended_anchor(output_file, ecst_args)
    _set_spi_flash_maximum_clock(output_file, ecst_args)
    _set_spi_flash_mode(output_file, ecst_args)
    _set_error_detection_configuration(output_file, ecst_args)
    _set_firmware_load_start_address(output_file, ecst_args)
    _set_firmware_entry_point(output_file, ecst_args)
    _set_firmware_crc_start_and_size(output_file, ecst_args)
    _set_firmware_length(output_file, ecst_args)
    _set_flash_size(output_file, ecst_args)
    _set_reserved_bytes(output_file, ecst_args)
    _set_firmware_header_crc_signature(output_file, ecst_args)
    _set_firmware_image_crc_signature(output_file, ecst_args)

    _exit_with_success()

def _set_input_and_output(ecst_args):
    """checks the input file and output and sets the output file.

    checks input file existence, creates an output file according
    to the 'output' argument.

    Note: input file size has to be greater than 0, and named differently
    from output file

    :param ecst_args: the object representing the command line arguments.

    :returns: output file path object, or -1 if fails
    """
    input_file = ecst_args.input
    output = ecst_args.output
    input_file_size = 0

    if not input_file:
        exit_with_failure("Define input file, using -i flag")

    input_file_path = Path(input_file)

    if not input_file_path.exists():
        exit_with_failure(f'Cannot open {input_file}')
    elif input_file_path.stat().st_size == 0:
        exit_with_failure(f'BIN Input file ({input_file}) is empty')
    else:
        input_file_size = input_file_path.stat().st_size

    if not output:
        output_file = Path("out_" + input_file_path.name)
    else:
        output_file = Path(output)

    if output_file.exists():
        if output_file.samefile(input_file_path):
            exit_with_failure(f'Input file name {input_file} '
                              f'should be differed from'
                              f' Output file name {output}')
        output_file.unlink()

    output_file.touch()

    if ecst_args.verbose == REG_VERBOSE:
        print(Fore.LIGHTCYAN_EX + f'\nBIN file: {input_file}, size:'
              f' {input_file_size} bytes')
        print(f'Output file name: {output_file.name} \n')

    return output_file

def _check_chip(output, ecst_args):
    """checks if the chip entered is a legal chip, generates an error
    and closes the application, deletes the output file if the chip name
    is illegal.

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """

    if ecst_args.chip_name == INVALID_INPUT:
        message = f'Invalid chip name, '
        message += "should be npcx4m3, npcx4m8, npcx9m8, npcx9m7, npcx9m6, " \
                   "npcx7m7, npcx7m6, npcx7m5."
        _exit_with_failure_delete_file(output, message)

def _set_anchor(output, ecst_args):
    """writes the anchor value to the output file

    :param output: the output file object.
    :param ecst_args: the object representing the command line arguments.
    """

    with output.open("r+b") as output_file:
        output_file.seek(HDR_ANCHOR_OFFSET + ecst_args.paste_firmware_header)
        output_file.write(FW_HDR_ANCHOR.to_bytes(4, "little"))
        if ecst_args.verbose == REG_VERBOSE:
            print(f'- HDR - FW Header ANCHOR                 - Offset '
                  f'{HDR_ANCHOR_OFFSET}  -  {_hex_print_format(FW_HDR_ANCHOR)}')

    output_file.close()

def _set_extended_anchor(output, ecst_args):
    """writes the extended anchor value to the output file

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """

    with output.open("r+b") as output_file:
        output_file.seek(HDR_EXTENDED_ANCHOR_OFFSET + \
        ecst_args.paste_firmware_header)
        if ecst_args.firmware_header_crc is FW_HDR_CRC_ENABLE:
            output_file.write(FW_HDR_EXT_ANCHOR_ENABLE.to_bytes(2, "little"))
            anchor_to_print = _hex_print_format(FW_HDR_EXT_ANCHOR_ENABLE)
        else:
            output_file.write(FW_HDR_EXT_ANCHOR_DISABLE.to_bytes(2, "little"))
            anchor_to_print = _hex_print_format(FW_HDR_EXT_ANCHOR_DISABLE)

        if ecst_args.verbose == REG_VERBOSE:
            print(f'- HDR - Header EXTENDED ANCHOR           - Offset'
                  f' {HDR_EXTENDED_ANCHOR_OFFSET}  -  {anchor_to_print}')
        output_file.close()


def _check_firmware_header_offset(output, ecst_args):
    """checks if the firmware header offset entered is valid.
    proportions:

    firmware header offset is a non-negative integer.
    firmware header offset is 16 bytes aligned
    firmware header offset equals/smaller than input file minus
    FW HEADER SIZE (64 KB)
    input file size is bigger than FW HEADER SIZE (64 KB)

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """

    input_file = Path(ecst_args.input)
    paste_fw_offset = ecst_args.paste_firmware_header
    input_file_size = input_file.stat().st_size

    if paste_fw_offset == INVALID_INPUT:
        _exit_with_failure_delete_file(output, "Cannot read paste"
                                               " firmware offset")

    paste_fw_offset_to_print = _hex_print_format(paste_fw_offset)

    if paste_fw_offset & ADDR_16_BYTES_ALIGNED_MASK != 0:
        message = f'Paste firmware address ({paste_fw_offset_to_print}) ' \
            f'is not 16 bytes aligned'
        _exit_with_failure_delete_file(output, message)

    if input_file_size <= HEADER_SIZE:
        message = f' input file size ({input_file_size} bytes) ' \
            f'should be bigger than fw header size ({HEADER_SIZE} bytes)'
        _exit_with_failure_delete_file(output, message)

    if input_file_size - HEADER_SIZE < paste_fw_offset:
        message = f'FW offset ({paste_fw_offset_to_print})should be less ' \
            f'than input file size ({input_file_size}) minus fw header size' \
            f' {HEADER_SIZE}'
        _exit_with_failure_delete_file(output, message)

def _set_spi_flash_maximum_clock(output, ecst_args):
    """Sets the maximum allowable clock frequency (for firmware loading);
    also sets the ratio between the Core clock
    and the SPI clock for the specified mode.
    writes the data into the output file.
    the application is closed, and an error is generated
    if the fields are not valid.

    Bits 2-0 - SPI MAX Clock
    Bit 3: SPI Clock Ratio

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """
    spi_max_clock_to_write = 0

    with output.open("r+b") as output_file:
        output_file.seek(HDR_SPI_MAX_CLK_OFFSET +
                         ecst_args.paste_firmware_header)
        spi_max_clock = ecst_args.spi_flash_maximum_clock
        spi_clock_ratio = ecst_args.spi_flash_clock_ratio

        if spi_clock_ratio == SPI_CLOCK_RATIO_1_VAL:
            spi_clock_ratio = SPI_CLOCK_RATIO_1
        elif spi_clock_ratio == SPI_CLOCK_RATIO_2_VAL:
            spi_clock_ratio = SPI_CLOCK_RATIO_2
        elif spi_clock_ratio == INVALID_INPUT:
            message = f'Cannot read SPI Clock Ratio'
            output_file.close()
            _exit_with_failure_delete_file(output, message)
        else:
            message = f'Invalid SPI Core Clock Ratio (3) - it should be 1 or 2'
            output_file.close()
            _exit_with_failure_delete_file(output, message)

        if spi_max_clock == SPI_MAX_CLOCK_20_MHZ_VAL:
            spi_max_clock_to_write = SPI_MAX_CLOCK_20_MHZ | spi_clock_ratio
            output_file.write(spi_max_clock_to_write.to_bytes(1, "little"))

        elif spi_max_clock == SPI_MAX_CLOCK_25_MHZ_VAL:
            spi_max_clock_to_write = SPI_MAX_CLOCK_25_MHZ | spi_clock_ratio
            output_file.write(spi_max_clock_to_write.to_bytes(1, "little"))

        elif spi_max_clock == SPI_MAX_CLOCK_33_MHZ_VAL:
            spi_max_clock_to_write = SPI_MAX_CLOCK_33_MHZ | spi_clock_ratio
            output_file.write(spi_max_clock_to_write.to_bytes(1, "little"))

        elif spi_max_clock == SPI_MAX_CLOCK_40_MHZ_VAL:
            spi_max_clock_to_write = SPI_MAX_CLOCK_40_MHZ | spi_clock_ratio
            output_file.write(spi_max_clock_to_write.to_bytes(1, "little"))

        elif spi_max_clock == SPI_MAX_CLOCK_50_MHZ_VAL:
            spi_max_clock_to_write = SPI_MAX_CLOCK_50_MHZ | spi_clock_ratio
            output_file.write(spi_max_clock_to_write.to_bytes(1, "little"))

        elif not str(spi_max_clock).isdigit():
            output_file.close()
            _exit_with_failure_delete_file(output,
                                           "Cannot read SPI Flash Max Clock")
        else:
            message = f'Invalid SPI Flash MAX Clock size ({spi_max_clock}) '
            message += '- it should be 20, 25, 33, 40 or 50 MHz'
            output_file.close()
            _exit_with_failure_delete_file(output, message)

        if ecst_args.verbose == REG_VERBOSE:
            print(f'- HDR - SPI flash MAX Clock              - Offset '
                  f'{HDR_SPI_MAX_CLK_OFFSET}  -  '
                  f'{_hex_print_format(spi_max_clock_to_write)}')
        output_file.close()

def _set_spi_flash_mode(output, ecst_args):
    """Sets the read mode used for firmware loading and enables
    the Unlimited Burst functionality.
    writes the data into the output file.
    the application is closed, and an error is generated
    if the fields are not valid.

    Bits 2-0 - SPI Flash Read Mode
    Bit 3: Unlimited Burst Mode

    Note: unlimburst is not relevant for npcx5mn chips family.

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """

    spi_flash_read_mode = ecst_args.spi_flash_read_mode
    spi_unlimited_burst_mode = ecst_args.unlimited_burst_mode
    spi_read_mode_to_write = 0

    with output.open("r+b") as output_file:
        output_file.seek(HDR_SPI_READ_MODE_OFFSET +
                         ecst_args.paste_firmware_header)
        if spi_flash_read_mode == SPI_NORMAL_MODE_VAL:
            spi_read_mode_to_write = SPI_NORMAL_MODE | spi_unlimited_burst_mode
            output_file.write(spi_read_mode_to_write.to_bytes(1, "little"))
        elif spi_flash_read_mode == SPI_SINGLE_MODE_VAL:
            spi_read_mode_to_write = SPI_SINGLE_MODE | spi_unlimited_burst_mode
            output_file.write(spi_read_mode_to_write.to_bytes(1, "little"))
        elif spi_flash_read_mode == SPI_DUAL_MODE_VAL:
            spi_read_mode_to_write = SPI_DUAL_MODE | spi_unlimited_burst_mode
            output_file.write(spi_read_mode_to_write.to_bytes(1, "little"))
        elif spi_flash_read_mode == SPI_QUAD_MODE_VAL:
            spi_read_mode_to_write = SPI_QUAD_MODE | spi_unlimited_burst_mode
            output_file.write(spi_read_mode_to_write.to_bytes(1, "little"))
        else:
            message = f'Invalid SPI Flash Read Mode ({spi_flash_read_mode}),'
            message += 'it should be normal, fast, dual, quad'
            output_file.close()
            _exit_with_failure_delete_file(output, message)

        if ecst_args.verbose == REG_VERBOSE:
            print(f'- HDR - SPI flash Read Mode              - Offset '
                  f'{HDR_SPI_READ_MODE_OFFSET}  -  '
                  f'{_hex_print_format(spi_read_mode_to_write)}')

    output_file.close()

def _set_error_detection_configuration(output, ecst_args):
    """writes the error detection configuration value (enabled/disabled)
    to the output file

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """
    with output.open("r+b") as output_file:
        output_file.seek(HDR_ERR_DETECTION_CONF_OFFSET +
                         ecst_args.paste_firmware_header)
        if ecst_args.firmware_crc == FW_CRC_ENABLE:
            err_detect_config_to_print = _hex_print_format(FW_CRC_ENABLE)
            output_file.write(FW_CRC_ENABLE.to_bytes(1, "little"))
        else:
            err_detect_config_to_print = _hex_print_format(FW_CRC_DISABLE)
            output_file.write(FW_CRC_DISABLE.to_bytes(1, "little"))

        if ecst_args.verbose == REG_VERBOSE:
            print(f'- HDR - FW CRC Enabled                   - Offset '
                  f'{HDR_ERR_DETECTION_CONF_OFFSET}  -  '
                  f'{err_detect_config_to_print}')

        output_file.close()

def _set_firmware_load_start_address(output, ecst_args):
    """writes the fw load address to the output file

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """
    start_ram = ecst_args.chip_ram_address
    end_ram = start_ram + ecst_args.chip_ram_size
    fw_load_addr = ecst_args.firmware_load_address
    fw_length = ecst_args.firmware_length
    fw_end_addr = fw_load_addr + fw_length

    start_ram_to_print = _hex_print_format(start_ram)
    end_ram_to_print = _hex_print_format(end_ram)
    fw_load_addr_to_print = _hex_print_format(fw_load_addr)
    fw_length_to_print = _hex_print_format(fw_length)
    fw_end_addr_to_print = _hex_print_format(fw_end_addr)

    if fw_length == INVALID_INPUT:
        message = f'Cannot read firmware length'
        _exit_with_failure_delete_file(output, message)

    if fw_length & ADDR_16_BYTES_ALIGNED_MASK != 0:
        message = f'Firmware length ({fw_length_to_print}) ' \
            f'is not 16 bytes aligned'
        _exit_with_failure_delete_file(output, message)

    if fw_load_addr is INVALID_INPUT:
        message = f'Cannot read FW Load start address'
        _exit_with_failure_delete_file(output, message)

    if fw_load_addr & ADDR_16_BYTES_ALIGNED_MASK != 0:
        message = f'Firmware load address ({fw_load_addr_to_print}) ' \
            f'is not 16 bytes aligned'
        _exit_with_failure_delete_file(output, message)

    if (fw_load_addr > end_ram) or (fw_load_addr < start_ram):
        message = f'Firmware load address ({fw_load_addr_to_print}) ' \
            f'should be between start ({start_ram_to_print}) '\
            f'and end ({end_ram_to_print}) of RAM'
        _exit_with_failure_delete_file(output, message)

    if fw_end_addr > end_ram:
        message = f'Firmware end address ({fw_end_addr_to_print}) should be '
        message += f'less than end of RAM address ({end_ram_to_print})'
        _exit_with_failure_delete_file(output, message)

    with output.open("r+b") as output_file:
        output_file.seek(HDR_FW_LOAD_START_ADDR_OFFSET +
                         ecst_args.paste_firmware_header)
        output_file.write(ecst_args.firmware_load_address.
                          to_bytes(4, "little"))

        output_file.seek(HDR_FW_LENGTH_OFFSET +
                         ecst_args.paste_firmware_header)
        output_file.write(fw_length.to_bytes(4, "little"))

        if ecst_args.verbose == REG_VERBOSE:
            print(f'- HDR - FW load start address            - Offset '
                  f'{HDR_FW_LOAD_START_ADDR_OFFSET}  -  '
                  f'{fw_load_addr_to_print}')
    output_file.close()

def _set_firmware_entry_point(output, ecst_args):
    """writes the fw entry point to the output file.
    proportions:

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """
    entry_pt_none = False
    input_file_path = Path(ecst_args.input)
    fw_entry_pt = ecst_args.firmware_entry_point
    fw_use_arm_reset = ecst_args.use_arm_reset
    fw_length = ecst_args.firmware_length
    fw_load_addr = ecst_args.firmware_load_address
    fw_end_addr = fw_load_addr + fw_length

    # check if fwep flag wasn't set and set it to fw load address if needed
    if fw_entry_pt is None:
        entry_pt_none = True
        fw_entry_pt = ecst_args.firmware_load_address

    if not entry_pt_none and fw_use_arm_reset:
        message = f'-usearmrst not allowed, FW entry point already set using '\
            f'-fwep !'
        _exit_with_failure_delete_file(output, message)

    with input_file_path.open("r+b") as input_file:
        with output.open("r+b") as output_file:
            if fw_use_arm_reset:
                input_file.seek(ARM_FW_ENTRY_POINT_OFFSET +
                                ecst_args.paste_firmware_header)
                fw_entry_byte = input_file.read(4)
                fw_entry_pt = int.from_bytes(fw_entry_byte, "little")

            if fw_entry_pt < fw_load_addr or fw_entry_pt > fw_end_addr:
                output_file.close()
                input_file.close()
                message = f'Firmware entry point ' \
                    f'({_hex_print_format(fw_entry_pt)}) ' \
                    f'should be between the FW load address ' \
                    f'({_hex_print_format(fw_load_addr)})' \
                    f' and FW end address ({_hex_print_format(fw_end_addr)})'

                _exit_with_failure_delete_file(output, message)

            output_file.seek(HDR_FW_ENTRY_POINT_OFFSET +
                             ecst_args.paste_firmware_header)
            output_file.write(fw_entry_pt.to_bytes(4, "little"))
        output_file.close()
    input_file.close()

    if ecst_args.verbose == REG_VERBOSE:
        print(f'- HDR - FW Entry point                   - Offset '
              f'{HDR_FW_ENTRY_POINT_OFFSET} -  '
              f'{_hex_print_format(fw_entry_pt)}')

def _set_firmware_crc_start_and_size(output, ecst_args):
    """writes the fw crc start address and the crc size to the output file.
    proportions:
    --crc start address should be 4 byte aligned, bigger than crc end address
    --crc size should be 4 byte aligned, and be set to firmware length minus
    crc start offset by default
    --crc end address is crc start address + crc size bytes

    the application is closed, and an error is generated if the mentioned
    fields not comply with the proportions.

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """
    fw_crc_size = ecst_args.firmware_crc_size
    fw_crc_start = ecst_args.firmware_crc_start

    if fw_crc_size is None:
        fw_crc_end = ecst_args.firmware_length - 1
        # default value for crc size
        fw_crc_size = ecst_args.firmware_length - fw_crc_start
        ecst_args.firmware_crc_size = fw_crc_size
    else:
        fw_crc_end = fw_crc_start + fw_crc_size - 1

    fw_crc_start_to_print = _hex_print_format(fw_crc_start)
    fw_crc_end_to_print = _hex_print_format(fw_crc_end)
    fw_length_to_print = _hex_print_format(ecst_args.firmware_length)
    fw_crc_size_to_print = _hex_print_format(fw_crc_size)

    if fw_crc_start & ADDR_4_BYTES_ALIGNED_MASK != 0:
        message = f'Firmware crc offset address ' \
            f'({fw_crc_start_to_print}) is not 4 bytes aligned'
        _exit_with_failure_delete_file(output, message)

    if fw_crc_start > fw_crc_end:
        message = f'CRC start address ({fw_crc_start_to_print}) should' \
            f' be less or equal to CRC end address ({fw_crc_end_to_print}) \n'
        _exit_with_failure_delete_file(output, message)

    if fw_crc_size & ADDR_4_BYTES_ALIGNED_MASK != 0:
        message = f'Firmware crc size ({fw_crc_size_to_print}) ' \
            f'is not 4 bytes aligned'
        _exit_with_failure_delete_file(output, message)

    if fw_crc_end > ecst_args.firmware_length - 1:
        message = f'CRC end address ({fw_crc_end_to_print}) should be less' \
            f' than the FW length ({fw_length_to_print}) \n'
        _exit_with_failure_delete_file(output, message)

    with output.open("r+b") as output_file:
        output_file.seek(HDR_FW_ERR_DETECT_START_ADDR_OFFSET +
                         ecst_args.paste_firmware_header)
        output_file.write(fw_crc_start.to_bytes(4, "little"))

        output_file.seek(HDR_FW_ERR_DETECT_END_ADDR_OFFSET +
                         ecst_args.paste_firmware_header)
        output_file.write(fw_crc_end.to_bytes(4, "little"))
        output_file.close()

    if ecst_args.verbose == REG_VERBOSE:
        print(f'- HDR - FW CRC Start                     - Offset '
              f'{HDR_FW_ERR_DETECT_START_ADDR_OFFSET} -  '
              f'{fw_crc_start_to_print}')

        print(f'- HDR - FW CRC End                       - Offset '
              f'{HDR_FW_ERR_DETECT_END_ADDR_OFFSET} -  '
              f'{fw_crc_end_to_print}')

def _set_firmware_length(output, ecst_args):
    """writes the flash size value to the output file
    Note: the firmware length value has already been checked before
    this method

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """

    fw_length = ecst_args.firmware_length
    fw_length_to_print = _hex_print_format(fw_length)

    with output.open("r+b") as output_file:
        output_file.seek(HDR_FW_LENGTH_OFFSET +
                         ecst_args.paste_firmware_header)
        output_file.write(fw_length.to_bytes(4, "little"))
        if ecst_args.verbose == REG_VERBOSE:
            print(f'- HDR - FW Length                        - Offset '
                  f'{HDR_FW_LENGTH_OFFSET} -  '
                  f'{fw_length_to_print}')
    output_file.close()

def _set_flash_size(output, ecst_args):
    """writes the flash size value to the output file
    valid values are 1,2,4,8 or 16 (default is 16).
    the application is closed and the output file is deleted
    if the flash size is invalid

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """
    flash_size_to_print = ""

    with output.open("r+b") as output_file:
        output_file.seek(HDR_FLASH_SIZE_OFFSET +
                         ecst_args.paste_firmware_header)
        flash_size = ecst_args.flash_size

        if flash_size == FLASH_SIZE_1_MBYTES_VAL:
            output_file.write(FLASH_SIZE_1_MBYTES.to_bytes(4, "little"))
            flash_size_to_print = _hex_print_format(FLASH_SIZE_1_MBYTES)
        elif flash_size == FLASH_SIZE_2_MBYTES_VAL:
            output_file.write(FLASH_SIZE_2_MBYTES.to_bytes(4, "little"))
            flash_size_to_print = _hex_print_format(FLASH_SIZE_2_MBYTES)
        elif flash_size == FLASH_SIZE_4_MBYTES_VAL:
            output_file.write(FLASH_SIZE_4_MBYTES.to_bytes(4, "little"))
            flash_size_to_print = _hex_print_format(FLASH_SIZE_4_MBYTES)
        elif flash_size == FLASH_SIZE_8_MBYTES_VAL:
            output_file.write(FLASH_SIZE_8_MBYTES.to_bytes(4, "little"))
            flash_size_to_print = _hex_print_format(FLASH_SIZE_8_MBYTES)
        elif flash_size == FLASH_SIZE_16_MBYTES_VAL:
            output_file.write(FLASH_SIZE_16_MBYTES.to_bytes(4, "little"))
            flash_size_to_print = _hex_print_format(FLASH_SIZE_16_MBYTES)
        elif not flash_size.isdigit():
            output_file.close()
            _exit_with_failure_delete_file(output, "Cannot read Flash size")
        else:
            message = f'Invalid flash size ({flash_size} MBytes), ' \
                f' it should be 0.5, 1, 2, 4, 8, 16 MBytes \n' \
                f' please note - for 0.5 MBytes flash, enter \'1\' '
            output_file.close()
            _exit_with_failure_delete_file(output, message)

    if ecst_args.verbose == REG_VERBOSE:
        print(f'- HDR - Flash size                       - Offset '
              f'{HDR_FLASH_SIZE_OFFSET} - '
              f' {flash_size_to_print}')
    output_file.close()

def _set_reserved_bytes(output, ecst_args):
    """fills the reserved part of the image at the relevant offset
    with the PAD_BYTE

    :param output: the output file object
    :param ecst_args: the object representing the command line arguments.
    """
    with output.open("r+b") as output_file:
        for i in range(BYTES_TO_PAD):
            output_file.seek(RESERVED_BYTES_OFFSET +
                             ecst_args.paste_firmware_header + i)
            output_file.write(PAD_BYTE)
    output_file.close()

def _set_firmware_header_crc_signature(output, ecst_args):
    """writes the firmware header crc signature (4 bytes)
    to the output file

    :param output: the output file object
    :param ecst_args: the object representing the command line arguments.
    """
    crc_to_print = _hex_print_format(0)

    # calculating crc only if the header crc check is enabled
    if ecst_args.firmware_header_crc != FW_HDR_CRC_DISABLE:

        with output.open("r+b") as output_file:
            crc_calc = 0xffffffff
            table = _create_table()

            for i in range(HDR_FW_HEADER_SIG_OFFSET):
                output_file.seek(ecst_args.paste_firmware_header + i)
                current = output_file.read(1)
                crc_calc = _crc_update(
                    int.from_bytes(current, "little"), crc_calc, table)

            crc = _finalize_crc(crc_calc)
            crc_to_write = crc.to_bytes(4, "little")
            crc_to_print = _hex_print_format(crc)
            output_file.seek(ecst_args.paste_firmware_header +
                             HDR_FW_HEADER_SIG_OFFSET)
            output_file.write(crc_to_write)

        output_file.close()

    if ecst_args.verbose == REG_VERBOSE:
        print(f'- HDR - Header CRC                       - Offset '
              f'{HDR_FW_HEADER_SIG_OFFSET} - '
              f' {crc_to_print}')

def _set_firmware_image_crc_signature(output, ecst_args):
    """writes the firmware image crc signature (4 bytes)
    to the output file.

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """
    # calculating crc only if the image crc check is enabled
    crc_to_print = _hex_print_format(0)
    if ecst_args.firmware_crc != FW_CRC_DISABLE:

        with output.open("r+b") as output_file:
            crc_calc = 0xffffffff
            table = _create_table()

            output_file.seek(FW_IMAGE_OFFSET + ecst_args.paste_firmware_header +
                             ecst_args.firmware_crc_start)
            for _ in range(ecst_args.firmware_crc_size):
                current = output_file.read(1)
                crc_calc = _crc_update(int.from_bytes(current, "little"), \
                crc_calc, table)

            crc = _finalize_crc(crc_calc)
            crc_to_write = crc.to_bytes(4, "little")
            crc_to_print = _hex_print_format(crc)
            output_file.seek(HDR_FW_IMAGE_SIG_OFFSET +
                             ecst_args.paste_firmware_header)
            output_file.write(crc_to_write)

        output_file.close()

    if ecst_args.verbose == REG_VERBOSE:
        print(f'- HDR - Header CRC                       - Offset '
              f'{HDR_FW_IMAGE_SIG_OFFSET} - '
              f' {crc_to_print}')

def _copy_image(output, ecst_args):
    """copies the fw image from the input file to the output file
    if firmware header offset is defined, just copies the input file to the
    output file

    :param output: the output file object,
    :param ecst_args: the object representing the command line arguments.
    """
    with open(ecst_args.input, "rb") as firmware_image:
        with open(output, "r+b") as output_file:
            if ecst_args.paste_firmware_header == 0:
                output_file.seek(FW_IMAGE_OFFSET)
            else:
                output_file.seek(0)
            for line in firmware_image:
                output_file.write(line)
        output_file.close()
    firmware_image.close()

    # pad fw image to be 16 byte aligned if needed
    input_file_size = Path(ecst_args.input).stat().st_size
    bytes_to_pad_num = abs((16 - input_file_size) % 16)

    with open(output, "r+b") as output_file:
        i = bytes_to_pad_num
        while i != 0:
            output_file.seek(0, 2)  # seek end of file
            output_file.write(PAD_BYTE)
            i -= 1
    output_file.close()

    # update firmware length if needed
    fw_length = ecst_args.firmware_length
    if fw_length is None:
        if ecst_args.paste_firmware_header == 0:
            ecst_args.firmware_length = input_file_size + bytes_to_pad_num
        else:
            ecst_args.firmware_length = input_file_size - HEADER_SIZE - \
                                                ecst_args.paste_firmware_header

def _merge_file_with_bt_header(ecst_args):
    """Merge the BT with the BH according to the bhoffset and pointer flags

    :param ecst_args: the object representing the command line arguments.
    """
    bh_index = ecst_args.bh_offset
    file_name_to_print = ""

    if not ecst_args.input:
        exit_with_failure('No input BIN file selected for'
                          'Bootloader header file.')
    else:
        input_file = Path(ecst_args.input)
        if not input_file.exists():
            exit_with_failure(f'Cannot open {ecst_args.input}')

        if input_file.stat().st_size < bh_index:

            message = f'Bootloader header offset ({bh_index} bytes) should be '
            message += f'less than file size ' \
                f'({input_file.stat().st_size } bytes)'
            exit_with_failure(message)

        # create a file if the output parameter is not None,
        # otherwise write to the input file
        if ecst_args.output is not None:
            output_file = Path(ecst_args.output)
            output_file.touch()
            with input_file.open("r+b") as firmware_image:
                with output_file.open("r+b") as output_file:
                    file_name_to_print = output_file.name
                    for line in firmware_image:
                        output_file.write(line)
                    output_file.seek(bh_index)
                    output_file.write(HDR_PTR_SIGNATURE.to_bytes(4, "little"))
                    output_file.seek(bh_index + 4)
                    output_file.write(ecst_args.pointer.to_bytes(4, "little"))
                output_file.close()
            firmware_image.close()

        else:
            with input_file.open("r+b") as file_to_merge:
                file_name_to_print = file_to_merge.name
                file_to_merge.seek(bh_index + SIGNATURE_OFFSET)
                file_to_merge.write(HDR_PTR_SIGNATURE.to_bytes(4, "little"))
                file_to_merge.seek(bh_index + POINTER_OFFSET)
                file_to_merge.write(ecst_args.pointer.to_bytes(4, "little"))
            file_to_merge.close()

    if ecst_args.verbose == REG_VERBOSE:
        print(Fore.LIGHTCYAN_EX + f'BootLoader Header file:'
              f' {file_name_to_print}')
        print(f'Offset: {_hex_print_format(ecst_args.bh_offset)},'
              f' Signature: {_hex_print_format(HDR_PTR_SIGNATURE)},'
              f' Pointer: {_hex_print_format(ecst_args.pointer)}')

def _create_bt_header(ecst_args):
    """create bootloader table header, consist of 4 bytes signature and
    4 bytes pointer

    :param ecst_args: the object representing the command line arguments.
    """
    if not ecst_args.output:
        exit_with_failure("No output file selected for "
                          "Bootloader header file.")
    else:
        output_file = Path(ecst_args.output)
        if not output_file.exists():
            output_file.touch()
        with open(output_file, "r+b") as boot_loader_header_file:
            boot_loader_header_file.seek(SIGNATURE_OFFSET)
            boot_loader_header_file.write(HDR_PTR_SIGNATURE.to_bytes(4, \
            "little"))
            boot_loader_header_file.seek(POINTER_OFFSET)
            boot_loader_header_file.write(ecst_args.pointer.to_bytes(4, \
            "little"))
        boot_loader_header_file.close()
        if ecst_args.verbose == REG_VERBOSE:
            print(Fore.LIGHTCYAN_EX + f'BootLoader Header file:'
                  f' {output_file.name}')
            print(f'Signature: {_hex_print_format(HDR_PTR_SIGNATURE)}, '
                  f'Pointer: {_hex_print_format(ecst_args.pointer)}')

def _create_table():
    """helper for crc calculation"""
    table = []
    for i in range(256):
        k = i
        for _ in range(8):
            if k & 1:
                k = (k >> 1) ^ 0xEDB88320
            else:
                k >>= 1
        table.append(k)
    return table

def _crc_update(cur, crc, table):
    """helper for crc calculation

    :param cur
    :param crc
    :param table
    """
    l_crc = 0x000000ff & cur

    tmp = crc ^ l_crc
    crc = (crc >> 8) ^ table[(tmp & 0xff)]
    return crc

def _finalize_crc(crc):
    """helper for crc calculation

    :param crc
    """
    final_crc = 0
    for j in range(NUM_OF_BYTES):
        current_bit = crc & (1 << j)
        current_bit = current_bit >> j
        final_crc |= current_bit << (NUM_OF_BYTES - 1) - j
    return final_crc

def _hex_print_format(value):
    """hex representation of an integer

    :param value: an integer to be represented in hex
    """
    return "0x{:08x}".format(value)

def _exit_with_failure_delete_file(output, message):
    """formatted failure message printer, prints the
    relevant error message, deletes the output file,
    and exits the application.

    :param message: the error message to be printed
    """
    output_file = Path(output)
    if output_file.exists():
        output_file.unlink()

    message = '\n' + message
    message += '\n'
    message += '******************************\n'
    message += '***        FAILED          ***\n'
    message += '******************************\n'
    print(Fore.RED + message)

    sys.exit(EXIT_FAILURE_STATUS)

def _exit_with_success():
    """formatted success message printer, prints the
    success message and exits the application.
    """
    message = '\n'
    message += '******************************\n'
    message += '***        SUCCESS         ***\n'
    message += '******************************\n'
    print(Fore.GREEN + message)

    sys.exit(EXIT_SUCCESS_STATUS)

def main():
    """main of the application
    """
    init()  # colored print initialization for windows

    if len(sys.argv) < 2:
        sys.exit(EXIT_FAILURE_STATUS)

    ecst_obj = EcstArgs()

    if ecst_obj.error_args:
        for err_arg in ecst_obj.error_args:
            message = f'unKnown flag: {err_arg}'
            exit_with_failure(message)
        sys.exit(EXIT_SUCCESS_STATUS)

    # Start to handle booter header table
    _bt_mode_handler(ecst_obj)

if __name__ == '__main__':
    main()