from typing import Tuple, Union

from sympy import symbols, solve

from loguru import logger

from ..cgal_bindings.plane import (
    Point_2,
    Segment_2,
    Vector_2,
    Ray_2,
    Direction_2,
    Line_2,
    squared_distance,
)
from ..cgal_bindings.enums import Orientation


def point_maker(pre_point):
    if isinstance(pre_point, Point2D):
        return pre_point
    elif isinstance(pre_point, tuple):
        return Point2D(pre_point[0], pre_point[1])
    else:
        print(type(pre_point))
        raise ValueError("Invalid input for Point2D")


class Shape2D(object):
    def __init__(self, **kwargs):
        self.color = kwargs.get("color", "white")

    # 计算self到另一个Shape2D的距离，返回float
    def distance(
        self, target: [Tuple[float, float], Point2D, Line2D, Segment2D, Ray2D]
    ) -> float:
        if isinstance(target, tuple):
            target = point_maker(target)
        return (squared_distance(self, target)) ** 0.5


class Point2D(Shape2D, Point_2):
    def __init__(self, x: float, y: float, **kwargs):
        Point_2.__init__(self, x, y)
        Shape2D.__init__(self, **kwargs)

    # 重载==运算符，判断两个Point2D实例是否为同一点
    def __eq__(self, other: [Tuple[float, float], Point2D]) -> bool:
        self.point == point_maker(other)

    def __repr__(self) -> str:
        return f"Point2D(x: {self.x}, y: {self.y})"


class Segment2D(Shape2D, Segment_2):
    def __init__(self, point1, point2, **kwargs):
        point1 = point_maker(point1)
        point2 = point_maker(point2)
        super(Shape2D, self).__init__(**kwargs)
        super(Segment_2, self).__init__(point1, point2)

    # 计算线段的长度
    def length(self) -> float:
        return self._squared_length() ** 0.5

    # 重载==运算符，判断两个Segment2D实例是否为同一条线段
    def __eq__(self, other: Segment2D) -> bool:
        return self == other

    # 重载`in`运算符，判断点是否在线段上
    def __contains__(self, point: [Tuple[float, float], Point2D]) -> bool:
        point = point_maker(point)
        return self.has_on(point)

    # 重载`repr`方法，返回Segment2D的字符串表示
    def __repr__(self) -> str:
        return f"Segment2D({self.point1}, {self.point2})"

    # 线段的起点`source`
    @property
    def source(self) -> Point2D:
        return self._source()

    # 线段的终点`target`
    @property
    def target(self) -> Point2D:
        return self._target()


class Ray2D(Shape2D, Ray_2):
    def __init__(
        self,
        source: [Tuple[float, float], Point2D],
        point: [Tuple[float, float], Point2D] = None,
        vec: Vector2D = None,
        direction: Direction2D = None,
        line: Line2D = None,
        **kwargs,
    ):
        source = point_maker(source)
        if point is not None:
            point = point_maker(point)
            Ray_2.__init__(self, source, point)
        elif vec is not None:
            Ray_2.__init__(self, source, vec)
        elif direction is not None:
            Ray_2.__init__(self, source, direction)
        elif line is not None:
            Ray_2.__init__(self, source, line)
        else:
            raise ValueError("Invalid input for Ray2D")
        Shape2D.__init__(self, **kwargs)

    # 返回射线起点
    @property
    def source(self) -> Point2D:
        return self._source()

    # 返回射线方向
    @property
    def direction(self) -> Direction2D:
        return self._direction()

    # 重载`repr`方法，返回Ray2D的字符串表示
    def __repr__(self) -> str:
        return f"Ray2D({self.source}, {self.direction})"

    # 重载`in`运算符，判断点是否在射线上
    def __contains__(self, point: [Tuple[float, float], Point2D]) -> bool:
        point = point_maker(point)
        return self.has_on(point)


class Direction2D(Shape2D, Direction_2):
    def __init__(
        self,
        vec: Vector2D = None,
        line: Line2D = None,
        ray: Ray2D = None,
        seg: Segment2D = None,
        coor: Tuple[float, float] = None,
        **kwargs,
    ):
        """`Direction2D`构造函数

        Args:
            vec (Vector2D, optional): _description_. Defaults to None.
            line (Line2D, optional): _description_. Defaults to None.
            ray (Ray2D, optional): _description_. Defaults to None.
            seg (Segment2D, optional): _description_. Defaults to None.
            coor (Tuple[float, float], optional): _description_. Defaults to None.

        > 需要提供`vec`, `line`, `ray`, `seg`, `coor`中的任意一个作为初始参数。
        """
        Shape2D.__init__(self, **kwargs)
        if vec is not None:
            Direction_2.__init__(self, vec)
        elif line is not None:
            Direction_2.__init__(self, line)
        elif ray is not None:
            Direction_2.__init__(self, ray)
        elif seg is not None:
            Direction_2.__init__(self, seg)
        elif coor is not None:
            Direction_2.__init__(self, coor)
        else:
            raise ValueError("Invalid input for Direction2D")

    @property
    def dx(self) -> float:
        return self._dx()

    @property
    def dy(self) -> float:
        return self._dy()

    # 重载`repr`方法，返回Direction2D的字符串表示
    def __repr__(self) -> str:
        return f"Direction2D({self.dx}, {self.dy})"


