#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright (C) 2022 F4PGA Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0

"""
Creates a device library file
"""

import argparse
import sys
import csv
import os
import re
from collections import namedtuple
from collections import defaultdict
from datetime import date
import simplejson as json
import lxml.etree as ET

"""
Pin properties
name - pin_name
dir - direction (input/output)
used - specify 'yes' if user is using the pin else specify 'no'
clk - specify associate clock
"""
PinData = namedtuple("PinData", "name dir used clk")


def main():
    """
    Creates a device library file by getting data from given csv and xml file
    """
    parser = argparse.ArgumentParser(description="Creates a device library file.")
    parser.add_argument("--lib", "-l", "-L", type=str, default="qlf_k4n8.lib", help="The output device lib file")
    parser.add_argument("--lib_name", "-n", "-N", type=str, required=True, help="Specify library name")
    parser.add_argument(
        "--template_data_path",
        "-t",
        "-T",
        type=str,
        required=True,
        help="Specify path from where to pick template data for library creation",
    )
    parser.add_argument("--cell_name", "-m", "-M", type=str, required=True, help="Specify cell name")
    parser.add_argument("--csv", "-c", "-C", type=str, required=True, help="Input pin-map csv file")
    parser.add_argument("--xml", "-x", "-X", type=str, required=True, help="Input interface-mapping xml file")

    args = parser.parse_args()

    if not os.path.exists(args.template_data_path):
        print('Invalid template data path "{}" specified'.format(args.template_data_path), file=sys.stderr)
        sys.exit(1)

    csv_pin_data = defaultdict(set)
    assoc_clk = dict()
    with open(args.csv, newline="") as csvfile:
        reader = csv.DictReader(csvfile)
        for row in reader:
            # define properties for scalar pins
            scalar_port_names = vec_to_scalar(row["port_name"])
            for port in scalar_port_names:
                if port.find("F2A") != -1:
                    csv_pin_data["F2A"].add(port)
                elif port.find("A2F") != -1:
                    csv_pin_data["A2F"].add(port)
                if row["Associated Clock"] is not None:
                    assoc_clk[port] = row["Associated Clock"].strip()

    port_names = parse_xml(args.xml)
    create_lib(port_names, args.template_data_path, csv_pin_data, args.lib_name, args.lib, args.cell_name, assoc_clk)


