editor.py

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from scene import Scene
from engine.entity import Entity
from engine.components import Transform, Sprite, Physics
from engine.core import Engine


class Editor:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("Crosshair Engine - Editor")
        self.root.configure(bg="#1e1e1e")
        self.scene = Scene()
        self.selected_entity = None
        self._setup_ui()

    def _setup_ui(self):
        # Apply dark theme
        style = ttk.Style()
        style.theme_create("dark", parent="alt", settings={
            "TFrame": {"configure": {"background": "#1e1e1e"}},
            "TLabel": {"configure": {"background": "#1e1e1e", "foreground": "#ffffff"}},
            "TButton": {"configure": {"background": "#333333", "foreground": "#ffffff"}},
            "TEntry": {"configure": {"fieldbackground": "#333333", "foreground": "#ffffff"}},
            "TListbox": {"configure": {"background": "#333333", "foreground": "#ffffff"}},
        })
        style.theme_use("dark")

        # top menu
        menubar = tk.Menu(self.root, bg="#1e1e1e", fg="#ffffff", activebackground="#333333", activeforeground="#ffffff")
        filemenu = tk.Menu(menubar, tearoff=0, bg="#1e1e1e", fg="#ffffff", activebackground="#333333", activeforeground="#ffffff")
        filemenu.add_command(label="New", command=self.new_scene)
        filemenu.add_command(label="Open...", command=self.open_scene)
        filemenu.add_command(label="Save As...", command=self.save_scene)
        menubar.add_cascade(label="File", menu=filemenu)
        self.root.config(menu=menubar)

        # main frames with scalable center and right
        main_pane = tk.PanedWindow(self.root, orient=tk.HORIZONTAL, sashwidth=6, bg="#222222", bd=0, showhandle=True)
        main_pane.pack(fill=tk.BOTH, expand=True)

        left = ttk.Frame(main_pane, width=240, relief="solid", borderwidth=1)
        main_pane.add(left, minsize=240)

        center_right_pane = tk.PanedWindow(main_pane, orient=tk.HORIZONTAL, sashwidth=6, bg="#222222", bd=0, showhandle=True)
        main_pane.add(center_right_pane)

        center = ttk.Frame(center_right_pane, width=800, relief="solid", borderwidth=1)
        center_right_pane.add(center, minsize=300)

        right = ttk.Frame(center_right_pane, width=300, relief="solid", borderwidth=1)
        center_right_pane.add(right, minsize=200)

        # left: entity list + add button
        ttk.Label(left, text="Entities").pack(anchor=tk.NW, padx=8, pady=4)
        self.entity_list_frame = ttk.Frame(left)
        self.entity_list_frame.pack(fill=tk.Y, expand=True, padx=8)

        def refresh_entity_list():
            for widget in self.entity_list_frame.winfo_children():
                widget.destroy()
            for idx, e in enumerate(self.scene.entities):
                entity_frame = ttk.Frame(self.entity_list_frame, relief="solid", borderwidth=1)
                entity_frame.pack(fill=tk.X, padx=4, pady=4)
                
                def make_select_callback(entity_idx):
                    def select_entity(event):
                        self.selected_entity = self.scene.entities[entity_idx]
                        self._build_inspector()
                        self._redraw()
                        self.refresh_entity_list()
                    return select_entity
                
                def make_menu_callback(entity_idx):
                    def show_dropdown(event):
                        dropdown_menu = tk.Menu(self.root, tearoff=False, bg="#1e1e1e", fg="#ffffff", activebackground="#333333", activeforeground="#ffffff")
                        dropdown_menu.add_command(label="Delete", command=lambda: self.delete_entity(entity_idx))
                        dropdown_menu.add_command(label="Duplicate", command=lambda: self.duplicate_entity(entity_idx))

                        # Add Template Manager option
                        dropdown_menu.add_command(label="Template Manager", command=lambda: self._open_template_manager(entity_idx))

                        dropdown_menu.post(event.x_root, event.y_root)
                    return show_dropdown
                
                # Highlight selected entity in the list
                if self.selected_entity and self.selected_entity == e:
                    entity_frame.configure(relief="ridge", borderwidth=2)
                
                label = ttk.Label(entity_frame, text=e.name, width=25)
                label.pack(side=tk.LEFT, padx=8, pady=4)
                label.bind("<Button-1>", make_select_callback(idx))
                entity_frame.bind("<Button-1>", make_select_callback(idx))
                
                dots_btn = ttk.Button(entity_frame, text="⋮", width=2)
                dots_btn.pack(side=tk.RIGHT, padx=4)
                dots_btn.bind("<Button-1>", make_menu_callback(idx))

        self.refresh_entity_list = refresh_entity_list
        self.refresh_entity_list()
        ttk.Separator(left, orient="horizontal").pack(fill=tk.X, padx=8, pady=4)
        ttk.Button(left, text="Add Entity", command=self.add_entity).pack(padx=8, pady=4)

        # center: canvas
        self.canvas = tk.Canvas(center, bg="#1e1e1e", width=800, height=600, highlightthickness=0, relief="solid", borderwidth=1)
        self.canvas.pack(fill=tk.BOTH, expand=True)
        self.canvas.bind("<Button-1>", self._on_canvas_click)
        self.canvas.bind("<B1-Motion>", self._on_canvas_drag)

        # Add smooth panning with right-click
        self.canvas.bind("<ButtonPress-3>", self._start_panning)
        self.canvas.bind("<B3-Motion>", self._pan_canvas)
        self.canvas.bind("<ButtonRelease-3>", self._stop_panning)

        # Add zoom functionality with the scroll wheel
        self.canvas.bind("<MouseWheel>", self._zoom_canvas)
        self._zoom_scale = 1.0  # Initial zoom scale

        self._pan_offset = [0, 0]  # Track the current pan offset
        self._is_panning = False

        # right: inspector
        ttk.Label(right, text="Inspector").pack(anchor=tk.NW, padx=8, pady=4)
        ttk.Separator(right, orient="horizontal").pack(fill=tk.X, padx=8, pady=4)
        self.inspector = ttk.Frame(right, relief="solid", borderwidth=1, width=300)
        self.inspector.pack(fill=tk.BOTH, expand=True, padx=8)

        # bottom: run button
        bframe = ttk.Frame(self.root, relief="solid", borderwidth=1)
        bframe.pack(side=tk.BOTTOM, fill=tk.X)
        ttk.Separator(bframe, orient="horizontal").pack(fill=tk.X, padx=8, pady=4)
        ttk.Button(bframe, text="Run Scene", command=self.run_scene).pack(side=tk.LEFT, padx=8, pady=6)
        ttk.Button(bframe, text="Save Scene", command=self.save_scene).pack(side=tk.LEFT, padx=8)

        # redraw
        self._redraw()

    def new_scene(self):
        self.scene = Scene()
        self.refresh_entity_list()
        self._redraw()

    def open_scene(self):
        p = filedialog.askopenfilename(filetypes=[("JSON scenes", "*.json"), ("All files", "*")])
        if not p:
            return
        try:
            self.scene = Scene.load(p)
        except Exception as e:
            messagebox.showerror("Error", f"Failed to load scene: {e}")
            return
        self.refresh_entity_list()
        self._redraw()

    def save_scene(self):
        p = filedialog.asksaveasfilename(defaultextension=".json", filetypes=[("JSON scenes", "*.json")])
        if not p:
            return
        try:
            self.scene.save(p)
        except Exception as e:
            messagebox.showerror("Error", f"Failed to save: {e}")

    def add_entity(self):
        e = Entity("Entity")
        e.add_component("Transform", Transform(100, 100))
        e.add_component("Sprite", Sprite("rect", 60, 40, "#4CAF50"))
        e.add_component("Physics", Physics(0, 0))
        self.scene.add_entity(e)
        self.refresh_entity_list()
        self._redraw()

    def delete_entity(self, idx):
        if 0 <= idx < len(self.scene.entities):
            self.scene.entities.pop(idx)
            self.selected_entity = None
            self.refresh_entity_list()
            self._build_inspector()
            self._redraw()

    def duplicate_entity(self, idx):
        if 0 <= idx < len(self.scene.entities):
            from copy import deepcopy
            original = self.scene.entities[idx]
            duplicated = deepcopy(original)
            duplicated.name = f"{original.name} (copy)"
            # Offset the position to avoid overlap
            trans = duplicated.get("Transform")
            if trans:
                trans.x += 30
                trans.y += 30
            self.scene.add_entity(duplicated)
            self.refresh_entity_list()
            self._redraw()

    def _on_entity_select(self, evt):
        w = evt.widget
        if not w.curselection():
            return
        idx = int(w.curselection()[0])
        self.selected_entity = self.scene.entities[idx]
        self._build_inspector()

    def _build_inspector(self):
        # clear
        for c in self.inspector.winfo_children():
            c.destroy()
        if not self.selected_entity:
            return
        ttk.Label(self.inspector, text=self.selected_entity.name).pack(anchor=tk.W)
        trans = self.selected_entity.get("Transform")
        sprite = self.selected_entity.get("Sprite")
        phys = self.selected_entity.get("Physics")

        # Transform fields
        ttk.Label(self.inspector, text="Position:").pack(anchor=tk.W, pady=(8, 0))
        px = tk.DoubleVar(value=trans.x)
        py = tk.DoubleVar(value=trans.y)
        def apply_pos(*a):
            trans.x = px.get(); trans.y = py.get(); self._redraw()
        ttk.Entry(self.inspector, textvariable=px).pack(fill=tk.X)
        ttk.Entry(self.inspector, textvariable=py).pack(fill=tk.X)
        ttk.Button(self.inspector, text="Apply Position", command=apply_pos).pack(pady=4)

        # Sprite fields
        ttk.Label(self.inspector, text="Sprite:").pack(anchor=tk.W, pady=(8, 0))
        wvar = tk.DoubleVar(value=sprite.w)
        hvar = tk.DoubleVar(value=sprite.h)
        color = tk.StringVar(value=sprite.color)
        def apply_sprite(*a):
            sprite.w = wvar.get(); sprite.h = hvar.get(); sprite.color = color.get(); self._redraw()
        ttk.Entry(self.inspector, textvariable=wvar).pack(fill=tk.X)
        ttk.Entry(self.inspector, textvariable=hvar).pack(fill=tk.X)
        ttk.Entry(self.inspector, textvariable=color).pack(fill=tk.X)
        ttk.Button(self.inspector, text="Apply Sprite", command=apply_sprite).pack(pady=4)

        # Physics
        if phys:
            ttk.Label(self.inspector, text="Physics (vx, vy):").pack(anchor=tk.W, pady=(8, 0))
            vx = tk.DoubleVar(value=phys.vx)
            vy = tk.DoubleVar(value=phys.vy)
            def apply_phys(*a):
                phys.vx = vx.get(); phys.vy = vy.get()
            ttk.Entry(self.inspector, textvariable=vx).pack(fill=tk.X)
            ttk.Entry(self.inspector, textvariable=vy).pack(fill=tk.X)
            ttk.Button(self.inspector, text="Apply Physics", command=apply_phys).pack(pady=4)

    def _on_canvas_click(self, event):
        # select entity under mouse
        found = None
        for e in reversed(self.scene.entities):
            t = e.get("Transform"); s = e.get("Sprite")
            if not t or not s:
                continue
            x1 = t.x - s.w/2; y1 = t.y - s.h/2; x2 = t.x + s.w/2; y2 = t.y + s.h/2
            if x1 <= event.x <= x2 and y1 <= event.y <= y2:
                found = e
                break
        if found:
            self.selected_entity = found
            # select in listbox
            idx = self.scene.entities.index(found)
            for widget in self.entity_list_frame.winfo_children():
                widget.configure(relief="solid", borderwidth=1)
            self.entity_list_frame.winfo_children()[idx].configure(relief="ridge", borderwidth=2)
            self._build_inspector()
            self._redraw()  # Ensure the outline appears immediately

    def _on_canvas_drag(self, event):
        if not self.selected_entity:
            return

        trans = self.selected_entity.get("Transform")
        sprite = self.selected_entity.get("Sprite")
        if not trans or not sprite:
            return

        # Check if the drag started within the bounds of the selected entity
        x1 = trans.x - sprite.w / 2
        y1 = trans.y - sprite.h / 2
        x2 = trans.x + sprite.w / 2
        y2 = trans.y + sprite.h / 2

        if x1 <= event.x <= x2 and y1 <= event.y <= y2:
            trans.x = event.x
            trans.y = event.y
            self._redraw()

    def _start_panning(self, event):
        # Initialize panning
        self._is_panning = True
        self._pan_start = (event.x, event.y)

    def _pan_canvas(self, event):
        if not self._is_panning:
            return

        dx = event.x - self._pan_start[0]
        dy = event.y - self._pan_start[1]

        self._pan_offset[0] += dx * 0.8  # Increased intensity for panning
        self._pan_offset[1] += dy * 0.8

        self._pan_start = (event.x, event.y)
        self._redraw()

    def _stop_panning(self, event):
        # End panning
        self._is_panning = False

    def _zoom_canvas(self, event):
        # Ensure zoom only happens within the canvas
        if event.widget != self.canvas:
            return

        # Adjust zoom scale based on scroll direction
        zoom_factor = 1.1 if event.delta > 0 else 0.9
        new_zoom_scale = self._zoom_scale * zoom_factor
        new_zoom_scale = max(0.5, min(new_zoom_scale, 2.0))  # Clamp zoom scale between 0.5x and 2.0x

        # Calculate zoom focus point relative to the current pan offset and scale
        canvas_x = (event.x - self._pan_offset[0]) / self._zoom_scale
        canvas_y = (event.y - self._pan_offset[1]) / self._zoom_scale

        # Adjust pan offset to keep the zoom focus point under the cursor
        self._pan_offset[0] -= (canvas_x * new_zoom_scale - canvas_x * self._zoom_scale)
        self._pan_offset[1] -= (canvas_y * new_zoom_scale - canvas_y * self._zoom_scale)

        self._zoom_scale = new_zoom_scale
        self._redraw()

    def _redraw(self):
        # draw scene onto the editor canvas
        self.canvas.delete("all")
        offset_x, offset_y = self._pan_offset
        scale = self._zoom_scale
        self.scene.draw(self.canvas, offset=(offset_x, offset_y), scale=scale)

        # Draw white outline around selected entity
        if self.selected_entity:
            trans = self.selected_entity.get("Transform")
            sprite = self.selected_entity.get("Sprite")
            if trans and sprite:
                x = (trans.x + offset_x) * scale
                y = (trans.y + offset_y) * scale
                w = sprite.w * scale
                h = sprite.h * scale
                x1 = x - w/2
                y1 = y - h/2
                x2 = x + w/2
                y2 = y + h/2

                if sprite.shape == "rect":
                    self.canvas.create_rectangle(x1, y1, x2, y2, outline="#ffffff", fill="", width=2)
                else:
                    self.canvas.create_oval(x1, y1, x2, y2, outline="#ffffff", fill="", width=2)

    def run_scene(self):
        # Launch engine in new window with a deep-copied scene
        from copy import deepcopy
        scene_copy = deepcopy(self.scene)
        eng = Engine(scene_copy, title="Running Scene")
        eng.run()

    def run(self):
        self.root.mainloop()

    def _open_template_manager(self, entity_idx):
        # Create a new window for managing templates
        manager_window = tk.Toplevel(self.root)
        manager_window.title("Template Manager")
        manager_window.geometry("400x300")
        manager_window.configure(bg="#1e1e1e")

        ttk.Label(manager_window, text="Select Template:", background="#1e1e1e", foreground="#ffffff", font=("Arial", 14)).pack(pady=20)

        def apply_template(template_name):
            entity = self.scene.entities[entity_idx]
            current_transform = entity.get("Transform")
            current_position = (current_transform.x, current_transform.y) if current_transform else (0, 0)
            entity.components.clear()

            if template_name == "Basic Rectangle":
                entity.add_component("Transform", Transform(*current_position))
                entity.add_component("Sprite", Sprite("rect", 60, 40, "#4CAF50"))
            elif template_name == "Basic Circle":
                entity.add_component("Transform", Transform(*current_position))
                entity.add_component("Sprite", Sprite("circle", 50, 50, "#FF5722"))
            elif template_name == "Player Character":
                entity.add_component("Transform", Transform(*current_position))
                entity.add_component("Sprite", Sprite("rect", 30, 40, "#2196F3"))
                entity.add_component("Physics", Physics(0, 0))
                entity.add_component("PlayerController", True)

            self.refresh_entity_list()
            self._redraw()
            manager_window.destroy()

        ttk.Button(manager_window, text="Basic Rectangle", command=lambda: apply_template("Basic Rectangle"), width=20).pack(pady=10)
        ttk.Button(manager_window, text="Basic Circle", command=lambda: apply_template("Basic Circle"), width=20).pack(pady=10)
        ttk.Button(manager_window, text="Player Character", command=lambda: apply_template("Player Character"), width=20).pack(pady=10)