class Vector2D(Shape2D, Vector_2):
    def __init__(
        self,
        points: Tuple[Tuple[float, float], Tuple[float, float]] = None,
        seg: Segment2D = None,
        ray: Ray2D = None,
        line: Line2D = None,
        values: Tuple[float, float] = None,
        homo_values: Tuple[float, float, float] = None,
        **kwargs,
    ):
        """向量Vector2D的初始化方法

        Args:
            points (Tuple[Tuple[float, float], Tuple[float, float]], optional): 两个端点的坐标. Defaults to None.
            seg (Segment2D, optional): 线段. Defaults to None.
            ray (Ray2D, optional): 射线. Defaults to None.
            line (Line2D, optional): 直线. Defaults to None.
            values (Tuple[float, float], optional): 坐标值. Defaults to None.
            homo_values (Tuple[float, float, float], optional): 齐次坐标值. Defaults to None.
        """
        Shape2D.__init__(self, **kwargs)
        if points is not None:
            point1 = point_maker(points[0])
            point2 = point_maker(points[1])
            Vector_2.__init__(self, point1, point2)
        elif seg is not None:
            Vector_2.__init__(self, seg)
        elif ray is not None:
            Vector_2.__init__(self, ray)
        elif line is not None:
            Vector_2.__init__(self, line)
        elif values is not None:
            Vector_2.__init__(self, *values)
        elif homo_values is not None:
            Vector_2.__init__(self, *homo_values)
        else:
            Vector_2.__init__(self)

    def __repr__(self) -> str:
        return f"Vector2D({self.x}, {self.y})"

    @property
    def x(self) -> float:
        return self._x()

    @property
    def y(self) -> float:
        return self._y()

    @property
    def hx(self) -> float:
        return self._hx()

    @property
    def hy(self) -> float:
        return self._hy()

    @property
    def hw(self) -> float:
        return self._hw()


# 直线类
class Line2D(Shape2D, Line_2):
    def __init__(
        self,
        coefficient: Tuple[float, float, float] = None,
        points: Tuple[Tuple[float, float], Tuple[float, float]] = None,
        point_and_direction: Tuple[Point2D, Direction2D] = None,
        point_and_vector: Tuple[Point2D, Vector2D] = None,
        segment: Segment2D = None,
        ray: Ray2D = None,
        **kwargs,
    ):
        """直线Line2D的初始化方法

        Args:
             直线Line2D的初始化参数,可以是以下几种形式:
                - "coefficient": 直线一般式方程的参数A, B, C
                - "points": 两个端点
                - "point_and_direction": 点和方向
                - "point_and_vector": 点和向量
                - "segment": 线段
                - "ray": 射线

        """
        Shape2D.__init__(self, **kwargs)
        if "points" in init_from:
            point1 = point_maker(point1)
            point2 = point_maker(point2)
            Line_2.__init__(self, point1, point2)
        if "coefficient" in init_from:
            Line_2.__init__(self, a, b, c)
        if "point_and_direction" in init_from:
            Line_2.__init__(self, point1, direction)
        if "point_and_vector" in init_from:
            point1 = point_maker(point1)
            Line_2.__init__(self, point1, vec)
        if "segment" in init_from:
            Line_2.__init__(self, seg)
        if "ray" in init_from:
            Line_2.__init__(self, ray)

        self._x, self._y = symbols("x y")
        if self.is_degenerate():
            self._expression = None
        else:
            self._expression = self.a * self._x + self.b * self._y + self.c

    @property
    def a(self) -> float:
        return self._a()

    @property
    def b(self) -> float:
        return self._b()

    @property
    def c(self) -> float:
        return self._c()

    # 返回该直线一般式方程文本，形如`ax+by+c=0`
    @property
    def expression(self):
        return f"{str(self._expression)} = 0"

    # 通过关键字`in`判断点是否在线段上
    def __contains__(self, point):
        return self.has_on(point)

    # 重载`repr`方法，返回Line2D的字符串表示
    def __repr__(self) -> str:
        return f"Line2D(expression is {self.expression})"

    # 计算点point到此直线的距离
    def distance(self, point: [Tuple[float, float], Point2D]) -> float:
        point = point_maker(point)
        return squared_distance(self, point) ** 0.5


