# Copyright (C) 2019 Intel Corporation. All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause
#

import sys
import common

SOURCE_ROOT_DIR = common.SOURCE_PATH
BOARD_NAME = ''
BOARD_INFO_FILE = "board_info.txt"
SCENARIO_INFO_FILE = ""

BIOS_INFO = ['BIOS Information', 'Vendor:', 'Version:', 'Release Date:', 'BIOS Revision:']

BASE_BOARD = ['Base Board Information', 'Manufacturer:', 'Product Name:', 'Version:']

BOARD_NAMES = ['apl-mrb', 'apl-nuc', 'apl-up2', 'dnv-cb2', 'nuc6cayh',
               'nuc7i7dnb', 'kbl-nuc-i7', 'icl-rvp']

LEGACY_TTYS = {
    'ttyS0':'0x3F8',
    'ttyS1':'0x2F8',
    'ttyS2':'0x3E8',
    'ttyS3':'0x2E8',
}

NATIVE_CONSOLE_DIC = {}
VALID_LEGACY_IRQ = []
VM_COUNT = 0

ERR_LIST = {}

HEADER_LICENSE = common.open_license() + "\n"

# The data base contains hide pci device
KNOWN_HIDDEN_PDEVS_BOARD_DB = {
    'apl-mrb':['00:0d:0'],
    'apl-up2':['00:0d:0'],
}


def prepare(check_git):
    """ check environment """
    return common.check_env(check_git)


def print_yel(msg, warn=False):
    """
    Print the message with color of yellow
    :param msg: the stings which will be output to STDOUT
    :param warn: the condition if needs to be output the color of yellow with 'Warning'
    """
    common.print_if_yel(msg, warn)


def print_red(msg, err=False):
    """
    Print the message with color of red
    :param msg: the stings which will be output to STDOUT
    :param err: the condition if needs to be output the color of red with 'Error'
    """
    common.print_if_red(msg, err)


def get_board_name():
    """
    Get board name from board.xml at fist line
    :param board_info: it is a file what contains board information for script to read from
    """
    (err_dic, board) = common.get_xml_attrib(BOARD_INFO_FILE, "board")
    return (err_dic, board)


def get_scenario_name():
    """
    Get scenario name from scenario.xml at fist line
    :param scenario_info: it is a file what contains board information for script to read from
    """
    (err_dic, scenario) = common.get_xml_attrib(SCENARIO_INFO_FILE, "scenario")
    return (err_dic, scenario)


def is_config_file_match():

    (err_dic, scenario_for_board) = common.get_xml_attrib(SCENARIO_INFO_FILE, "board")
    (err_dic, board_name) = common.get_xml_attrib(BOARD_INFO_FILE, "board")

    if scenario_for_board == board_name:
        return (err_dic, True)
    else:
        return (err_dic, False)


def usage(file_name):
    """ This is usage for how to use this tool """
    common.usage(file_name)


def get_param(args):
    """
    Get the script parameters from command line
    :param args: this the command line of string for the script without script name
    """
    return common.get_param(args)


def get_info(board_info, msg_s, msg_e):
    """
    Get information which specify by argument
    :param board_info: it is a file what contains information for script to read from
    :param msg_s: it is a pattern of key stings what start to match from board information
    :param msg_e: it is a pattern of key stings what end to match from board information
    """
    info_lines = common.get_board_info(board_info, msg_s, msg_e)
    return info_lines


def handle_bios_info(config):
    """
    Handle bios information
    :param config: it is a file pointer of bios information for writing to
    """
    bios_lines = get_info(BOARD_INFO_FILE, "<BIOS_INFO>", "</BIOS_INFO>")
    board_lines = get_info(BOARD_INFO_FILE, "<BASE_BOARD_INFO>", "</BASE_BOARD_INFO>")
    print("/*", file=config)

    if not bios_lines or not board_lines:
        print(" * DMI info is not found", file=config)
    else:
        i_cnt = 0
        bios_board = BIOS_INFO + BASE_BOARD

        # remove the same value and keep origin sort
        bios_board_info = list(set(bios_board))
        bios_board_info.sort(key=bios_board.index)

        bios_board_lines = bios_lines + board_lines
        bios_info_len = len(bios_lines)
        for line in bios_board_lines:
            if i_cnt == bios_info_len:
                print(" *", file=config)

            i_cnt += 1

            for misc_info in bios_board_info:
                if misc_info == " ".join(line.split()[0:1]) or misc_info == \
                        " ".join(line.split()[0:2]) or misc_info == " ".join(line.split()[0:3]):
                    print(" * {0}".format(line.strip()), file=config)

    print(" */", file=config)