# =============================================================================
def create_lib(port_names, template_data_path, csv_pin_data, lib_name, lib_file_name, cell_name, assoc_clk):
    """
    Create lib file
    """
    # Read header template file and populate lib file with this data
    curr_dir = os.path.dirname(os.path.abspath(__file__))

    common_lib_data = dict()
    common_lib_data_file = os.path.join(template_data_path, "common_lib_data.json")
    with open(common_lib_data_file) as fp:
        common_lib_data = json.load(fp)

    today = date.today()
    curr_date = today.strftime("%B %d, %Y")

    lib_header_tmpl = os.path.join(template_data_path, "lib_header_template.txt")
    header_templ_file = os.path.join(curr_dir, lib_header_tmpl)
    in_str = open(header_templ_file, "r").read()

    curr_str = in_str.replace("{lib_name}", lib_name)
    str_rep_date = curr_str.replace("{curr_date}", curr_date)
    str1 = str_rep_date.replace("{cell_name}", cell_name)

    a2f_pin_list = [None] * len(port_names["A2F"])
    f2a_pin_list = [None] * len(port_names["F2A"])
    for port in port_names["A2F"]:
        pin_dir = "input"
        pin_used = False
        if port in csv_pin_data["A2F"]:
            pin_used = True

        clk = ""
        if port in assoc_clk:
            if assoc_clk[port].strip() != "":
                clk = assoc_clk[port].strip()

        index = port_index(port)
        if index != -1:
            pin_data = PinData(name=port, dir=pin_dir, used=pin_used, clk=clk)
            a2f_pin_list[index] = pin_data
        else:
            print("ERROR: No index present in A2F port: '{}'".format(port))

    for port in port_names["F2A"]:
        pin_dir = "output"
        pin_used = False
        if port in csv_pin_data["F2A"]:
            pin_used = True

        clk = ""
        if port in assoc_clk:
            if assoc_clk[port].strip() != "":
                clk = assoc_clk[port].strip()

        index = port_index(port)
        if index != -1:
            pin_data = PinData(name=port, dir=pin_dir, used=pin_used, clk=clk)
            f2a_pin_list[index] = pin_data
        else:
            print("ERROR: No index present in F2A port: '{}'\n".format(port))

    lib_data = ""
    a2f_bus_name = ""
    if len(a2f_pin_list) > 0:
        pos = a2f_pin_list[0].name.find("[")
        if pos != -1:
            a2f_bus_name = a2f_pin_list[0].name[0:pos]
            lib_data += "\n{}bus ( {} ) {{\n".format(add_tab(2), a2f_bus_name)
            lib_data += "\n{}bus_type   : BUS1536_type1 ;".format(add_tab(3))
            lib_data += "\n{}direction  : input ;\n".format(add_tab(3))

    for pin in a2f_pin_list:
        if pin.used:
            curr_str = "\n{}pin ({}) {{".format(add_tab(3), pin.name)
            cap = common_lib_data["input_used"]["cap"]
            max_tran = common_lib_data["input_used"]["max_tran"]
            curr_str += form_pin_header(pin.dir, cap, max_tran)

            if pin.clk != "":
                clks = pin.clk.split(" ")
                for clk in clks:
                    clk_name = clk
                    timing_type = ["setup_rising", "hold_rising"]
                    for val in timing_type:
                        curr_str += form_in_timing_group(clk_name, val, common_lib_data)
            curr_str += "\n{}}} /* end of pin {} */\n".format(add_tab(3), pin.name)
            lib_data += curr_str
        else:
            curr_str = "\n{}pin ({}) {{".format(add_tab(3), pin.name)
            cap = common_lib_data["input_unused"]["cap"]
            max_tran = common_lib_data["input_unused"]["max_tran"]
            curr_str += form_pin_header(pin.dir, cap, max_tran)
            curr_str += "\n{}}} /* end of pin {} */\n".format(add_tab(3), pin.name)
            lib_data += curr_str

    if len(a2f_pin_list) > 0:
        lib_data += "\n{}}} /* end of bus {} */\n".format(add_tab(2), a2f_bus_name)

    f2a_bus_name = ""
    if len(f2a_pin_list) > 0:
        pos = f2a_pin_list[0].name.find("[")
        if pos != -1:
            f2a_bus_name = f2a_pin_list[0].name[0:pos]
            lib_data += "\n{}bus ( {} ) {{\n".format(add_tab(2), f2a_bus_name)
            lib_data += "\n{}bus_type   : BUS1536_type1 ;".format(add_tab(3))
            lib_data += "\n{}direction  : output ;\n".format(add_tab(3))

    for pin in f2a_pin_list:
        if pin.used:
            curr_str = "\n{}pin ({}) {{".format(add_tab(3), pin.name)
            cap = common_lib_data["output_used"]["cap"]
            max_tran = common_lib_data["output_used"]["max_tran"]
            curr_str += form_pin_header(pin.dir, cap, max_tran)

            if pin.clk != "":
                clks = pin.clk.split(" ")
                for clk in clks:
                    clk_name = clk
                    timing_type = "rising_edge"
                    curr_str += form_out_timing_group(clk_name, timing_type, common_lib_data)
                curr_str += form_out_reset_timing_group("RESET_N", "positive_unate", "clear", common_lib_data)
            curr_str += "\n{}}} /* end of pin {} */\n".format(add_tab(3), pin.name)
            lib_data += curr_str
        else:
            curr_str = "\n{}pin ({}) {{".format(add_tab(3), pin.name)
            cap = common_lib_data["output_unused"]["cap"]
            max_tran = common_lib_data["output_unused"]["max_tran"]
            curr_str += form_pin_header(pin.dir, cap, max_tran)
            curr_str += "\n{}}} /* end of pin {} */\n".format(add_tab(3), pin.name)
            lib_data += curr_str
    if len(f2a_pin_list) > 0:
        lib_data += "\n{}}} /* end of bus {} */\n".format(add_tab(2), f2a_bus_name)

    dedicated_pin_tmpl = os.path.join(template_data_path, "dedicated_pin_lib_data.txt")
    dedicated_pin_lib_file = os.path.join(curr_dir, dedicated_pin_tmpl)
    dedicated_pin_data = open(dedicated_pin_lib_file, "r").read()

    inter_str = str1.replace("@dedicated_pin_data@", dedicated_pin_data)

    final_str = inter_str.replace("@user_pin_data@", lib_data)
    with open(lib_file_name, "w") as out_fp:
        out_fp.write(final_str)


