import tkinter as tk
import json

# (Node osztály módosítása)

class Node:
    def __init__(self, name, x, y):
        self.name = name
        self.value = None
        self.connections = []
        self.operation = None
        self.x = x
        self.y = y
        self.handle_x = x  # Handle x-koordinátája, kezdetben megegyezik a node x-koordinátájával
        self.handle_y = y  # Handle y-koordinátája, kezdetben megegyezik a node y-koordinátájával

    # További metódusok és attribútumok...


    def set_value(self, value):
        self.value = value

    def add_connection(self, node):
        self.connections.append(node)

    def set_operation(self, operation):
        self.operation = operation
    def create_connection(self, node1, node2):
        node1.add_connection(node2)
        node2.add_connection(node1)



class NodeGUI:
    node_count = 1  # Globális változó az egyedi azonosításhoz
    def __init__(self, root):
        self.root = root
        self.nodes = []
        self.selected_node = None
        self.line = None
        self.canvas = tk.Canvas(self.root, width=500, height=500, bg="white")
        self.canvas.pack()

        self.node_name_entry = tk.Entry(self.root)
        self.node_value_entry = tk.Entry(self.root)
        self.operation_dropdown = tk.StringVar(self.root)
        self.operation_dropdown.set("Válasszon műveletet")
        self.operation_dropdown_menu = tk.OptionMenu(self.root, self.operation_dropdown, "add", "multiply")
        self.create_node_button = tk.Button(self.root, text="Új Node létrehozása", command=self.create_node)
        self.save_button = tk.Button(self.root, text="Terv mentése", command=self.save_plan)
        self.load_button = tk.Button(self.root, text="Terv betöltése", command=self.load_plan)

        self.node_name_entry.pack()
        self.node_value_entry.pack()
        self.operation_dropdown_menu.pack()
        self.create_node_button.pack()
        self.save_button.pack()
        self.load_button.pack()

        self.drag_data = {"x": 0, "y": 0, "item": None}

        self.canvas.bind("<ButtonPress-1>", self.on_click)
        self.canvas.bind("<B1-Motion>", self.on_drag)
        self.canvas.bind("<ButtonRelease-1>", self.on_release)


    # (Node és NodeGUI osztályok maradnak, csak a create_node függvény lesz módosítva)
    # Egér görgő események hozzáadása
        self.canvas.bind("<MouseWheel>", self.zoom)

    def zoom(self, event):
        scale = 1.1  # Nagyítás és kicsinyítés mértéke
        if event.delta > 0:  # Görgő felfelé mozgatása (nagyítás)
            self.canvas.scale("all", event.x, event.y, scale, scale)
        elif event.delta < 0:  # Görgő lefelé mozgatása (kicsinyítés)
            self.canvas.scale("all", event.x, event.y, 1 / scale, 1 / scale)

    def save_plan(self):

        pass

    def load_plan(self):
        pass

    def connect_nodes(self, event, node):
        pass


    def create_node(self):
        name = self.node_name_entry.get()
        value = int(self.node_value_entry.get()) if self.node_value_entry.get() else None
        operation = self.operation_dropdown.get()

        new_node = Node(name, 50 + len(self.nodes) * 100, 50)  # A NODE-ot a felhasználó által megadott névvel hozzuk létre
        new_node.set_value(value)
        new_node.set_operation(operation)

        self.nodes.append(new_node)
        self.draw_nodes()

    def draw_nodes(self):
        self.canvas.delete("all")

        for node in self.nodes:
            rect_width = 100
            rect_height = 50
            node_rect = self.canvas.create_rectangle(
                node.x - rect_width // 2, node.y - rect_height // 2,
                node.x + rect_width // 2, node.y + rect_height // 2, fill="lightblue"
            )
            text_id = self.canvas.create_text(node.x, node.y - rect_height // 4, text=node.name)
            value_text = f"Value: {node.value}" if node.value is not None else "Value: None"
            value_id = self.canvas.create_text(node.x, node.y + rect_height // 4, text=value_text)
            self.canvas.tag_bind(node_rect, "<Button-1>", lambda event, node=node: self.select_node(event, node))

           # A kijelölt rész követi a node-ot
            handle_rect = self.canvas.create_rectangle(
                node.x - 10, node.y - 10, node.x + 10, node.y + 10, fill="red"
            )
            self.canvas.tag_bind(handle_rect, "<Button-1>", lambda event, node=node: self.connect_nodes(event, node))

        # Vonalkapcsolatok minden egyes node-hoz
        for node in self.nodes:
            for connection in node.connections:
                self.canvas.create_line(
                    node.x, node.y, connection.x, connection.y, fill="black"
                )
            if self.selected_node:
              for connection in self.selected_node.connections:
                self.canvas.create_line(
                    self.selected_node.handle_x, self.selected_node.handle_y,
                    connection.handle_x, connection.handle_y,
                    fill="black"
                    )

    def on_drag(self, event):
     if self.selected_node is not None:
        for connection in self.selected_node.connections:
            # Ezt a részt csak akkor futtasd le, ha van kiválasztott node
            if self.drag_data["item"]:
                node = self.drag_data["item"]
                node.x += event.x - self.drag_data["x"]
                node.y += event.y - self.drag_data["y"]
                self.drag_data["x"] = event.x
                self.drag_data["y"] = event.y
                self.draw_nodes()
            if (node.handle_x - 10 < event.x < node.handle_x + 10) and \
                (node.handle_y - 10 < event.y < node.handle_y + 10):
                    # A vonal húzásának folyamata a kijelölt részre kattintáskor
                for connection in self.selected_node.connections:
                    pass

            for connection in self.selected_node.connections:
                # A vonalak új koordinátáinak beállítása
                self.canvas.coords(connection.line, self.selected_node.x, self.selected_node.y, connection.x, connection.y)
                self.selected_node.x = event.x
                self.selected_node.y = event.y
     else:
        print("Nem választott ki NODE-ot.")

    def on_click(self, event):
        rect_width = 100
        rect_height = 50

        for node in self.nodes:
            if (node.x - rect_width // 2 < event.x < node.x + rect_width // 2) and \
               (node.y - rect_height // 2 < event.y < node.y + rect_height // 2):
                if (node.handle_x - 10 < event.x < node.handle_x + 10) and \
                   (node.handle_y - 10 < event.y < node.handle_y + 10):
                    self.selected_node = node
                    self.drag_data["item"] = node
                    self.drag_data["x"] = event.x
                    self.drag_data["y"] = event.y
                    break
                else:
                    self.selected_node = node
                    self.drag_data["item"] = node
                    self.drag_data["x"] = event.x
                    self.drag_data["y"] = event.y
                    break

    def on_release(self, event):
        if self.selected_node:
            for node in self.nodes:
                if (node.x - 50 < event.x < node.x + 50) and (node.y - 25 < event.y < node.y + 25) and node != self.selected_node:
                    if self.line:
                        self.canvas.delete(self.line)
                    self.line = self.canvas.create_line(node.x, node.y, self.selected_node.x, self.selected_node.y)
                    node.add_connection(self.selected_node)
                    self.selected_node.add_connection(node)
            self.selected_node = None
            self.drag_data["item"] = None



    def save_plan(self):
        data = {
            "nodes": [{
                "name": node.name,
                "x": node.x,
                "y": node.y,
                "value": node.value,
                "operation": node.operation,
                "connections": [self.nodes.index(connection) for connection in node.connections]
            } for node in self.nodes]
        }
        with open("node_plan.json", "w") as file:
            json.dump(data, file)
        print("Terv elmentve")

    def load_plan(self):
        try:
            with open("node_plan.json", "r") as file:
                data = json.load(file)
                self.nodes = []
                for node_data in data["nodes"]:
                    new_node = Node(node_data["name"], node_data["x"], node_data["y"])
                    new_node.set_value(node_data["value"])
                    new_node.set_operation(node_data["operation"])
                    connections = [self.nodes[index] for index in node_data["connections"]]
                    new_node.connections = connections
                    self.nodes.append(new_node)
                self.draw_nodes()
            print("Terv betöltve")
        except FileNotFoundError:
            print("Nincs mentett terv")

def main():
    root = tk.Tk()
    root.title("Node Creator")
    node_gui = NodeGUI(root)
    root.mainloop()

if __name__ == "__main__":
    main()