# See LICENSE for licensing information.
#
# Copyright (c) 2016-2019 Regents of the University of California and The Board
# of Regents for the Oklahoma Agricultural and Mechanical College
# (acting for and on behalf of Oklahoma State University)
# All rights reserved.
#
import debug
from tech import GDS, drc
from vector import vector
from tech import layer
import math


class pin_layout:
    """
    A class to represent a rectangular design pin. It is limited to a
    single shape.
    """

    def __init__(self, name, rect, layer_name_pp):
        self.name = name
        # repack the rect as a vector, just in case
        if type(rect[0]) == vector:
            self._rect = rect
        else:
            self._rect = [vector(rect[0]), vector(rect[1])]
        # snap the rect to the grid
        self._rect = [x.snap_to_grid() for x in self.rect]

        debug.check(self.width() > 0, "Zero width pin.")
        debug.check(self.height() > 0, "Zero height pin.")
        
        # if it's a string, use the name
        if type(layer_name_pp) == str:
            self._layer = layer_name_pp
        # else it is required to be a lpp
        else:
            for (layer_name, lpp) in layer.items():
                if not lpp:
                    continue
                if self.same_lpp(layer_name_pp, lpp):
                    self._layer = layer_name
                    break
            else:
                debug.error("Couldn't find layer {}".format(layer_name_pp), -1)

        self.lpp = layer[self.layer]
        self._recompute_hash()

    @property
    def layer(self):
        return self._layer

    @layer.setter
    def layer(self, l):
        self._layer = l
        self._recompute_hash()

    @property
    def rect(self):
        return self._rect

    @rect.setter
    def rect(self, r):
        self._rect = r
        self._recompute_hash()

    def _recompute_hash(self):
        """ Recompute the hash for our hash cache """
        self._hash = hash(repr(self))

    def __str__(self):
        """ override print function output """
        return "({} layer={} ll={} ur={})".format(self.name,
                                                  self.layer,
                                                  self.rect[0],
                                                  self.rect[1])

    def __repr__(self):
        """
        override repr function output (don't include
        name since pin shapes could have same shape but diff name e.g. blockage vs A)
        """
        return "(layer={} ll={} ur={})".format(self.layer,
                                               self.rect[0],
                                               self.rect[1])

    def __hash__(self):
        """
        Implement the hash function for sets etc. We only return a cached
        value, that is updated when either 'rect' or 'layer' are changed. This
        is a major speedup, if pin_layout is used as a key for dicts.
        """
        return self._hash
    
    def __lt__(self, other):
        """ Provide a function for ordering items by the ll point """
        (ll, ur) = self.rect
        (oll, our) = other.rect
        
        if ll.x < oll.x and ll.y < oll.y:
            return True
            
        return False
    
    def __eq__(self, other):
        """ Check if these are the same pins for duplicate checks """
        if isinstance(other, self.__class__):
            return (self.lpp == other.lpp and self.rect == other.rect)
        else:
            return False

    def bbox(self, pin_list):
        """
        Given a list of layout pins, create a bounding box layout.
        """
        (ll, ur) = self.rect
        min_x = ll.x
        max_x = ur.x
        min_y = ll.y
        max_y = ur.y

        for pin in pin_list:
            min_x = min(min_x, pin.ll().x)
            max_x = max(max_x, pin.ur().x)
            min_y = min(min_y, pin.ll().y)
            max_y = max(max_y, pin.ur().y)

        self.rect = [vector(min_x, min_y), vector(max_x, max_y)]
        
    def fix_minarea(self):
        """
        Try to fix minimum area rule.
        """
        min_area = drc("{}_minarea".format(self.layer))
        pass
    
    def inflate(self, spacing=None):
        """
        Inflate the rectangle by the spacing (or other rule)
        and return the new rectangle.
        """
        if not spacing:
            spacing = 0.5*drc("{0}_to_{0}".format(self.layer))
            
        (ll, ur) = self.rect
        spacing = vector(spacing, spacing)
        newll = ll - spacing
        newur = ur + spacing
        
        return (newll, newur)

    def intersection(self, other):
        """ Check if a shape overlaps with a rectangle  """
        (ll, ur) = self.rect
        (oll, our) = other.rect

        min_x = max(ll.x, oll.x)
        max_x = min(ll.x, oll.x)
        min_y = max(ll.y, oll.y)
        max_y = min(ll.y, oll.y)

        return [vector(min_x, min_y), vector(max_x, max_y)]

    def xoverlaps(self, other):
        """ Check if shape has x overlap """
        (ll, ur) = self.rect
        (oll, our) = other.rect
        x_overlaps = False
        # check if self is within other x range
        if (ll.x >= oll.x and ll.x <= our.x) or (ur.x >= oll.x and ur.x <= our.x):
            x_overlaps = True
        # check if other is within self x range
        if (oll.x >= ll.x and oll.x <= ur.x) or (our.x >= ll.x and our.x <= ur.x):
            x_overlaps = True

        return x_overlaps

    def yoverlaps(self, other):
        """ Check if shape has x overlap """
        (ll, ur) = self.rect
        (oll, our) = other.rect
        y_overlaps = False

        # check if self is within other y range
        if (ll.y >= oll.y and ll.y <= our.y) or (ur.y >= oll.y and ur.y <= our.y):
            y_overlaps = True
        # check if other is within self y range
        if (oll.y >= ll.y and oll.y <= ur.y) or (our.y >= ll.y and our.y <= ur.y):
            y_overlaps = True

        return y_overlaps
    
    def xcontains(self, other):
        """ Check if shape contains the x overlap """
        (ll, ur) = self.rect
        (oll, our) = other.rect

        return (oll.x >= ll.x and our.x <= ur.x)

    def ycontains(self, other):
        """ Check if shape contains the y overlap """
        (ll, ur) = self.rect
        (oll, our) = other.rect

        return (oll.y >= ll.y and our.y <= ur.y)
    
    def contains(self, other):
        """ Check if a shape contains another rectangle  """
        # If it is the same shape entirely, it is contained!
        if self == other:
            return True
        
        # Can only overlap on the same layer
        if not self.same_lpp(self.lpp, other.lpp):
            return False

        if not self.xcontains(other):
            return False

        if not self.ycontains(other):
            return False

        return True

    def contained_by_any(self, shape_list):
        """ Checks if shape is contained by any in the list """
        for shape in shape_list:
            if shape.contains(self):
                return True
        return False
    
    def overlaps(self, other):
        """ Check if a shape overlaps with a rectangle  """
        # Can only overlap on the same layer
        if not self.same_lpp(self.lpp, other.lpp):
            return False
        
        x_overlaps = self.xoverlaps(other)
        y_overlaps = self.yoverlaps(other)

        return x_overlaps and y_overlaps

    def area(self):
        """ Return the area. """
        return self.height()*self.width()
    
    def height(self):
        """ Return height. Abs is for pre-normalized value."""
        return abs(self.rect[1].y-self.rect[0].y)
    
    def width(self):
        """ Return width. Abs is for pre-normalized value."""
        return abs(self.rect[1].x-self.rect[0].x)

    def normalize(self):
        """ Re-find the LL and UR points after a transform """
        (first, second) = self.rect
        ll = vector(min(first[0], second[0]), min(first[1], second[1]))
        ur = vector(max(first[0], second[0]), max(first[1], second[1]))
        self.rect=[ll, ur]
        
    def transform(self, offset, mirror, rotate):
        """
        Transform with offset, mirror and rotation
        to get the absolute pin location.
        We must then re-find the ll and ur.
        The master is the cell instance.
        """
        (ll, ur) = self.rect
        if mirror == "MX":
            ll = ll.scale(1, -1)
            ur = ur.scale(1, -1)
        elif mirror == "MY":
            ll = ll.scale(-1, 1)
            ur = ur.scale(-1, 1)
        elif mirror == "XY":
            ll = ll.scale(-1, -1)
            ur = ur.scale(-1, -1)
            
        if rotate == 90:
            ll = ll.rotate_scale(-1, 1)
            ur = ur.rotate_scale(-1, 1)
        elif rotate == 180:
            ll = ll.scale(-1, -1)
            ur = ur.scale(-1, -1)
        elif rotate == 270:
            ll = ll.rotate_scale(1, -1)
            ur = ur.rotate_scale(1, -1)

        self.rect = [offset + ll, offset + ur]
        self.normalize()

    def center(self):
        return vector(0.5*(self.rect[0].x+self.rect[1].x),
                      0.5*(self.rect[0].y+self.rect[1].y))

    def cx(self):
        """ Center x """
        return 0.5*(self.rect[0].x+self.rect[1].x)

    def cy(self):
        """ Center y """
        return 0.5*(self.rect[0].y+self.rect[1].y)
    
    # The four possible corners
    def ll(self):
        """ Lower left point """
        return self.rect[0]

    def ul(self):
        """ Upper left point """
        return vector(self.rect[0].x, self.rect[1].y)

    def lr(self):
        """ Lower right point """
        return vector(self.rect[1].x, self.rect[0].y)

    def ur(self):
        """ Upper right point """
        return self.rect[1]
    
    # The possible y edge values
    def uy(self):
        """ Upper y value """
        return self.rect[1].y

    def by(self):
        """ Bottom y value """
        return self.rect[0].y

    # The possible x edge values
    
    def lx(self):
        """ Left x value """
        return self.rect[0].x
    
    def rx(self):
        """ Right x value """
        return self.rect[1].x
    
    # The edge centers
    def rc(self):
        """ Right center point """
        return vector(self.rect[1].x,
                      0.5*(self.rect[0].y+self.rect[1].y))

    def lc(self):
        """ Left center point """
        return vector(self.rect[0].x,
                      0.5*(self.rect[0].y+self.rect[1].y))
    
    def uc(self):
        """ Upper center point """
        return vector(0.5*(self.rect[0].x+self.rect[1].x),
                      self.rect[1].y)

    def bc(self):
        """ Bottom center point """
        return vector(0.5*(self.rect[0].x+self.rect[1].x),
                      self.rect[0].y)

    def gds_write_file(self, newLayout):
        """Writes the pin shape and label to GDS"""
        debug.info(4, "writing pin (" + str(self.layer) + "):"
                   + str(self.width()) + "x"
                   + str(self.height()) + " @ " + str(self.ll()))
        (layer_num, purpose) = layer[self.layer]
        newLayout.addBox(layerNumber=layer_num,
                         purposeNumber=purpose,
                         offsetInMicrons=self.ll(),
                         width=self.width(),
                         height=self.height(),
                         center=False)
        # Add the tet in the middle of the pin.
        # This fixes some pin label offsetting when GDS gets
        # imported into Magic.
        newLayout.addText(text=self.name,
                          layerNumber=layer_num,
                          offsetInMicrons=self.center(),
                          magnification=GDS["zoom"],
                          rotate=None)

    def compute_overlap(self, other):
        """ Calculate the rectangular overlap of two rectangles. """
        (r1_ll, r1_ur) = self.rect
        (r2_ll, r2_ur) = other.rect

        # ov_ur = vector(min(r1_ur.x,r2_ur.x),min(r1_ur.y,r2_ur.y))
        # ov_ll = vector(max(r1_ll.x,r2_ll.x),max(r1_ll.y,r2_ll.y))

        dy = min(r1_ur.y, r2_ur.y) - max(r1_ll.y, r2_ll.y)
        dx = min(r1_ur.x, r2_ur.x) - max(r1_ll.x, r2_ll.x)
        
        if dx >= 0 and dy >= 0:
            return [dx, dy]
        else:
            return [0, 0]

    def distance(self, other):
        """
        Calculate the distance to another pin layout.
        """
        (r1_ll, r1_ur) = self.rect
        (r2_ll, r2_ur) = other.rect

        def dist(x1, y1, x2, y2):
            return math.sqrt((x2-x1)**2 + (y2-y1)**2)
        
        left = r2_ur.x < r1_ll.x
        right = r1_ur.x < r2_ll.x
        bottom = r2_ur.y < r1_ll.y
        top = r1_ur.y < r2_ll.y

        if top and left:
            return dist(r1_ll.x, r1_ur.y, r2_ur.x, r2_ll.y)
        elif left and bottom:
            return dist(r1_ll.x, r1_ll.y, r2_ur.x, r2_ur.y)
        elif bottom and right:
            return dist(r1_ur.x, r1_ll.y, r2_ll.x, r2_ur.y)
        elif right and top:
            return dist(r1_ur.x, r1_ur.y, r2_ll.x, r2_ll.y)
        elif left:
            return r1_ll.x - r2_ur.x
        elif right:
            return r2_ll.x - r1_ur.x
        elif bottom:
            return r1_ll.y - r2_ur.y
        elif top:
            return r2_ll.y - r1_ur.y
        else:
            # rectangles intersect
            return 0
        
    def overlap_length(self, other):
        """
        Calculate the intersection segment and determine its length
        """

        if self.contains(other):
            return math.inf
        elif other.contains(self):
            return math.inf
        else:
            intersections = self.compute_overlap_segment(other)
            # This is the common case where two pairs of edges overlap
            # at two points, so just find the distance between those two points
            if len(intersections) == 2:
                (p1, p2) = intersections
                return math.sqrt(pow(p1[0]-p2[0], 2) + pow(p1[1]-p2[1], 2))
            else:
                # This is where we had a corner intersection or none
                return 0

    
    def compute_overlap_segment(self, other):
        """
        Calculate the intersection segment of two rectangles
        (if any)
        """
        (r1_ll, r1_ur) = self.rect
        (r2_ll, r2_ur) = other.rect

        # The other corners besides ll and ur
        r1_ul = vector(r1_ll.x, r1_ur.y)
        r1_lr = vector(r1_ur.x, r1_ll.y)
        r2_ul = vector(r2_ll.x, r2_ur.y)
        r2_lr = vector(r2_ur.x, r2_ll.y)

        from itertools import tee
        
        def pairwise(iterable):
            "s -> (s0,s1), (s1,s2), (s2, s3), ..."
            a, b = tee(iterable)
            next(b, None)
            return zip(a, b)
        
        # R1 edges CW
        r1_cw_points = [r1_ll, r1_ul, r1_ur, r1_lr, r1_ll]
        r1_edges = []
        for (p, q) in pairwise(r1_cw_points):
            r1_edges.append([p, q])
        
        # R2 edges CW
        r2_cw_points = [r2_ll, r2_ul, r2_ur, r2_lr, r2_ll]
        r2_edges = []
        for (p, q) in pairwise(r2_cw_points):
            r2_edges.append([p, q])

        # There are 4 edges on each rectangle
        # so just brute force check intersection of each
        # Two pairs of them should intersect
        intersections = []
        for r1e in r1_edges:
            for r2e in r2_edges:
                i = self.segment_intersection(r1e, r2e)
                if i:
                    intersections.append(i)

        return intersections

    def on_segment(self, p, q, r):
        """
        Given three co-linear points, determine if q lies on segment pr
        """
        if q.x <= max(p.x, r.x) and \
           q.x >= min(p.x, r.x) and \
           q.y <= max(p.y, r.y) and \
           q.y >= min(p.y, r.y):
            return True
        
        return False
    
    def segment_intersection(self, s1, s2):
        """
        Determine the intersection point of two segments
        Return the a segment if they overlap.
        Return None if they don't.
        """
        (a, b) = s1
        (c, d) = s2
        # Line AB represented as a1x + b1y = c1
        a1 = b.y - a.y
        b1 = a.x - b.x
        c1 = a1*a.x + b1*a.y
        
        # Line CD represented as a2x + b2y = c2
        a2 = d.y - c.y
        b2 = c.x - d.x
        c2 = a2*c.x + b2*c.y
        
        determinant = a1*b2 - a2*b1

        if determinant != 0:
            x = (b2*c1 - b1*c2)/determinant
            y = (a1*c2 - a2*c1)/determinant
            
            r = vector(x, y).snap_to_grid()
            if self.on_segment(a, r, b) and self.on_segment(c, r, d):
                return r
           
        return None

    def same_lpp(self, lpp1, lpp2):
        """
        Check if the layers and purposes are the same.
        Ignore if purpose is a None.
        """
        if lpp1[1] == None or lpp2[1] == None:
            return lpp1[0] == lpp2[0]
        
        return lpp1[0] == lpp2[0] and lpp1[1] == lpp2[1]
