from PySide6.QtWidgets import QApplication, QMainWindow, QSizePolicy
from Gui import Ui_fluencyCAD  # Import the generated GUI module
from drawing_modules.gl_widget import OpenGLWidget
from drawing_modules.draw_widget2d import SnapLineWidget
from sdf import *
import python_solvespace

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # Set up the UI from the generated GUI module
        self.ui = Ui_fluencyCAD()
        self.ui.setupUi(self)

        self.openGLWidget = OpenGLWidget()
        layout = self.ui.gl_box.layout()
        layout.addWidget(self.openGLWidget)
        size_policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
        #self.openGLWidget.setSizePolicy(size_policy)

        self.sketchWidget = SnapLineWidget()
        layout2 = self.ui.sketch_tab.layout()  # Get the layout of self.ui.gl_canvas
        layout2.addWidget(self.sketchWidget)
        size_policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
        self.sketchWidget.setSizePolicy(size_policy)
        self.sketchWidget.setStyleSheet("background-color: white; border: 1px solid red;")

        self.ui.pb_apply_code.pressed.connect(self.check_current_tab)

    def check_current_tab(self):
        if self.ui.InputTab.currentIndex() == 0:
            self.generate_mesh_from_draw()
        elif self.ui.InputTab.currentIndex() == 1:
            self.generate_mesh_from_code()

    def load_and_render(self, file, centroid):
        self.openGLWidget.draw_stl(file)
        self.openGLWidget.update()



class Geometry:
    def distance(self, p1, p2):
        """Calculate the distance between two points."""
        print("p1", p1)
        print("p2", p2)
        return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)

    def generate_mesh_from_code(self):
        code_bytes = self.ui.textEdit.toPlainText().encode('utf-8')
        code_text = code_bytes.decode('utf-8')
        save_string = "\nf.save('out.stl', samples=2**12)"
        code_text += save_string

        local_vars = {}
        try:
            print(code_text)
            exec(code_text, globals(), local_vars)

            # Retrieve the result from the captured local variables
            result = local_vars.get('result')
            print("Result:", result)
            mesh = self.openGLWidget.load_stl("out.stl")
            self.openGLWidget.draw_stl(mesh)
        except Exception as e:
            print("Error executing code:", e)

    def generate_mesh_from_draw(self, points, ):
        f = None
        points = MainWindow().sketchWidget.points
        print(points)
        p_list = []
        dimension = 0.001
        for ps in points:
            p_list.append((ps.x() , ps.y()))

        #p_list.append(p_list[0])
        print(p_list)
        f = polygon(p_list).extrude(100)

        """if len(points) > 3:
            p1 = [points[0].x(), points[0].y()]
            p2 = [points[1].x(), points[1].y()]
            dimension = self.distance(p1, p2)
            scale = 0.001
            f = box(dimension * scale)
        elif len(points) < 3:
            p1 = [points[0].x(), points[0].y()]
            p2 = [points[1].x(), points[1].y()]
            dimension = self.distance(p1, p2)
            scale = 0.001
            print(dimension * scale)
            f = sphere(dimension * scale)"""

        if f:
            f.save('out.stl', samples=2**12, sparse=False)




if __name__ == "__main__":
    app = QApplication([])
    window = MainWindow()
    window.show()
    app.exec()