# --- START OF FILE diff_viewer.py ---

import tkinter as tk
from tkinter import ttk, scrolledtext, Canvas, messagebox
import difflib
import logging
import os
import locale # Per fallback encoding

class DiffViewerWindow(tk.Toplevel):
    """
    Toplevel window to display a side-by-side diff of a file.
    Shows differences between the working directory version and the HEAD version.
    Includes synchronized scrolling via clicking on the overview minimap.
    Relies solely on minimap clicks for vertical navigation.
    """
    def __init__(self, master, logger, git_commands, repo_path, file_status_line):
        """
        Initializes the Diff Viewer window.

        Args:
            master: The parent widget (usually the main Tkinter root).
            logger: Logger instance for logging messages.
            git_commands: Instance of GitCommands for interacting with Git.
            repo_path (str): Absolute path to the Git repository.
            file_status_line (str): The full status line from 'git status --short'
                                    for the file to be diffed (e.g., " M path/to/file.py").
        """
        super().__init__(master)

        # Setup Logger (con fallback)
        if not isinstance(logger, (logging.Logger, logging.LoggerAdapter)):
            print("ERROR: DiffViewerWindow requires a valid logger. Using fallback.")
            self.logger = logging.getLogger("DiffViewer_Fallback")
            self.logger.setLevel(logging.WARNING) # Logga solo warning/error
        else:
            self.logger = logger

        # Setup GitCommands
        if git_commands is None:
             self.logger.critical("GitCommands instance is required.")
             raise ValueError("DiffViewerWindow requires a valid GitCommands instance.")
        self.git_commands = git_commands

        self.repo_path = repo_path

        # Pulisci e valida il percorso del file dalla riga di stato
        self.relative_file_path = self._clean_relative_path(file_status_line)
        if not self.relative_file_path:
             self.logger.error(f"Cannot show diff: Invalid path from '{file_status_line}'.")
             messagebox.showerror("Error", "Invalid file path for diff.", parent=master)
             self.after_idle(self.destroy) # Chiudi se percorso non valido
             return # Esce dall'init

        # Configurazione Finestra Toplevel
        self.title(f"Diff - {os.path.basename(self.relative_file_path)}")
        self.geometry("920x650") # Dimensioni finestra
        self.minsize(550, 400) # Dimensioni minime
        self.grab_set()        # Rendi modale
        self.transient(master) # Appare sopra il parent

        # Stato interno
        self.head_content_lines = []
        self.workdir_content_lines = []
        self.diff_map = [] # Mappa per minimappa: 0=uguale, 1=rimosso/mod, 2=aggiunto/mod
        self._scrolling_active = False # Flag per prevenire eventi ricorsivi

        # Costruisci l'interfaccia grafica
        self._create_widgets()

        # Carica il contenuto dei file e calcola/mostra il diff
        load_ok = False
        try:
            load_ok = self._load_content()
            if load_ok:
                self._compute_and_display_diff()
                self._setup_scrolling() # Configura solo il click sulla minimappa
            else:
                 # Se _load_content fallisce, mostra errore nei widget
                 self.logger.warning("Content loading failed, populating text widgets with error messages.")
                 self._populate_text(self.text_head, ["<Error loading HEAD content>"])
                 self._populate_text(self.text_workdir, ["<Error loading Workdir content>"])
                 # Disegna comunque la minimappa (sarà vuota)
                 self.minimap_canvas.after(50, self._draw_minimap)

        except Exception as load_err:
             # Errore imprevisto durante il caricamento/diff
             self.logger.exception(f"Unexpected error during diff setup for '{self.relative_file_path}': {load_err}")
             messagebox.showerror("Fatal Error", f"Failed to display diff:\n{load_err}", parent=self)
             self.after_idle(self.destroy) # Chiudi in caso di errore grave
             return # Esce dall'init

        # Centra la finestra rispetto al parent
        self._center_window(master)


    def _clean_relative_path(self, file_status_line):
        """
        Extracts a clean relative path from a git status line.
        Handles status codes, spaces, renames, and quotes.
        """
        try:
            # Pulisci caratteri speciali e spazi esterni
            line = file_status_line.strip('\x00').strip()
            if not line:
                self.logger.warning("Received empty status line for cleaning.")
                return ""

            # Trova il primo spazio per separare lo stato dal percorso
            space_index = -1
            for i, char in enumerate(line):
                if char.isspace():
                    space_index = i
                    break

            # Se non c'è spazio o è alla fine, il formato è sospetto
            if space_index == -1 or space_index + 1 >= len(line):
                # Se la linea non contiene spazi, potremmo assumere che sia solo il nome file?
                # Questo potrebbe accadere se lo stato viene perso prima. Per sicurezza,
                # richiediamo uno spazio per separare stato e percorso.
                self.logger.warning(f"Could not find valid space separator in status line: '{line}'")
                return "" # Ritorna vuoto se non c'è separatore valido

            # Estrai la parte del percorso dopo il primo spazio
            relative_path_raw = line[space_index + 1:].strip()

            # Gestisci rinominati nel formato "XY orig -> new"
            if "->" in relative_path_raw:
                # Prendi solo il nome del file *nuovo* (dopo ->)
                relative_path = relative_path_raw.split("->")[-1].strip()
            else:
                relative_path = relative_path_raw

            # Gestisci le quote se presenti (tipico se non si usa -z)
            if len(relative_path) >= 2 and relative_path.startswith('"') and relative_path.endswith('"'):
                 relative_path = relative_path[1:-1]

            # Controlla se il risultato è vuoto dopo la pulizia
            if not relative_path:
                 self.logger.warning(f"Extracted path is empty from status line: '{line}'")
                 return ""

            self.logger.debug(f"Cleaned path from '{file_status_line}' -> '{relative_path}'")
            return relative_path

        except Exception as e:
            self.logger.error(f"Error cleaning path from status line '{file_status_line}': {e}", exc_info=True)
            return "" # Ritorna vuoto in caso di errore


    def _center_window(self, parent):
        """Centers the Toplevel window relative to its parent."""
        try:
            self.update_idletasks() # Assicura dimensioni aggiornate
            # Calcola le coordinate
            parent_x = parent.winfo_rootx()
            parent_y = parent.winfo_rooty()
            parent_width = parent.winfo_width()
            parent_height = parent.winfo_height()
            window_width = self.winfo_width()
            window_height = self.winfo_height()
            x = parent_x + (parent_width // 2) - (window_width // 2)
            y = parent_y + (parent_height // 2) - (window_height // 2)
            # Assicura visibilità sullo schermo
            screen_width = self.winfo_screenwidth()
            screen_height = self.winfo_screenheight()
            x = max(0, min(x, screen_width - window_width))
            y = max(0, min(y, screen_height - window_height))
            # Imposta geometria
            self.geometry(f"+{int(x)}+{int(y)}")
        except Exception as e:
            self.logger.error(f"Could not center DiffViewerWindow: {e}", exc_info=True)


    def _create_widgets(self):
        """Creates the main widgets for the diff view (NO main scrollbar)."""
        main_frame = ttk.Frame(self, padding=5)
        main_frame.pack(fill=tk.BOTH, expand=True)
        main_frame.rowconfigure(1, weight=1) # Riga dei text widget si espande
        # Colonne: Sinistra (HEAD), Destra (Workdir), Minimap
        main_frame.columnconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=1)
        main_frame.columnconfigure(2, weight=0, minsize=40) # Minimap larghezza fissa

        # Etichette Titoli
        ttk.Label(main_frame, text=f"HEAD (Repository Version)").grid(
            row=0, column=0, sticky='w', padx=(5,2), pady=(0, 2))
        ttk.Label(main_frame, text=f"Working Directory Version").grid(
            row=0, column=1, sticky='w', padx=(2,5), pady=(0, 2))
        ttk.Label(main_frame, text="Overview").grid(
            row=0, column=2, sticky='w', padx=(5,0), pady=(0, 2))

        # Widget Testo (senza scrollbar individuali o yscrollcommand)
        text_font = ("Consolas", 10) # Font Monospace
        common_text_opts = {
            "wrap": tk.NONE, # No a capo
            "font": text_font,
            "padx": 5, "pady": 5,
            "undo": False, # Non serve undo in visualizzazione
            "state": tk.DISABLED, # Inizia non modificabile
            "borderwidth": 1,
            "relief": tk.SUNKEN
        }
        self.text_head = tk.Text(main_frame, **common_text_opts)
        self.text_workdir = tk.Text(main_frame, **common_text_opts)

        self.text_head.grid(row=1, column=0, sticky='nsew', padx=(5, 2))
        self.text_workdir.grid(row=1, column=1, sticky='nsew', padx=(2, 5))

        # Minimap Canvas
        self.minimap_canvas = Canvas(
            main_frame, width=40, bg='#F0F0F0',
            relief=tk.SUNKEN, borderwidth=1, highlightthickness=0
        )
        self.minimap_canvas.grid(row=1, column=2, sticky='ns', padx=(5, 0))
        self.minimap_canvas.bind("<Configure>", self._on_minimap_resize)

        # Configurazione Tag per Highlighting
        self.text_head.tag_config("removed", background="#FFE0E0") # Rosso chiaro
        self.text_head.tag_config("empty", background="#F5F5F5", foreground="#A0A0A0") # Grigio per filler
        self.text_workdir.tag_config("added", background="#E0FFE0") # Verde chiaro
        self.text_workdir.tag_config("empty", background="#F5F5F5", foreground="#A0A0A0") # Grigio per filler


    def _load_content(self):
        """Loads file content from HEAD and working directory."""
        self.logger.info(f"Loading content for diff: {self.relative_file_path}")
        load_success = True
        # Carica HEAD
        try:
            head_content_raw = self.git_commands.get_file_content_from_ref(
                self.repo_path, self.relative_file_path, ref="HEAD"
            )
            self.head_content_lines = head_content_raw.splitlines() if head_content_raw is not None else []
            if head_content_raw is None:
                 self.logger.warning(f"File '{self.relative_file_path}' not found in HEAD (likely new or deleted in HEAD).")
        except Exception as e_head:
             self.logger.error(f"Error loading HEAD content for '{self.relative_file_path}': {e_head}", exc_info=True)
             self.head_content_lines = [f"<Error loading HEAD: {e_head}>"]
             load_success = False

        # Carica Working Directory
        try:
             workdir_full_path = os.path.join(self.repo_path, self.relative_file_path)
             if os.path.exists(workdir_full_path) and os.path.isfile(workdir_full_path):
                  try:
                      with open(workdir_full_path, 'r', encoding='utf-8') as f:
                          self.workdir_content_lines = f.read().splitlines()
                  except UnicodeDecodeError:
                      self.logger.warning(f"UTF-8 decode failed for WD {workdir_full_path}, trying fallback.")
                      try:
                          fallback_encoding = locale.getpreferredencoding(False) or 'latin-1'
                          with open(workdir_full_path, 'r', encoding=fallback_encoding, errors='replace') as f:
                              self.workdir_content_lines = f.read().splitlines()
                      except Exception as fb_e:
                           self.logger.error(f"WD fallback read failed: {fb_e}")
                           self.workdir_content_lines = [f"<Error reading WD: {fb_e}>"]
                           load_success = False
             else:
                  self.logger.info(f"Working directory file not found: {workdir_full_path}")
                  self.workdir_content_lines = [] # File non esiste sul disco
        except Exception as e_wd:
            self.logger.error(f"Error loading Workdir content for '{self.relative_file_path}': {e_wd}", exc_info=True)
            self.workdir_content_lines = [f"<Error loading Workdir: {e_wd}>"]
            load_success = False

        return load_success


    def _compute_and_display_diff(self):
        """Calculates the diff and populates the text widgets with highlights,
           ensuring consistent line count for display using SequenceMatcher."""
        self.logger.debug("Computing and displaying diff...")
        if not self.head_content_lines and not self.workdir_content_lines:
             self.logger.warning("Both HEAD and Workdir content are empty or failed.")
             self._populate_text(self.text_head, ["(No content in HEAD)"])
             self._populate_text(self.text_workdir, ["(No content in Workdir)"])
             self.diff_map = []
             self.minimap_canvas.after(50, self._draw_minimap)
             return

        matcher = difflib.SequenceMatcher(None, self.head_content_lines, self.workdir_content_lines, autojunk=False)
        head_lines_display = []
        workdir_lines_display = []
        diff_map_for_minimap = []

        self.logger.debug("Generating aligned display lines using SequenceMatcher opcodes...")
        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
            head_chunk = self.head_content_lines[i1:i2]
            workdir_chunk = self.workdir_content_lines[j1:j2]

            if tag == 'equal':
                for k in range(len(head_chunk)):
                    head_lines_display.append((' ', head_chunk[k]))
                    workdir_lines_display.append((' ', workdir_chunk[k]))
                    diff_map_for_minimap.append(0) # 0 = equal
            elif tag == 'delete':
                for k in range(len(head_chunk)):
                    head_lines_display.append(('-', head_chunk[k]))
                    workdir_lines_display.append(('empty', ''))
                    diff_map_for_minimap.append(1) # 1 = deleted/modified head
            elif tag == 'insert':
                for k in range(len(workdir_chunk)):
                    head_lines_display.append(('empty', ''))
                    workdir_lines_display.append(('+', workdir_chunk[k]))
                    diff_map_for_minimap.append(2) # 2 = added/modified workdir
            elif tag == 'replace':
                len_head = len(head_chunk)
                len_workdir = len(workdir_chunk)
                max_len = max(len_head, len_workdir)
                for k in range(max_len):
                    head_line = head_chunk[k] if k < len_head else ''
                    workdir_line = workdir_chunk[k] if k < len_workdir else ''
                    head_code = '-' if k < len_head else 'empty'
                    workdir_code = '+' if k < len_workdir else 'empty'
                    head_lines_display.append((head_code, head_line))
                    workdir_lines_display.append((workdir_code, workdir_line))
                    # Segna come modificato (1 per rosso, 2 per verde)
                    diff_map_for_minimap.append(1 if head_code != 'empty' else 2)

        # Verifica coerenza (opzionale ma utile per debug)
        if len(head_lines_display) != len(workdir_lines_display) or \
           len(head_lines_display) != len(diff_map_for_minimap):
             self.logger.error("Internal Diff Error: Mismatch in aligned line counts!")
        else:
             self.logger.debug(f"Aligned display generated with {len(head_lines_display)} lines.")

        self.diff_map = diff_map_for_minimap # Aggiorna mappa per minimappa

        # Popola widget testo
        self._populate_text(self.text_head, head_lines_display)
        self._populate_text(self.text_workdir, workdir_lines_display)

        # Disegna minimappa (con ritardo)
        self.minimap_canvas.after(100, self._draw_minimap)


    def _populate_text(self, text_widget, lines_data):
        """Populates a text widget with lines and applies tags."""
        widget_name = text_widget.winfo_name()
        self.logger.debug(f"Populating widget {widget_name} with {len(lines_data)} lines.")
        text_widget.config(state=tk.NORMAL) # Abilita per modifica
        text_widget.delete('1.0', tk.END)   # Pulisci contenuto precedente

        if not lines_data:
            self.logger.debug(f"No lines data for {widget_name}.")
            text_widget.insert('1.0', "(No content)\n", ("empty",)) # Mostra messaggio vuoto
        else:
            content_string = ""
            tags_to_apply = [] # Lista di (tag_name, start_index, end_index)
            current_line_num = 1 # Tkinter usa indice 1-based
            for data_tuple in lines_data:
                if not isinstance(data_tuple, tuple) or len(data_tuple) != 2:
                    self.logger.warning(f"Skipping malformed data in {widget_name}: {data_tuple}")
                    line_content = "<Internal Error: Bad data format>\n"
                    code = 'error' # Codice fittizio per evitare errori tag
                else:
                    code, content = data_tuple
                    line_content = content + '\n' # Aggiungi newline per Text widget

                # Aggiungi il contenuto della riga alla stringa completa
                content_string += line_content

                # Calcola indici per i tag
                start_index = f"{current_line_num}.0"
                end_index = f"{current_line_num}.end" # .end si riferisce alla fine della linea logica

                # Aggiungi tag alla lista se necessario
                if code == '-': tags_to_apply.append(("removed", start_index, end_index))
                elif code == '+': tags_to_apply.append(("added", start_index, end_index))
                elif code == 'empty': tags_to_apply.append(("empty", start_index, end_index))

                current_line_num += 1 # Incrementa numero linea per la prossima iterazione

            # Inserisci tutto il testo in una volta sola
            text_widget.insert('1.0', content_string)

            # Applica tutti i tag raccolti
            for tag, start, end in tags_to_apply:
                try:
                     text_widget.tag_add(tag, start, end)
                except tk.TclError as tag_err:
                     self.logger.error(f"Error applying tag '{tag}' from {start} to {end}: {tag_err}")

        text_widget.config(state=tk.DISABLED) # Disabilita dopo aver popolato
        text_widget.yview_moveto(0.0)         # Assicura che sia all'inizio


    def _draw_minimap(self):
        """Draws the minimap overview based on self.diff_map."""
        canvas = self.minimap_canvas
        canvas.delete("diff_line")
        canvas.delete("viewport_indicator")

        num_lines = len(self.diff_map)
        if num_lines == 0:
            self.logger.debug("No diff map data for minimap.")
            return

        canvas.update_idletasks()
        canvas_width = canvas.winfo_width()
        canvas_height = canvas.winfo_height()

        if canvas_width <= 1 or canvas_height <= 1:
            self.logger.debug(f"Skipping minimap draw due to invalid dimensions: {canvas_width}x{canvas_height}")
            return

        self.logger.debug(f"Drawing minimap ({canvas_width}x{canvas_height}) for {num_lines} lines.")

        # Calcola l'altezza ESATTA per linea, senza max(1.0) inizialmente
        # per vedere se il problema è l'arrotondamento
        exact_line_height = float(canvas_height) / num_lines if num_lines > 0 else 1.0

        # --- MODIFICA: Arrotondamento e gestione bordo inferiore ---
        accumulated_height = 0.0
        for i, diff_type in enumerate(self.diff_map):
            y_start = round(accumulated_height) # Arrotonda inizio

            # Calcola l'altezza *teorica* per questa linea
            current_line_height = exact_line_height
            accumulated_height += current_line_height
            y_end = round(accumulated_height) # Arrotonda fine

            # Assicura che y_end sia almeno y_start + 1 per visibilità
            if y_end <= y_start: y_end = y_start + 1

            # Gestione ultima linea per riempire esattamente il canvas
            if i == num_lines - 1:
                 y_end = canvas_height # Forza l'ultima linea ad arrivare al bordo

            # Colore (come modificato prima per avere rosso per tutte le diff)
            color = '#F0F0F0' # Grigio
            if diff_type == 1 or diff_type == 2:
                 color = '#F8D0D0' # Rosso

            canvas.create_rectangle(0, y_start, canvas_width, y_end,
                                    fill=color, outline="", tags="diff_line")
        # --- FINE MODIFICA ---

        self._update_minimap_viewport()


    # --- Scrolling Logic (Solo Minimap Click) ---

    def _setup_scrolling(self):
         """ Configure ONLY minimap click for navigation. """
         self.minimap_canvas.bind("<Button-1>", self._on_minimap_click)
         # Nessun altro binding necessario (no scrollbar, no yscrollcommand)

    def _reset_scroll_flag(self):
        """Resets the scrolling flag."""
        self._scrolling_active = False

    def _update_minimap_viewport(self):
        """ Updates the indicator rectangle on the minimap. """
        canvas = self.minimap_canvas
        canvas.delete("viewport_indicator") # Rimuovi il vecchio
        try:
            # Leggi la posizione della vista da uno dei widget testo
            first, last = self.text_head.yview()
        except tk.TclError:
            self.logger.warning("TclError getting text view, cannot update minimap viewport.")
            return # Esce se il widget è distrutto

        # Assicurati che le dimensioni siano valide
        canvas.update_idletasks()
        canvas_height = canvas.winfo_height()
        canvas_width = canvas.winfo_width()
        if canvas_height <= 1 or canvas_width <=1 :
            self.logger.debug("Canvas not ready for viewport update.")
            return

        # Calcola coordinate y del rettangolo indicatore
        y_start = first * canvas_height
        y_end = last * canvas_height
        # Assicura altezza minima di 1 pixel
        if y_end <= y_start : y_end = y_start + 1

        # Disegna il nuovo indicatore
        canvas.create_rectangle(
            1, y_start, canvas_width - 1, y_end, # Margine laterale 1px
            outline='black', width=1,
            tags="viewport_indicator"
        )
        # Assicurati che sia sopra le linee colorate
        canvas.tag_raise("viewport_indicator")


    def _on_minimap_click(self, event):
        """ Handles clicks on the minimap to scroll the text views. """
        if self._scrolling_active: return # Previene chiamate multiple
        self._scrolling_active = True
        try:
             canvas = self.minimap_canvas
             canvas_height = canvas.winfo_height()
             if canvas_height <= 1: return # Canvas non pronto

             # Calcola la frazione verticale del click
             target_fraction = event.y / canvas_height
             # Limita la frazione tra 0.0 e poco meno di 1.0 per evitare problemi
             target_fraction = max(0.0, min(target_fraction, 1.0))

             self.logger.debug(f"Minimap clicked at y={event.y}, fraction={target_fraction:.3f}")

             # Muovi entrambi i widget di testo a quella frazione
             # yview_moveto imposta la *prima* linea visibile a quella frazione
             self.text_head.yview_moveto(target_fraction)
             self.text_workdir.yview_moveto(target_fraction)

             # Aggiorna l'indicatore sulla minimappa per riflettere la nuova vista
             self._update_minimap_viewport()

        finally:
             # Resetta il flag dopo un breve ritardo per evitare loop
             self.after(50, self._reset_scroll_flag) # Ritardo leggermente aumentato
             
    # Usiamo un debounce semplice per evitare ridisegni troppo frequenti durante il drag
    _configure_timer_id = None

    def _on_minimap_resize(self, event):
        """Called when the minimap canvas is resized (e.g., window resize).
           Schedules a redraw after a short delay (debounce)."""
        # Cancella il timer precedente se esiste
        if self._configure_timer_id:
            self.after_cancel(self._configure_timer_id)

        # Pianifica il ridisegno dopo un breve ritardo (es. 100ms)
        # Questo evita di ridisegnare continuamente mentre l'utente trascina il bordo
        self._configure_timer_id = self.after(100, self._redraw_minimap_on_resize)

    def _redraw_minimap_on_resize(self):
        """Actually redraws the minimap. Called by the debounced timer."""
        self.logger.debug("Redrawing minimap due to resize event.")
        self._configure_timer_id = None # Resetta ID timer
        # Chiama la funzione di disegno esistente
        self._draw_minimap()

# --- END OF FILE diff_viewer.py ---