def get_tree_tag(config_file, tag_str):
    """
    This is get tag value by tag_str from config file
    :param config_file: it is a file what contains information for script to read from
    :param tag_str: it is key of pattern to config file item
    :return: value of tag_str item
    """
    return common.get_tree_tag_val(config_file, tag_str)


def get_sub_leaf_tag(config_file, branch_tag, tag_str):
    """
     This is get tag value by tag_str from config file
     :param config_file: it is a file what contains information for script to read from
     :param branch_tag: it is key of patter to config file branch tag item
     :param tag_str: it is key of pattern to config file leaf tag item
     :return: value of tag_str item
     """
    return common.get_leaf_tag_val(config_file, branch_tag, tag_str)


def gen_patch(srcs_list, board_name):
    """
    Generate patch and apply to local source code
    :param srcs_list: it is a list what contains source files
    :param board_name: board name
    """
    err_dic = common.add_to_patch(srcs_list, board_name)
    return err_dic


def is_hpa_size(hpa_size_list):
    """
    This is identify if the host physical size list is correct format
    :param hpa_size_list: host physical size list
    :return: True if good format
    """
    ret = common.check_hpa_size(hpa_size_list)
    return ret


def get_rootfs(config_file):
    """
    This will get rootfs partition from board information
    :param config_file: it is a file which contain board information
    :return: rootfs partition list
    """
    root_dev_list = []
    rootfs_lines = get_info(config_file, "<BLOCK_DEVICE_INFO>", "</BLOCK_DEVICE_INFO>")

    # none 'BLOCK_DEVICE_INFO' tag
    if rootfs_lines == None:
        return root_dev_list

    for rootfs_line in rootfs_lines:
        if not rootfs_line:
            break

        if not common.handle_root_dev(rootfs_line):
            continue

        root_dev = rootfs_line.strip().split(':')[0]
        root_dev_list.append(root_dev)

    return (root_dev_list, len(root_dev_list))


def clos_info_parser(board_info):
    """ Parse CLOS information """
    return common.get_max_clos(board_info)


def get_pre_launch_cnt(config_file):
    """
    This is get pre launched vm count
    :param config_file:  it is a file what contains vm information for script to read from
    :return: number of per launched vm
    """
    pre_launch_cnt = common.vm_pre_launch_cnt(config_file)
    return pre_launch_cnt


def get_vm_count(config_file):
    """
    This is get vm count
    :param config_file:  it is a file what contains vm information for script to read from
    :return: number of vm
    """
    global VM_COUNT
    VM_COUNT = common.get_vm_count(config_file)


def get_order_type_by_vmid(idx):
    """
    This is get pre launched vm count
    :param idx: index of vm id
    :return: vm type of index to vmid
    """
    (err_dic, order_type) = common.get_load_order_by_vmid(SCENARIO_INFO_FILE, VM_COUNT, idx)
    if err_dic:
        ERR_LIST.update(err_dic)

    return order_type


def get_valid_irq(board_info):
    """
     This is get available irq from board info file
     :param board_info:  it is a file what contains board information for script to read from
     :return: None
     """
    global VALID_LEGACY_IRQ
    val_irq = []
    irq_info_lines = get_info(board_info, "<AVAILABLE_IRQ_INFO>", "</AVAILABLE_IRQ_INFO>")
    for irq_string in irq_info_lines:
        val_irq = [x.strip() for x in irq_string.split(',')]

    VALID_LEGACY_IRQ = val_irq


def alloc_irq():
    """
      This is allocated an available irq
      :return: free irq
      """
    irq_val = VALID_LEGACY_IRQ.pop(0)

    return irq_val


def get_valid_console():
    """ Get valid console with mapping {ttyS:irq} returned """
    used_console_lines = get_info(BOARD_INFO_FILE, "<TTYS_INFO>", "</TTYS_INFO>")

    vuart0_valid_console = []
    vuart1_valid_console = ['ttyS0', 'ttyS1', 'ttyS2', 'ttyS3', 'ttyS4', 'ttyS5', 'ttyS6', 'ttyS7']
    if used_console_lines:
        vuart0_valid_console.clear()
        for console in used_console_lines:
            #seri:/dev/ttySx type:mmio base:0x91526000 irq:4 bdf:"00:18.0"
            #seri:/dev/ttySy type:portio base:0x2f8 irq:5
            tty = console.split('/')[2].split()[0]
            ttys_irq = console.split()[3].split(':')[1].strip()
            NATIVE_CONSOLE_DIC[tty] = ttys_irq
            vuart0_valid_console.append(tty)
            if tty:
                vuart1_valid_console.remove(tty)

    return (vuart0_valid_console, vuart1_valid_console)