# =============================================================================


def port_index(port):
    """
    Returns index in the port name like gfpga_pad_IO_A2F[1248]
    """
    indx_parser = re.compile(r"[a-zA-Z0-9_]*\[(?P<index>[0-9]+)\]$")
    match = indx_parser.fullmatch(port)
    index = -1
    if match is not None:
        index = int(match.group("index"))

    return index


def form_pin_header(direction, cap, max_tran):
    """
    Form pin header section
    """
    curr_str = "\n{}direction : {};\n{}capacitance : {};".format(add_tab(4), direction, add_tab(4), cap)
    curr_str += "\n{}max_transition : {};".format(add_tab(4), max_tran)
    return curr_str


# =============================================================================


def form_out_reset_timing_group(reset_name, timing_sense, timing_type, common_lib_data):
    """
    Form timing group for output pin when related pin is reset
    """
    cell_fall_val = common_lib_data["reset_timing"]["cell_fall_val"]
    fall_tran_val = common_lib_data["reset_timing"]["fall_tran_val"]
    curr_str = '\n{}timing () {{\n{}related_pin : "{}";'.format(add_tab(4), add_tab(5), reset_name)
    curr_str += "\n{}timing_sense : {};".format(add_tab(5), timing_sense)
    curr_str += "\n{}timing_type : {};".format(add_tab(5), timing_type)
    curr_str += "\n{}cell_fall (scalar) {{\n{}values({});\n{}}}".format(
        add_tab(5), add_tab(6), cell_fall_val, add_tab(5)
    )
    curr_str += "\n{}fall_transition (scalar) {{\n{}values({});\n{}}}".format(
        add_tab(5), add_tab(6), fall_tran_val, add_tab(5)
    )
    curr_str += "\n{}}}".format(add_tab(4))
    return curr_str


# =============================================================================


def form_out_timing_group(clk_name, timing_type, common_lib_data):
    """
    Form timing group for output pin in a Pin group in a library file
    """
    cell_rise_val = common_lib_data["output_timing"]["rising_edge_cell_rise_val"]
    cell_fall_val = common_lib_data["output_timing"]["rising_edge_cell_fall_val"]
    rise_tran_val = common_lib_data["output_timing"]["rising_edge_rise_tran_val"]
    fall_tran_val = common_lib_data["output_timing"]["rising_edge_fall_tran_val"]
    curr_str = '\n{}timing () {{\n{}related_pin : "{}";'.format(add_tab(4), add_tab(5), clk_name)
    curr_str += "\n{}timing_type : {};".format(add_tab(5), timing_type)
    curr_str += "\n{}cell_rise (scalar) {{\n{}values({});\n{}}}".format(
        add_tab(5), add_tab(6), cell_rise_val, add_tab(5)
    )
    curr_str += "\n{}rise_transition (scalar) {{\n{}values({});\n{}}}".format(
        add_tab(5), add_tab(6), rise_tran_val, add_tab(5)
    )
    curr_str += "\n{}cell_fall (scalar) {{\n{}values({});\n{}}}".format(
        add_tab(5), add_tab(6), cell_fall_val, add_tab(5)
    )
    curr_str += "\n{}fall_transition (scalar) {{\n{}values({});\n{}}}".format(
        add_tab(5), add_tab(6), fall_tran_val, add_tab(5)
    )
    curr_str += "\n{}}}".format(add_tab(4))
    return curr_str


# =============================================================================


def add_tab(num_tabs):
    """
    Add given number of tabs and return the string
    """
    curr_str = "\t" * num_tabs
    return curr_str


# =============================================================================


