from PySide6.QtWidgets import QApplication, QWidget, QMessageBox
from PySide6.QtGui import QPainter, QPen, QColor
from PySide6.QtCore import Qt, QPoint
from python_solvespace import SolverSystem, ResultFlag

class SketchWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.points = []
        self.selected_line = None
        self.snapping_range = 20  # Range in pixels for snapping
        self.line_mode = False
        self.solv = SolverSystem()

    def solve_constraint(self):
        solv = SolverSystem()
        wp = solv.create_2d_base()  # Workplane (Entity)
        p0 = solv.add_point_2d(0, 0, wp)  # Entity
        solv.dragged(p0, wp)  # Make a constraint with the entity
        ...
        line0 = solv.add_line_2d(p0, p1, wp)  # Create entity with others
        ...
        line1 = solv.add_line_2d(p0, p3, wp)
        solv.angle(line0, line1, 45, wp)  # Constrain two entities
        line1 = solv.entity(-1)  # Entity handle can be re-generated and negatively indexed
        ...
        if solv.solve() == ResultFlag.OKAY:
            # Get the result (unpack from the entity or parameters)
            # x and y are actually float type
            dof = solv.dof()
            x, y = solv.params(p2.params)
            ...
        else:
            # Error!
            # Get the list of all constraints
            failures = solv.failures()
            ...


    def set_points(self, points: list):
        self.points = points
        #self.update()


    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton and self.line_mode:
            self.points.append(event.pos())
            self.update()

        elif event.button() == Qt.RightButton:
            for i in range(len(self.points) - 1):
                if self.is_point_on_line(event.pos(), self.points[i], self.points[i + 1]):
                    self.selected_line = i
                    break
            else:
                self.selected_line = None

    def mouseMoveEvent(self, event):
        if event.buttons() & Qt.RightButton:
            if self.selected_line is not None:
                self.points[self.selected_line] = event.pos()
            else:
                self.points[-1] = event.pos()
            self.update()

    def mouseDoubleClickEvent(self, event):
        pass

    def distance(self, p1, p2):
        return ((p1.x() - p2.x()) ** 2 + (p1.y() - p2.y()) ** 2) ** 0.5

    def is_point_on_line(self, p, p1, p2):
        distance1 = self.distance(p, p1)
        distance2 = self.distance(p, p2)
        total_distance = self.distance(p1, p2)

        return abs(distance1 + distance2 - total_distance) < 1

    def paintEvent(self, event):
        painter = QPainter(self)

        # Set the background color
        painter.fillRect(self.rect(), QColor('black'))

        pen = QPen(Qt.gray)
        pen.setWidth(2)
        painter.setPen(pen)

        for i in range(len(self.points) - 1):
            painter.drawLine(self.points[i], self.points[i + 1])

        # Draw points
        for point in self.points:
            painter.drawEllipse(point, 3, 3)

        if self.selected_line is not None:
            p1 = self.points[self.selected_line]
            p2 = self.points[self.selected_line + 1]
            painter.setPen(QPen(Qt.red, 2))
            painter.drawLine(p1, p2)
        painter.end()

    def clear_sketch(self):
        self.points = []
        self.update()


# Example usage
if __name__ == "__main__":
    import sys

    app = QApplication(sys.argv)
    window = SketchWidget()
    window.setWindowTitle("Snap Line Widget")
    window.resize(800, 600)
    window.show()
    sys.exit(app.exec())