def console_to_show(board_info):
    """
     This is get available console from board info file
     :param board_info:  it is a file what contains board information for script to read from
     :return: available console
     """
    show_vuart1 = False
    (vuart0_valid_console, vuart1_valid_console) = get_valid_console()
    if not vuart1_valid_console:
        print_yel("Console are full used, sos_console/vuart1 have to chose one:", warn=True)
        vuart0_valid_console = ['ttyS0', 'ttyS1', 'ttyS2', 'ttyS3']
        vuart1_valid_console = ['ttyS0', 'ttyS1', 'ttyS2', 'ttyS3']
        show_vuart1 = True

    return (vuart0_valid_console, vuart1_valid_console, show_vuart1)


def parser_vuart_console():
    """
    There may be 3 types in the console item
    1. BDF:(00:18.2) seri:/dev/ttyS2
    2. /dev/ttyS2
    3. ttyS2
    """
    ttys_n = ''
    (err_dic, scenario_name) = get_scenario_name()

    if scenario_name != "logical_partition":
        ttys = get_sub_leaf_tag(SCENARIO_INFO_FILE, "board_private", "console")
    else:
        ttys = get_sub_leaf_tag(SCENARIO_INFO_FILE, "os_config", "console")

    if not ttys or ttys[0] == None:
        return (err_dic, ttys_n)

    if ttys and 'BDF' in ttys[0] or '/dev' in ttys[0]:
        ttys_n = ttys[0].split('/')[2]
    else:
        # sdc/sdc2 is different from logical_partition
        ttys_n = ttys[0]

    return (err_dic, ttys_n)


def get_board_private_vuart(branch_tag, tag_console):
    """
    Get vuart_console from board setting
    :param tag_console: TTYS_INFO
    :return: vuart0/vuart1 console dictionary
    """
    err_dic = {}
    vuart0_console_dic = {}
    vuart1_console_dic = {}

    (err_dic, ttys_n) = parser_vuart_console()
    if err_dic:
        return err_dic

    if ttys_n:

        (vuart0_valid_console, vuart1_valid_console, show_vuart1) = console_to_show(BOARD_INFO_FILE)

        # VUART0
        if ttys_n not in list(NATIVE_CONSOLE_DIC.keys()):
            vuart0_console_dic[ttys_n] = alloc_irq()
        else:
            if int(NATIVE_CONSOLE_DIC[ttys_n]) >= 16:
                vuart0_console_dic[ttys_n] = alloc_irq()
            else:
                vuart0_console_dic[ttys_n] = NATIVE_CONSOLE_DIC[ttys_n]
    else:
        vuart1_valid_console = ['ttyS1']

    # VUART1
    if len(NATIVE_CONSOLE_DIC) >= 2 and 'ttyS1' in NATIVE_CONSOLE_DIC.keys():
        # There are more than 1 serial port in native, we need to use native ttyS1 info for vuart1 which include
        # base ioport and irq number.
        vuart1_console_dic['ttyS1'] = NATIVE_CONSOLE_DIC['ttyS1']
    else:
        # There is only one native serial port. We hardcode base ioport for vuart1 and allocate a irq which is
        # free in native env and use it for vuart1 irq number
        vuart1_console_dic[vuart1_valid_console[0]] = alloc_irq()

    return (err_dic, vuart0_console_dic, vuart1_console_dic)


def get_vuart_info_id(config_file, idx):
    """
    Get vuart information by vuart id indexx
    :param config_file: it is a file what contains information for script to read from
    :param idx: vuart index in range: [0,1]
    :return: dictionary which stored the vuart-id
    """
    tmp_tag = common.get_vuart_info_id(config_file, idx)
    return tmp_tag


def get_processor_info():
    """
    Get cpu processor list
    :param board_info: it is a file what contains board information
    :return: cpu processor list
    """
    processor_list = []
    tmp_list = []
    processor_info = get_info(BOARD_INFO_FILE, "<CPU_PROCESSOR_INFO>", "</CPU_PROCESSOR_INFO>")

    if not processor_info:
        key = "CPU PROCESSOR_INFO error:"
        ERR_LIST[key] = "CPU core is not exists"
        return processor_list

    for processor_line in processor_info:
        if not processor_line:
            break

        processor_list = processor_line.strip().split(',')
        for processor in processor_list:
            tmp_list.append(processor.strip())
        break

    return tmp_list


def undline_name(name):
    """
    This convert name which has contain '-' to '_'
    :param name: name which contain '-' and ' '
    :return: name_str which contain'_'
    """
    return common.undline_name(name)