
import math

from .. import util
from ..euclid.shapes import Circle, Arc, Line as ELine, OriginLine
from ..euclid import intersection
from ..euclid.intersection import InfiniteIntersections, SingleIntersection, \
                                  NoIntersection
from .shapes import Point
from . import shapes as poincare


class Hypercycle:
    def __init__(self, projShape, segment=False):
        assert isinstance(projShape, (Circle, Arc, ELine, OriginLine))
        if segment and not isinstance(projShape, (Arc, ELine)):
            raise ValueError('Not enough information to determine segment endpoints')
        unit = Circle(0,0,1)
        if segment:
            if isinstance(projShape, Arc):
                # TODO: Trim if arc extends outside unit circle
                pass
            elif isinstance(projShape, ELine):
                # TODO: Trim if arc extends outside unit circle
                pass
            else:
                raise ValueError('Unknown type')
        else:
            if isinstance(projShape, Circle):
                x1, y1, x2, y2 = intersection.circleCircle(projShape, unit)
                if projShape.cw:
                    x1, y1, x2, y2 = x2, y2, x1, y1
                projShape = Arc.fromPointsWithCenter(x1, y1, x2, y2,
                                    projShape.cx, projShape.cy, r=projShape.r,
                                    cw=projShape.cw)
            elif isinstance(projShape, ELine):
                x1, y1, x2, y2 = intersection.circleLine(unit, projShape)
                # Keep direction of line the same
                origAng = math.atan2(projShape.y2-projShape.y1,
                                     projShape.x2-projShape.x1)
                newAng = math.atan2(y2-y1, x2-x1)
                angDiff = (newAng - origAng) % (math.pi*2)
                if math.pi/2 < angDiff < 3*math.pi/2:
                    x1, y1, x2, y2 = x2, y2, x1, y1
                projShape = ELine(x1, y1, x2, y2)
            else:
                raise ValueError('Unknown type')
        self.projShape = projShape
        self.segment = segment
    def startPoint(self):
        return Point(*self.projShape.startPoint())
    def endPoint(self):
        return Point(*self.projShape.endPoint())
    def intersectionsWithHcycle(self, hcycle2):
        ''' Returns list of intersections in the unit circle '''
        x2, y2 = 1, 1  # Default, invalid
        try:
            if isinstance(self.projShape, Circle):
                if isinstance(hcycle2.projShape, Circle):
                    x1, y1, x2, y2 = intersection.circleCircle(
                                        self.projShape, hcycle2.projShape)
                else:
                    x1, y1, x2, y2 = intersection.circleLine(
                                        self.projShape, hcycle2.projShape)
            else:
                if isinstance(hcycle2.projShape, Circle):
                    x1, y1, x2, y2 = intersection.circleLine(
                                        hcycle2.projShape, self.projShape)
                else:
                    x1, y1 = intersection.lineLine(
                                self.projShape, hcycle2.projShape)
        except InfiniteIntersections as e:
            raise e from None
        except SingleIntersection as e:
            x1, y1 = e.args
        except NoIntersection:
            x1, y1 = 1, 1  # Invalid
        pts = []
        try:
            pts.append(Point.fromEuclid(x1, y1))
        except ValueError: pass
        try:
            pts.append(Point.fromEuclid(x2, y2))
        except ValueError: pass
        return pts
    def trimmed(self, x1, y1, x2, y2, **kwargs):
        ''' Returns a segment of this hypercycle going from x1,y1
            to x2,y2 (assuming that x1,y1 and x2,y2 are on the
            hypercycle) '''
        trimmedShape = self.projShape.trimmed(x1, y1, x2, y2, **kwargs)
        return type(self)(trimmedShape, segment=True)
    def midpointEuclid(self):
        x, y = self.projShape.midpoint()
        return Point(x, y)
    def reverse(self):
        self.projShape.reverse()
    def reversed(self):
        newShape = self.projShape.reversed()
        newObj = type(self)(newShape, segment=True)
        newObj.segment = self.segment
        return newObj
    def makePerpendicular(self, x, y):
        if util.nearZero(x) and util.nearZero(y):
            radical1 = None
        else:
            radical1 = ELine.radicalAxis(Circle(0,0,1), (x,y))
        radical2 = ELine.radicalAxis(self.projShape, (x,y))
        if radical1 is None or radical1.parallelTo(radical2):
            # Infinite radius circle
            shape = radical2.makePerpendicular(x,y)
            # Ensure correct direction
            if isinstance(self.projShape, ELine):
                if shape.antiparallelTo(self.projShape):
                    shape.reverse()
            else:  # projShape is a Circle
                radial = ELine.fromPoints(x, y, self.projShape.cx, self.projShape.cy)
                if radial.antiparallelTo(shape) ^ self.projShape.cw:
                    shape.reverse()
            return poincare.Line(shape, segment=False)
        else:
            cx, cy = intersection.lineLine(radical1, radical2)
            r = math.hypot(cy-y, cx-x)
            shape = Circle(cx, cy, r)
            # Ensure correct direction
            shape.cw = False
            if isinstance(self.projShape, ELine):
                x1, y1, x2, y2 = intersection.lineCircle(self.projShape, shape)
            else:  # projShape is a Circle
                x1, y1, x2, y2 = intersection.circleCircle(self.projShape, shape)
                shape.cw = shape.cw ^ self.projShape.cw
            if math.hypot(x1, y1) <= math.hypot(x2, y2):
                shape.cw = not shape.cw
            return poincare.Line(shape, segment=False)
    def makeCap(self, point):
        if point.isIdeal():
            return point
        else:
            return self.makePerpendicular(*point)
    def makeOffset(self, offset):
        return Hypercycle.fromHypercycleOffset(self, offset)
    @classmethod
    def fromHypercycleOffset(cls, hcycle, offset, unit=Circle(0,0,1)):
        dh = offset #dh = math.asinh(offset/2)
        if isinstance(hcycle.projShape, Circle):
            # May throw if bad geometry
            x1, y1, x2, y2 = intersection.circleCircle(hcycle.projShape, unit)
            cx, cy = hcycle.projShape.cx, hcycle.projShape.cy
            r, cw = hcycle.projShape.r, hcycle.projShape.cw
            if cw:
                x1, y1, x2, y2 = x2, y2, x1, y1
            rc = math.hypot(cx, cy)
            deMid = rc - r
            dhMid = 2 * math.atanh(deMid)
            sign = -1 if cw else 1
            t = math.tanh((dhMid + sign*dh)/2)
            xOff, yOff = t * cx / rc, t * cy / rc
        else:
            # May throw if bad geometry
            x1, y1, x2, y2 = intersection.lineCircle(hcycle.projShape, unit)
            lineAng = math.atan2(y2-y1, x2-x1)
            mx, my = (x1+x2)/2, (y1+y2)/2  # Midpoint
            if util.nearZero(mx) and util.nearZero(my):
                ang = math.atan2(y2-y1, x2-x1) + math.pi/2
            else:
                ang = math.atan2(my, mx)
            # Test if the line goes clockwise around the origin
            cw = (ang - lineAng) % (math.pi*2) < math.pi
            rm = math.hypot(mx, my)
            deMid = rm
            dhMid = 2 * math.atanh(deMid)
            sign = 1 if cw else -1
            t = math.tanh((dhMid + sign*dh)/2)
            xOff, yOff = t * math.cos(ang), t * math.sin(ang)
        return cls.fromPoints(x1, y1, x2, y2, xOff, yOff, segment=False, excludeMid=False)
    @staticmethod
    def _pointsInlineWithOrigin(x1, y1, x2, y2):
        if ((util.nearZero(x1) and util.nearZero(x2)) or
            (util.nearZero(y1) and util.nearZero(y2)) or
            (util.nearZero(x1) and util.nearZero(y1)) or
            (util.nearZero(x2) and util.nearZero(y2))):
            return True
        elif ((util.nearZero(x1) or util.nearZero(x2)) and
              (util.nearZero(y1) or util.nearZero(y2))):
            return False
        elif util.nearZero(x1) or util.nearZero(x2):
            return util.nearZero(x1/y1 - x2/y2)
        else:
            return util.nearZero(y1/x1 - y2/x2)
    @classmethod
    def fromPoints(cls, sx, sy, ex, ey, mx, my, segment=False, excludeMid=False, **kwargs):
        ''' Start xy, end xy, other xy; pass excludeMid=True if other point is
            not between start and end '''
        if util.nearZero(sx-ex) and util.nearZero(sy-ey):
            assert False, 'Start and end points are the same'
        if util.nearZero(sx-mx) and util.nearZero(sy-my):
            assert False, 'Start and mid points are the same'
        if util.nearZero(mx-ex) and util.nearZero(my-ey):
            assert False, 'Mid and end points are the same'
        if cls._pointsInlineWithOrigin(sx-mx, sy-my, ex-mx, ey-my):
            shape = ELine(sx, sy, ex, ey)
        else:
            shape = Arc.fromPoints(sx, sy, ex, ey, mx, my,
                                   excludeMid=excludeMid)
        return cls(shape, segment=segment, **kwargs)
    def toDrawables(self, elements, hwidth=None, transform=None, **kwargs):
        if hwidth is not None:
            try:
                hwidth1, hwidth2 = hwidth
            except TypeError:
                hwidth = float(hwidth)
                hwidth1, hwidth2 = hwidth/2, -hwidth/2
            if self.segment:
                edges = []
                edges.append(self.makeOffset(hwidth1))
                edges.append(self.makeCap(self.startPoint()))
                edges.append(self.makeOffset(hwidth2))
                edges.append(self.makeCap(self.endPoint()))
                poly = poincare.Polygon.fromEdges(edges, join=True)
                return poly.toDrawables(elements, transform=transform, **kwargs)
            else:
                edge1 = Hypercycle.fromHypercycleOffset(self, hwidth1).projShape
                edge2 = Hypercycle.fromHypercycleOffset(self, hwidth2).projShape
                edge2.reverse()
                path = elements.Path(**kwargs)
                if transform:
                    edge1 = transform.applyToShape(edge1)
                    edge2 = transform.applyToShape(edge2)
                edge1.drawToPath(path, includeM=True)
                edge2.drawToPath(path, includeM=False)
                path.Z()
                return (path,)
        else:
            shape = self.projShape
            if transform:
                shape = transform.applyToShape(shape)
            return shape.toDrawables(elements, **kwargs)
    def drawToPath(self, path, transform=None, **kwargs):
        shape = self.projShape
        if transform:
            shape = transform.applyToShape(shape)
        return shape.drawToPath(path, **kwargs)