def form_in_timing_group(clk_name, timing_type, common_lib_data):
    """
    Form timing group for input pin in a Pin group in a library file
    """
    rise_constraint_val = "0.0"
    fall_constraint_val = "0.0"
    if timing_type == "setup_rising":
        rise_constraint_val = common_lib_data["input_timing"]["setup_rising_rise_constraint_val"]
        fall_constraint_val = common_lib_data["input_timing"]["setup_rising_fall_constraint_val"]
    else:
        rise_constraint_val = common_lib_data["input_timing"]["hold_rising_rise_constraint_val"]
        fall_constraint_val = common_lib_data["input_timing"]["hold_rising_fall_constraint_val"]

    curr_str = '\n{}timing () {{\n{}related_pin : "{}";'.format(add_tab(4), add_tab(5), clk_name)
    curr_str += "\n{}timing_type : {};".format(add_tab(5), timing_type)
    curr_str += "\n{}rise_constraint (scalar) {{\n{}values({});\n{}}}".format(
        add_tab(5), add_tab(6), rise_constraint_val, add_tab(5)
    )
    curr_str += "\n{}fall_constraint (scalar) {{\n{}values({});\n{}}}".format(
        add_tab(5), add_tab(6), fall_constraint_val, add_tab(5)
    )
    curr_str += "\n{}}}".format(add_tab(4))
    return curr_str


# =============================================================================


def parse_xml(xml_file):
    """
    Parses given xml file and collects the desired data
    """
    parser = ET.XMLParser(resolve_entities=False, strip_cdata=False)
    xml_tree = ET.parse(xml_file, parser)
    xml_root = xml_tree.getroot()

    port_names = defaultdict(set)
    # Get the "IO" section
    xml_io = xml_root.find("IO")
    if xml_io is None:
        print("ERROR: No mandatory 'IO' section defined in 'DEVICE' section")
        sys.exit(1)

    xml_top_io = xml_io.find("TOP_IO")
    if xml_top_io is not None:
        port_names = parse_xml_io(xml_top_io, port_names)

    xml_bottom_io = xml_io.find("BOTTOM_IO")
    if xml_bottom_io is not None:
        port_names = parse_xml_io(xml_bottom_io, port_names)

    xml_left_io = xml_io.find("LEFT_IO")
    if xml_left_io is not None:
        port_names = parse_xml_io(xml_left_io, port_names)

    xml_right_io = xml_io.find("RIGHT_IO")
    if xml_right_io is not None:
        port_names = parse_xml_io(xml_right_io, port_names)

    return port_names


# =============================================================================


def parse_xml_io(xml_io, port_names):
    """
    Parses xml and get data for mapped_name key
    """
    assert xml_io is not None
    for xml_cell in xml_io.findall("CELL"):
        mapped_name = xml_cell.get("mapped_name")
        # define properties for scalar pins
        scalar_mapped_pins = vec_to_scalar(mapped_name)
        if mapped_name.find("F2A") != -1:
            port_names["F2A"].update(scalar_mapped_pins)
        elif mapped_name.find("A2F") != -1:
            port_names["A2F"].update(scalar_mapped_pins)
    return port_names


# =============================================================================


def vec_to_scalar(port_name):
    """
    Converts given bus port into a list of its scalar port equivalents
    """
    scalar_ports = []
    if port_name is not None and ":" in port_name:
        open_brace = port_name.find("[")
        close_brace = port_name.find("]")
        if open_brace == -1 or close_brace == -1:
            print(
                'Invalid portname "{}" specified. Bus ports should contain [ ] to specify range'.format(port_name),
                file=sys.stderr,
            )
            sys.exit(1)
        bus = port_name[open_brace + 1 : close_brace]
        lsb = int(bus[: bus.find(":")])
        msb = int(bus[bus.find(":") + 1 :])
        if lsb > msb:
            for i in range(lsb, msb - 1, -1):
                curr_port_name = port_name[:open_brace] + "[" + str(i) + "]"
                scalar_ports.append(curr_port_name)
        else:
            for i in range(lsb, msb + 1):
                curr_port_name = port_name[:open_brace] + "[" + str(i) + "]"
                scalar_ports.append(curr_port_name)
    else:
        scalar_ports.append(port_name)

    return scalar_ports


# =============================================================================

if __name__ == "__main__":
    main()