import uuid
from PySide6.QtCore import Qt
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



# main, draw_widget, gl_widget

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)

        ### Main Model
        self.model = {
            'sketch': {},
            'operations': {},
        }
        self.list_selected = []

        #self.ui.pb_apply_code.pressed.connect(self.check_current_tab)
        self.ui.element_list.currentItemChanged.connect(self.on_item_changed)
        self.ui.element_list.itemChanged.connect(self.view_update)

        ### Sketches
        self.ui.pb_nw_sktch.pressed.connect(self.add_sketch)
        self.ui.pb_del_sketch.pressed.connect(self.reset_pos_list)

        ### Operations
        self.ui.pb_extrdop.pressed.connect(self.send_extrude)
        self.ui.pb_cutop.pressed.connect(self.send_cut)

    def view_update(self):
        print("Update")
        name = self.ui.element_list.currentItem().text()
        print("selcted_for disp", name)
        model = self.model['operations'][name]['sdf_object']
        mesh = model.generate(samples=2**12)
        self.openGLWidget.load_mesh_direct(mesh)

    def on_item_changed(self, current_item, previous_item):
        if current_item:
            name = current_item.text()
            #self.view_update()
            print(f"Selected item: {name}")

    def add_sketch(self):
        p_list = []
        name = f"sketch-{str(uuid.uuid4())}"
        points = self.sketchWidget.points

        for ps in points:
            p_list.append((ps.x(), ps.y()))

        element = {
            'id': name,
            'type': 'polygon',
            'sketch_points': p_list,
        }

        self.model['sketch'][element['id']] = element
        print(self.model)

        self.ui.element_list.addItem(name)

    def send_extrude(self):
        selected = self.ui.element_list.currentItem()
        name = selected.text()
        points = self.model['sketch'][name]['sketch_points']

        geo = Geometry()
        f = geo.extrude_shape(points)

        element = {
            'id': name,
            'type': 'extrude',
            'sdf_object': f,
        }

        name_op = f"extrd-{name}"
        self.model['operations'][name_op] = element
        self.ui.element_list.addItem(name_op)
        items = self.ui.element_list.findItems(name_op, Qt.MatchExactly)
        self.ui.element_list.setCurrentItem(items[0])
        self.view_update()

    def send_cut(self):
        name = self.ui.element_list.currentItem().text()
        points = self.model['operations'][name]['sdf_object']
        self.list_selected.append(points)
        print(self.list_selected)

        if len(self.list_selected) > 1:
            geo = Geometry()
            f = geo.cut_shapes(self.list_selected[0], self.list_selected[1] )

            element = {
                'id': name,
                'type': 'cut',
                'sdf_object': f,
            }

            name_op = f"cut-{name}"
            self.model['operations'][name_op] = element
            self.ui.element_list.addItem(name_op)
            items = self.ui.element_list.findItems(name_op, Qt.MatchExactly)
            self.ui.element_list.setCurrentItem(items[0])
            self.view_update()

        else:
            print("mindestens 2!")

    def load_and_render(self, file):
        self.openGLWidget.load_stl(file)
        self.openGLWidget.update()


    def reset_pos_list(self):
        print("Deleting")
        self.sketchWidget.clear_sketch()


    """ def check_current_tab(self):
        if self.ui.InputTab.currentIndex() == 0:
            geo = Geometry()
            geo.generate_mesh_from_draw(self.sketchWidget.points)
            self.load_and_render("out.stl")

        elif self.ui.InputTab.currentIndex() == 1:
            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

            geo = Geometry()
            geo.generate_mesh_from_code(code_text)
            self.load_and_render("out.stl")"""



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 extrude_shape(self, points):
        """2D to 3D sdf always first"""
        f = polygon(points).extrude(100)

        return f

    def cut_shapes(self, sdf_object1, sdf_object2):
        f = difference(sdf_object1, sdf_object2) # equivalent

        return f

    def export_mesh(self, sdf_object):
        """FINAL EXPORT"""
        result_points = sdf_object.generate()
        write_binary_stl('out.stl', result_points)

    def generate_mesh_from_code(self, code_text: str):
        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)

        except Exception as e:
            print("Error executing code:", e)


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