import math

from .. import util
from ..euclid.shapes import Circle, Arc, Line as ELine, OriginLine
from ..euclid import intersection
from ..euclid.intersection import InfiniteIntersections, SingleIntersection, \
                                  NoIntersection
from .shapes import Point
from . import shapes as poincare


class Hypercycle:
    def __init__(self, projShape, segment=False):
        assert isinstance(projShape, (Circle, Arc, ELine, OriginLine))
        if segment and not isinstance(projShape, (Arc, ELine)):
            raise ValueError('Not enough information to determine segment endpoints')
        unit = Circle(0,0,1)
        if segment:
            if isinstance(projShape, Arc):
                # TODO: Trim if arc extends outside unit circle
                pass
            elif isinstance(projShape, ELine):
                # TODO: Trim if arc extends outside unit circle
                pass
            else:
                raise ValueError('Unknown type')
        else:
            if isinstance(projShape, Circle):
                x1, y1, x2, y2 = intersection.circleCircle(projShape, unit)
                if projShape.cw:
                    x1, y1, x2, y2 = x2, y2, x1, y1
                projShape = Arc.fromPointsWithCenter(x1, y1, x2, y2,
                                    projShape.cx, projShape.cy, r=projShape.r,
                                    cw=projShape.cw)
            elif isinstance(projShape, ELine):
                x1, y1, x2, y2 = intersection.circleLine(unit, projShape)
                # Keep direction of line the same
                origAng = math.atan2(projShape.y2-projShape.y1,
                                     projShape.x2-projShape.x1)
                newAng = math.atan2(y2-y1, x2-x1)
                angDiff = (newAng - origAng) % (math.pi*2)
                if math.pi/2 < angDiff < 3*math.pi/2:
                    x1, y1, x2, y2 = x2, y2, x1, y1
                projShape = ELine(x1, y1, x2, y2)
            else:
                raise ValueError('Unknown type')
        self.projShape = projShape
        self.segment = segment
    def startPoint(self):
        return Point(*self.projShape.startPoint())
    def endPoint(self):
        return Point(*self.projShape.endPoint())
    def intersectionsWithHcycle(self, hcycle2):
        ''' Returns list of intersections in the unit circle '''
        x2, y2 = 1, 1  # Default, invalid
        try:
            if isinstance(self.projShape, Circle):
                if isinstance(hcycle2.projShape, Circle):
                    x1, y1, x2, y2 = intersection.circleCircle(
                                        self.projShape, hcycle2.projShape)
                else:
                    x1, y1, x2, y2 = intersection.circleLine(
                                        self.projShape, hcycle2.projShape)
            else:
                if isinstance(hcycle2.projShape, Circle):
                    x1, y1, x2, y2 = intersection.circleLine(
                                        hcycle2.projShape, self.projShape)
                else:
                    x1, y1 = intersection.lineLine(
                                self.projShape, hcycle2.projShape)
        except InfiniteIntersections as e:
            raise e from None
        except SingleIntersection as e:
            x1, y1 = e.args
        except NoIntersection:
            x1, y1 = 1, 1  # Invalid
        pts = []
        try:
            pts.append(Point.fromEuclid(x1, y1))
        except ValueError: pass
        try:
            pts.append(Point.fromEuclid(x2, y2))
        except ValueError: pass
        return pts
    def trimmed(self, x1, y1, x2, y2, **kwargs):
        ''' Returns a segment of this hypercycle going from x1,y1
            to x2,y2 (assuming that x1,y1 and x2,y2 are on the
            hypercycle) '''
        trimmedShape = self.projShape.trimmed(x1, y1, x2, y2, **kwargs)
        return type(self)(trimmedShape, segment=True)
    def midpointEuclid(self):
        x, y = self.projShape.midpoint()
        return Point(x, y)
    def reverse(self):
        self.projShape.reverse()
    def reversed(self):
        newShape = self.projShape.reversed()
        newObj = type(self)(newShape, segment=True)
        newObj.segment = self.segment
        return newObj
    def makePerpendicular(self, x, y):
        if util.nearZero(x) and util.nearZero(y):
            radical1 = None
        else:
            radical1 = ELine.radicalAxis(Circle(0,0,1), (x,y))
        radical2 = ELine.radicalAxis(self.projShape, (x,y))
        if radical1 is None or radical1.parallelTo(radical2):
            # Infinite radius circle
            shape = radical2.makePerpendicular(x,y)
            # Ensure correct direction
            if isinstance(self.projShape, ELine):
                if shape.antiparallelTo(self.projShape):
                    shape.reverse()
            else:  # projShape is a Circle
                radial = ELine.fromPoints(x, y, self.projShape.cx, self.projShape.cy)
                if radial.antiparallelTo(shape) ^ self.projShape.cw:
                    shape.reverse()
            return poincare.Line(shape, segment=False)
        else:
            cx, cy = intersection.lineLine(radical1, radical2)
            r = math.hypot(cy-y, cx-x)
            shape = Circle(cx, cy, r)
            # Ensure correct direction
            shape.cw = False
            if isinstance(self.projShape, ELine):
                x1, y1, x2, y2 = intersection.lineCircle(self.projShape, shape)
            else:  # projShape is a Circle
                x1, y1, x2, y2 = intersection.circleCircle(self.projShape, shape)
                shape.cw = shape.cw ^ self.projShape.cw
            if math.hypot(x1, y1) <= math.hypot(x2, y2):
                shape.cw = not shape.cw
            return poincare.Line(shape, segment=False)
    def makeCap(self, point):
        if point.isIdeal():
            return point
        else:
            return self.makePerpendicular(*point)
    def makeOffset(self, offset):
        return Hypercycle.fromHypercycleOffset(self, offset)
    @classmethod
    def fromHypercycleOffset(cls, hcycle, offset, unit=Circle(0,0,1)):
        dh = offset #dh = math.asinh(offset/2)
        if isinstance(hcycle.projShape, Circle):
            # May throw if bad geometry
            x1, y1, x2, y2 = intersection.circleCircle(hcycle.projShape, unit)
            cx, cy = hcycle.projShape.cx, hcycle.projShape.cy
            r, cw = hcycle.projShape.r, hcycle.projShape.cw
            if cw:
                x1, y1, x2, y2 = x2, y2, x1, y1
            rc = math.hypot(cx, cy)
            deMid = rc - r
            dhMid = 2 * math.atanh(deMid)
            sign = -1 if cw else 1
            t = math.tanh((dhMid + sign*dh)/2)
            xOff, yOff = t * cx / rc, t * cy / rc
        else:
            # May throw if bad geometry
            x1, y1, x2, y2 = intersection.lineCircle(hcycle.projShape, unit)
            lineAng = math.atan2(y2-y1, x2-x1)
            mx, my = (x1+x2)/2, (y1+y2)/2  # Midpoint
            if util.nearZero(mx) and util.nearZero(my):
                ang = math.atan2(y2-y1, x2-x1) + math.pi/2
            else:
                ang = math.atan2(my, mx)
            # Test if the line goes clockwise around the origin
            cw = (ang - lineAng) % (math.pi*2) < math.pi
            rm = math.hypot(mx, my)
            deMid = rm
            dhMid = 2 * math.atanh(deMid)
            sign = 1 if cw else -1
            t = math.tanh((dhMid + sign*dh)/2)
            xOff, yOff = t * math.cos(ang), t * math.sin(ang)
        return cls.fromPoints(x1, y1, x2, y2, xOff, yOff, segment=False, excludeMid=False)
    @staticmethod
    def _pointsInlineWithOrigin(x1, y1, x2, y2):
        if ((util.nearZero(x1) and util.nearZero(x2)) or
            (util.nearZero(y1) and util.nearZero(y2)) or
            (util.nearZero(x1) and util.nearZero(y1)) or
            (util.nearZero(x2) and util.nearZero(y2))):
            return True
        elif ((util.nearZero(x1) or util.nearZero(x2)) and
              (util.nearZero(y1) or util.nearZero(y2))):
            return False
        elif util.nearZero(x1) or util.nearZero(x2):
            return util.nearZero(x1/y1 - x2/y2)
        else:
            return util.nearZero(y1/x1 - y2/x2)
    @classmethod
    def fromPoints(cls, sx, sy, ex, ey, mx, my, segment=False, excludeMid=False, **kwargs):
        ''' Start xy, end xy, other xy; pass excludeMid=True if other point is
            not between start and end '''
        if util.nearZero(sx-ex) and util.nearZero(sy-ey):
            assert False, 'Start and end points are the same'
        if util.nearZero(sx-mx) and util.nearZero(sy-my):
            assert False, 'Start and mid points are the same'
        if util.nearZero(mx-ex) and util.nearZero(my-ey):
            assert False, 'Mid and end points are the same'
        if cls._pointsInlineWithOrigin(sx-mx, sy-my, ex-mx, ey-my):
            shape = ELine(sx, sy, ex, ey)
        else:
            shape = Arc.fromPoints(sx, sy, ex, ey, mx, my,
                                   excludeMid=excludeMid)
        return cls(shape, segment=segment, **kwargs)
    def toDrawables(self, elements, hwidth=None, transform=None, **kwargs):
        if hwidth is not None:
            try:
                hwidth1, hwidth2 = hwidth
            except TypeError:
                hwidth = float(hwidth)
                hwidth1, hwidth2 = hwidth/2, -hwidth/2
            if self.segment:
                edges = []
                edges.append(self.makeOffset(hwidth1))
                edges.append(self.makeCap(self.startPoint()))
                edges.append(self.makeOffset(hwidth2))
                edges.append(self.makeCap(self.endPoint()))
                poly = poincare.Polygon.fromEdges(edges, join=True)
                return poly.toDrawables(elements, transform=transform, **kwargs)
            else:
                edge1 = Hypercycle.fromHypercycleOffset(self, hwidth1).projShape
                edge2 = Hypercycle.fromHypercycleOffset(self, hwidth2).projShape
                edge2.reverse()
                path = elements.Path(**kwargs)
                if transform:
                    edge1 = transform.applyToShape(edge1)
                    edge2 = transform.applyToShape(edge2)
                edge1.drawToPath(path, includeM=True)
                edge2.drawToPath(path, includeM=False)
                path.Z()
                return (path,)
        else:
            shape = self.projShape
            if transform:
                shape = transform.applyToShape(shape)
            return shape.toDrawables(elements, **kwargs)
    def drawToPath(self, path, transform=None, **kwargs):
        shape = self.projShape
        if transform:
            shape = transform.applyToShape(shape)
        return shape.drawToPath(path, **kwargs)


# TODO: Trim if arc extends outside unit circle # TODO: Trim if arc extends outside unit circle # Keep direction of line the same Returns list of intersections in the unit circle # Default, invalid # Invalid Returns a segment of this hypercycle going from x1,y1             to x2,y2 (assuming that x1,y1 and x2,y2 are on the             hypercycle) # Infinite radius circle # Ensure correct direction # projShape is a Circle # Ensure correct direction # projShape is a Circle #dh = math.asinh(offset/2) # May throw if bad geometry # May throw if bad geometry # Midpoint # Test if the line goes clockwise around the origin Start xy, end xy, other xy; pass excludeMid=True if other point is             not between start and end