from __future__ import print_function
from collections import OrderedDict, namedtuple
import itertools
import re
import eblif
import lxml.etree as ET

IoConstraint = namedtuple('IoConstraint', 'name x y z comment')

HEADER_TEMPLATE = """\
#{name:<{nl}} x   y   z    pcf_line
#{s:-^{nl}} --  --  -    ----"""

CONSTRAINT_TEMPLATE = '{name:<{nl}} {x: 3} {y: 3} {z: 2}  # {comment}'
INOUT_REGEX = re.compile(r"^(.+)(_\$inp|_\$out)(.*)$")
NETNAME_REGEX = re.compile(r"(.+?)(\[[0-9]+\]$|$)")


class IoPlace(object):
    def __init__(self):
        self.constraints = OrderedDict()
        self.inputs = set()
        self.outputs = set()
        self.net_to_block = None
        self.net_map = {}
        self.block_to_inst = {}
        self.inout_nets = set()
        self.net_to_pad = set()
        self.net_file_io = set()

    def read_io_loc_pairs(self, blif):
        """
         Read IO_LOC_PAIRS parameters from eblif carrying the information
         which package pin a specified top port is constrained, e.g. O_LOC_PAIRS = "portA:D1"
         In case of differential inputs/outputs there are two pairs of the parameter,
         i.e. IO_LOC_PAIRS = "portA_p:D2,portA_n:D4"
        """
        if 'subckt' not in blif:
            return
        for attr in blif['subckt']:
            if 'param' not in attr:
                continue
            if 'IO_LOC_PAIRS' in attr['param']:
                locs = attr['param']['IO_LOC_PAIRS'][1:-1].split(',')
                if 'NONE' in locs:
                    continue
                for loc in locs:
                    net, pad = loc.split(':')
                    self.net_to_pad.add((net, pad))

    def read_io_list_from_eblif(self, eblif_file):
        blif = eblif.parse_blif(eblif_file)

        self.inputs = set(blif['inputs']['args'])
        self.outputs = set(blif['outputs']['args'])

        # Build a net name map that maps products of an inout port split into
        # their formet name.
        #
        # For example, an inout port 'A' is split into 'A_$inp' and 'A_$out',
        # port B[2] into 'B_$inp[2]' and 'B_$out[2]'.
        self.net_map = {}
        self.inout_nets = set()
        for net in itertools.chain(self.inputs, self.outputs):
            match = INOUT_REGEX.match(net)
            if match:
                alias = match.group(1) + match.group(3)
                self.inout_nets.add(alias)
                self.net_map[net] = alias
            else:
                self.net_map[net] = net
        self.read_io_loc_pairs(blif)

    def load_block_names_from_net_file(self, net_file):
        """
        .place files expect top-level block (cluster) names, not net names, so
        build a mapping from net names to block names from the .net file.
        """
        net_xml = ET.parse(net_file)
        net_root = net_xml.getroot()
        self.net_to_block = {}

        for block in net_root.xpath("//block"):
            instance = block.attrib["instance"]
            if instance != "inpad[0]" and instance != "outpad[0]":
                continue

            top_block = block.getparent()
            assert top_block is not None
            while top_block.getparent() is not net_root:
                assert top_block is not None
                top_block = top_block.getparent()
            self.net_to_block[block.get("name")] = top_block.get("name")

        # Loop over all top-level blocks. Store block name to its instance
        # correspondences.
        for block_xml in net_root.findall("block"):
            name = block_xml.attrib["name"]
            inst = block_xml.attrib["instance"]

            assert name not in self.block_to_inst, block_xml.attrib
            self.block_to_inst[name] = inst

    def load_net_file_ios(self, net_file):
        """
        Loads input and outputs net names from the netlist file.
        """

        def get_ios(net_root, io_types):
            "Get the top level io signals from the netlist XML root."
            for io_type in io_types:
                io = net_root.xpath("/block/{}/text ()".format(io_type))

                if len(io) == 1:
                    yield io[0]

        net_xml = ET.parse(net_file)
        net_root = net_xml.getroot()

        for io_line in get_ios(net_root, ["inputs", "outputs"]):
            io_list = io_line.split(" ")
            for io in io_list:
                self.net_file_io.add(io.replace("out:", ""))

    def get_top_level_block_instance_for_net(self, net_name):
        """
        Returns a name of the top-level block instance for the given net
        name.
        """
        assert self.is_net(net_name)

        # VPR prefixes output constraints with "out:"
        if net_name in self.outputs:
            net_name = 'out:' + net_name

        # This is an inout net
        if net_name in self.inout_nets:
            block_names = set()

            for prefix, suffix in zip(["", "out:"], ["_$inp", "_$out"]):
                match = NETNAME_REGEX.match(net_name)
                name = prefix + match.group(1) + suffix + match.group(2)
                block_names.add(self.net_to_block[name])

            # Both parts of the net should point to the same block
            assert len(block_names) == 1, (net_name, block_names)
            return self.block_to_inst[list(block_names)[0]]

        # A regular net
        else:
            if net_name in self.net_to_block:
                block_name = self.net_to_block[net_name]
                return self.block_to_inst[block_name]
            else:
                return None

    def constrain_net(self, net_name, loc, comment=""):
        assert len(loc) == 3
        assert net_name not in self.constraints

        assert self.is_net(net_name), "net {} not in eblif".format(net_name)

        # VPR prefixes output constraints with "out:"
        if net_name in self.outputs:
            net_name = 'out:' + net_name

        # This is an inout net
        if net_name in self.inout_nets:
            for prefix, suffix in zip(["", "out:"], ["_$inp", "_$out"]):

                match = NETNAME_REGEX.match(net_name)
                name = prefix + match.group(1) + suffix + match.group(2)

                self.constraints[name] = IoConstraint(
                    name=name,
                    x=loc[0],
                    y=loc[1],
                    z=loc[2],
                    comment=comment,
                )

        # A regular net
        else:
            self.constraints[net_name] = IoConstraint(
                name=net_name,
                x=loc[0],
                y=loc[1],
                z=loc[2],
                comment=comment,
            )

    def output_io_place(self, f):
        max_name_length = max(len(c.name) for c in self.constraints.values())
        print(
            HEADER_TEMPLATE.format(
                name="Block Name", nl=max_name_length, s=""
            ),
            file=f
        )

        constrained_blocks = {}

        for vpr_net, constraint in self.constraints.items():
            name = constraint.name
            name = self.net_to_block.get(name) if self.net_to_block else name

            # This block is already constrained, check if there is no
            # conflict there.
            if name in constrained_blocks:
                existing = constrained_blocks[name]

                if existing.x != constraint.x or\
                   existing.y != constraint.y or\
                   existing.z != constraint.z:

                    print(
                        "Error: block '{}' has multiple conflicting constraints!"
                        .format(name)
                    )
                    print("", constrained_blocks[name])
                    print("", constraint)
                    exit(-1)

                # Don't write the second constraing
                continue

            # omit if no corresponding block name for the net
            if name is not None:
                print(
                    CONSTRAINT_TEMPLATE.format(
                        name=name,
                        nl=max_name_length,
                        x=constraint.x,
                        y=constraint.y,
                        z=constraint.z,
                        comment=constraint.comment
                    ),
                    file=f
                )

                # Add to constrained block list
                constrained_blocks[name] = constraint

    def is_net(self, net):
        return net in self.net_map.values()

    def is_net_packed(self, net):
        return net in self.net_file_io

    def get_nets(self):
        for net in self.inputs:
            yield self.net_map[net]
        for net in self.outputs:
            yield self.net_map[net]