class Circle2D(Shape2D, Circle_2):
    def __init__(
        self,
        center_and_radius: Tuple[Union[Point2D, Tuple[float, float]], float] = None,
        points: Tuple[
            Union[Point2D, Tuple[float, float]], Union[Point2D, Tuple[float, float]]
        ] = None,
        diameter_and_orientation: Tuple[
            Union[Point2D, Tuple[float, float]],
            Union[Point2D, Tuple[float, float]],
            Orientation,
        ] = None,
        center_and_orientation: Tuple[
            Union[Point2D, Tuple[float, float]], Orientation
        ] = None,
        **kwargs,
    ):
        """
        圆Circle2D的初始化方法

        Args:
            center_and_radius: 圆心和半径, 方向默认为Orientation.COUNTERCLOCKWISE
            points: 过三个不共线点的圆
            diameter_and_orientation: 直径为给定两个端点的线段，方向默认为Orientation.COUNTERCLOCKWISE, 方向不可为Orienatation.COLLINEAR
            center_and_orientation: 圆心和方向, 通过该方法初始化的圆半径为0, `is_degenerate`方法返回True\
        
        Example:
            ```python
            # 圆心和方向
            circle1 = Circle2D(center_and_orientation=((0, 0), Orientation.COUNTERCLOCKWISE))
            assert circle1.is_degenerate() == True

            # 过三个不共线点的圆
            circle2 = Circle2D(points=((0, 0), (1, 1), (2, 0)))

            # 直径为给定两个端点的线段，方向默认为Orientation.COUNTERCLOCKWISE
            circle3 = Circle2D(diameter_and_orientation=((0, 0), (1, 1)), Orientation.COUNTERCLOCKWISE)

            # 圆心和半径
            circle4 = Circle2D(center_and_radius=((0, 0), 1))((0, 0), 1, Orientation.COUNTERCLOCKWISE))
        """
        Shape2D.__init__(self, **kwargs)
        if center_and_radius is not None:
            center = point_maker(center_and_radius[0])
            radius = center_and_radius[1]
            ori = center_and_radius[2] if len(center_and_radius) == 3 else Orientation.COUNTERCLOCKWISE
            Circle_2.__init__(self, center, radius, ori)
        elif points is not None:
            points = [point_maker(p) for p in points]
            Circle_2.__init__(self, *points)
        elif diameter_and_orientation is not None:
            point1 = point_maker(diameter_and_orientation[0][0])
            point2 = point_maker(diameter_and_orientation[0][1])
            ori = diameter_and_orientation[1] if len(diameter_and_orientation) == 2 else Orientation.COUNTERCLOCKWISE
            Circle_2.__init__(self, point1, point2, ori)
        elif center_and_orientation is not None:
            center = point_maker(center_and_orientation[0])
            ori = center_and_orientation[1] if len(center_and_orientation) == 2 else Orientation.COUNTERCLOCKWISE
            Circle_2.__init__(self, center, ori)
        else:
            raise ValueError("Invalid input for Circle2D")
        self._x, self._y = symbols("x y")
        self._expression = (self._x - self.center.x) ** 2 + (self._y - self.center.y) ** 2 - self._squared_radius

    @property
    def center(self) -> Point2D:
        return self._center()

    @property
    def radius(self) -> float:
        return self._squared_radius() ** 0.5
    
    @property
    def orientation(self) -> Orientation:
        return self._orientation()
    
    # 重载`repr`方法，返回Circle2D的字符串表示
    def __repr__(self) -> str:
        return f"Circle2D(center: {self.center}, radius: {self.radius}, orientation: {self.orientation})"
    
    # 圆的标准方程
    @property
    def standard_equation(self) -> str:
        return f"{str(self._expression)} = 0"

    # 圆的一般方程
    @property
    def general_equation(self) -> str:
        return f"{str(self._expression.expand())} = 0"

# 三角形类
class Triangle2D(Shape2D, Triangle_2):
    def __init__(
        self,
        points: Tuple[
            Union[Point2D, Tuple[float, float]],
            Union[Point2D, Tuple[float, float]],
            Union[Point2D, Tuple[float, float]],
        ] = None,
        **kwargs,
    ):
        """
        三角形Triangle2D的初始化方法

        Args:
            points: 三个端点
        """
        Shape2D.__init__(self, **kwargs)
        points = [point_maker(p) for p in points]
        Triangle_2.__init__(self, *points)
    
    # 重载`repr`方法，返回Triangle2D的字符串表示
    def __repr__(self) -> str:
        return f"Triangle2D(points: {[self.vertex(i) for i in range(3)]})"