#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Programme pour autonuméroter les bornes dans les fichiers QElectroTech (.qet)
Version finale qui fonctionne correctement
"""

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import xml.etree.ElementTree as ET
import os
from collections import OrderedDict

class QETBorneNumbering:
    def __init__(self, root):
        self.root = root
        self.root.title("Autonumérotation des bornes QElectroTech")
        self.root.geometry("800x600")
        
        # Variables
        self.file_path = None
        self.xml_root = None
        self.bornes_trouvees = []
        self.borne_selectionnee = None
        self.use_wire_num = tk.BooleanVar(value=False)
        
        self.create_widgets()
    
    def create_widgets(self):
        """Crée l'interface graphique"""
        # Frame principale
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # Configuration du poids pour le redimensionnement
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(3, weight=1)
        
        # Bouton pour ouvrir le fichier
        btn_open = ttk.Button(main_frame, text="Ouvrir un fichier .qet", command=self.open_file)
        btn_open.grid(row=0, column=0, columnspan=2, pady=10, sticky=tk.W+tk.E)
        
        # Label pour afficher le fichier ouvert
        self.label_file = ttk.Label(main_frame, text="Aucun fichier sélectionné", foreground="gray")
        self.label_file.grid(row=1, column=0, columnspan=2, sticky=tk.W)
        
        # Frame pour les bornes trouvées
        frame_bornes = ttk.LabelFrame(main_frame, text="Bornes trouvées", padding="5")
        frame_bornes.grid(row=2, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=10)
        frame_bornes.columnconfigure(0, weight=1)
        
        # Listbox pour les bornes
        self.listbox_bornes = tk.Listbox(frame_bornes, height=6)
        self.listbox_bornes.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        self.listbox_bornes.bind('<<ListboxSelect>>', self.on_borne_select)
        
        # Scrollbar pour la listbox
        scrollbar = ttk.Scrollbar(frame_bornes, orient="vertical", command=self.listbox_bornes.yview)
        scrollbar.grid(row=0, column=1, sticky=(tk.N, tk.S))
        self.listbox_bornes.configure(yscrollcommand=scrollbar.set)
        
        # Frame pour les boutons d'action
        frame_actions = ttk.LabelFrame(main_frame, text="Actions", padding="5")
        frame_actions.grid(row=3, column=0, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S), pady=10)
        frame_actions.columnconfigure(0, weight=1)
        
        # Bouton d'autonumérotation
        self.btn_numeroter = ttk.Button(frame_actions, text="Numéroter les bornes sélectionnées", 
                                       command=self.numeroter_bornes, state="disabled")
        self.btn_numeroter.grid(row=0, column=0, pady=5, sticky=tk.W+tk.E)

        # Checkbox pour le mode de numérotation (Numéro de fil)
        self.chk_wire = ttk.Checkbutton(frame_actions, text="Utiliser n° fil (Label_Fil)", 
                                       variable=self.use_wire_num)
        self.chk_wire.grid(row=1, column=0, pady=5, sticky=tk.W)
        
        # Bouton pour sauvegarder
        self.btn_save = ttk.Button(frame_actions, text="Sauvegarder le fichier", 
                                  command=self.save_file, state="disabled")
        self.btn_save.grid(row=1, column=0, pady=5, sticky=tk.W+tk.E)
        self.btn_save.grid(row=2, column=0, pady=5, sticky=tk.W+tk.E)
        
        # Zone de statut
        self.status_var = tk.StringVar(value="Prêt")
        status_bar = ttk.Label(main_frame, textvariable=self.status_var, relief=tk.SUNKEN)
        status_bar.grid(row=4, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(10, 0))
    
    def open_file(self):
        """Ouvre un fichier .qet et analyse les bornes"""
        file_path = filedialog.askopenfilename(
            title="Sélectionner un fichier QElectroTech",
            filetypes=[("Fichiers QElectroTech", "*.qet"), ("Tous les fichiers", "*.*")]
        )
        
        if file_path:
            try:
                self.file_path = file_path
                self.label_file.config(text=f"Fichier: {os.path.basename(file_path)}")
                
                # Lecture et analyse du fichier XML
                self.analyze_file()
                
                # Réinitialiser l'état de modification pour le nouveau fichier
                if hasattr(self, '_already_modified'):
                    del self._already_modified
                
                self.status_var.set(f"Fichier chargé: {len(self.bornes_trouvees)} bornes trouvées")
                
            except Exception as e:
                messagebox.showerror("Erreur", f"Impossible d'ouvrir le fichier:\n{str(e)}")
                self.status_var.set("Erreur lors de l'ouverture du fichier")
    
    def analyze_file(self):
        """Analyse le fichier XML pour trouver les bornes"""
        try:
            # Parser le fichier XML
            tree = ET.parse(self.file_path)
            self.xml_root = tree.getroot()
            
            # Extraire les bornes
            self.bornes_trouvees = self.extract_bornes()
            
            # Mettre à jour la listbox (sans doublons)
            self.update_listbox()
            
        except ET.ParseError as e:
            raise Exception(f"Erreur de parsing XML: {str(e)}")
        except Exception as e:
            raise Exception(f"Erreur lors de l'analyse: {str(e)}")
    
    def extract_bornes(self):
        """Extrait toutes les bornes du fichier XML"""
        bornes = []
        
        # Parcourir tous les diagrammes pour trouver les folios
        for diagram in self.xml_root.iter('diagram'):
            folio = diagram.get('folio', '1')
            
            # Parcourir les éléments dans ce diagramme
            for element in diagram.iter('element'):
                x = float(element.get('x', '0'))
                y = float(element.get('y', '0'))
                
                # Vérifier si c'est une borne (commence par X)
                for child in element:
                    if child.tag == 'elementInformations':
                        for info in child:
                            if info.tag == 'elementInformation':
                                name = info.get('name', '')
                                if name == 'label':
                                    text = info.text
                                    if text and text.upper().startswith('X'):
                                        bornes.append({
                                            'element': element,
                                            'label': text,
                                            'position': (x, y),
                                            'folio': folio
                                        })
                                        break
        
        return bornes
    
    def get_borne_base(self, label):
        """Extrait la base du label (tronque après ':')"""
        if ':' in label:
            return label.split(':')[0]
        return label
    
    def update_listbox(self):
        """Met à jour la listbox avec les bornes uniques"""
        self.listbox_bornes.delete(0, tk.END)
        
        # Extraire les bases de labels uniques (tronquer avant ':')
        bases_uniques = list(OrderedDict.fromkeys([self.get_borne_base(b['label']) for b in self.bornes_trouvees]))
        
        for label in sorted(bases_uniques):
            self.listbox_bornes.insert(tk.END, label)
        
        # Activer le bouton de numérotation si des bornes sont trouvées
        if bases_uniques:
            self.btn_numeroter.config(state="normal")
        else:
            self.btn_numeroter.config(state="disabled")
    
    def on_borne_select(self, event):
        """Gère la sélection d'une borne dans la listbox"""
        selection = self.listbox_bornes.curselection()
        if selection:
            index = selection[0]
            self.borne_selectionnee = self.listbox_bornes.get(index)
            self.status_var.set(f"Borne sélectionnée: {self.borne_selectionnee}")
    
    def get_connected_wire_text(self, diagram, element_id):
        """Trouve le texte du conducteur connecté à un élément donné"""
        if not element_id:
            return ""
        # Chercher dans les conducteurs du diagramme
        for conductor in diagram.iter('conductor'):
            # Vérification directe des attributs element1 et element2 (Format QET standard)
            # Le numéro de fil est dans l'attribut 'num'
            if conductor.get('element1') == element_id or conductor.get('element2') == element_id:
                text = conductor.get('num', '')
                if text and text.strip() and text.strip() != "_":
                    return text.strip()
            
            # Compatibilité avec d'autres formats potentiels (points de connexion)
            for point in conductor.iter('point'):
                if point.get('element') == element_id:
                    # Vérifier l'attribut text ou num
                    text = conductor.get('text', '')
                    if not text:
                        text = conductor.get('num', '')
                    
                    if text and text.strip() and text.strip() != "_":
                        return text.strip()
        return ""

    def numeroter_bornes(self):
        """Numérote les bornes sélectionnées dans leur ordre d'apparition"""
        if not self.borne_selectionnee:
            messagebox.showwarning("Avertissement", "Veuillez sélectionner une borne à numéroter")
            return
        
        try:
            # Si c'est la première numérotation, recharger le fichier XML
            if not hasattr(self, '_already_modified'):
                tree = ET.parse(self.file_path)
                self.xml_root = tree.getroot()
                self._already_modified = True
            # Sinon, utiliser l'arbre XML déjà modifié
            
            # Filtrer les bornes correspondant à la base sélectionnée
            bornes_a_numeroter = []
            for diagram in self.xml_root.iter('diagram'):
                folio = diagram.get('folio', '1')
                for element in diagram.iter('element'):
                    x = float(element.get('x', '0'))
                    y = float(element.get('y', '0'))
                    
                    for child in element:
                        if child.tag == 'elementInformations':
                            for info in child:
                                if info.tag == 'elementInformation':
                                    name = info.get('name', '')
                                    if name == 'label':
                                        text = info.text
                                        if text and self.get_borne_base(text) == self.borne_selectionnee:
                                            bornes_a_numeroter.append({
                                                'element': element,
                                                'label': text,
                                                'position': (x, y),
                                                'folio': folio,
                                                'diagram': diagram # Nécessaire pour trouver les fils
                                            })
                                            break
            
            if not bornes_a_numeroter:
                messagebox.showwarning("Avertissement", "Aucune borne trouvée pour ce label")
                return
            
            def natural_sort_key(s):
                """Fonction utilitaire pour trier les folios numériquement si possible"""
                import re
                return [int(text) if text.isdigit() else text.lower()
                        for text in re.split('([0-9]+)', s)]

            # Trier par folio puis par position (gauche à droite)
            # On utilise natural_sort_key pour le folio pour éviter que "10" soit avant "2"
            bornes_triees = sorted(bornes_a_numeroter, 
                                 key=lambda x: (natural_sort_key(x['folio']), x['position'][0], x['position'][1]))
            
            # Numéroter les bornes avec format X1:00, X1:01, etc.
            for i, borne in enumerate(bornes_triees):
                num_seq = i + 1
                if self.use_wire_num.get():
                    # Mode concaténation : X1:1_102 (Bornier:Index_Fil)
                    # QET utilise l'attribut 'uuid' pour l'identifiant unique
                    element_id = borne['element'].get('uuid')
                    if not element_id:
                        element_id = borne['element'].get('id')
                        
                    wire_text = self.get_connected_wire_text(borne['diagram'], element_id)
                    suffixe = wire_text if wire_text else "?"
                    nouveau_label = f"{self.borne_selectionnee}:{num_seq}_{suffixe}"
                else:
                    # Mode séquentiel classique
                    nouveau_label = f"{self.borne_selectionnee}:{num_seq}"
                
                # Modifier elementInformation
                for child in borne['element']:
                    if child.tag == 'elementInformations':
                        for info in child:
                            if info.tag == 'elementInformation':
                                name = info.get('name', '')
                                if name == 'label':
                                    info.text = nouveau_label
                    
                    # Modifier dynamic_text
                    elif child.tag == 'dynamic_texts':
                        for dynamic_text in child:
                            if dynamic_text.tag == 'dynamic_elmt_text':
                                for sub_child in dynamic_text:
                                    if sub_child.tag == 'info_name' and sub_child.text == 'label':
                                        for text_elem in dynamic_text:
                                            if text_elem.tag == 'text':
                                                text_elem.text = nouveau_label
            
            self.status_var.set(f"{len(bornes_triees)} bornes {self.borne_selectionnee} numérotées avec succès")
            self.btn_save.config(state="normal")
            
            messagebox.showinfo("Succès", f"{len(bornes_triees)} bornes {self.borne_selectionnee} ont été numérotées")
            
        except Exception as e:
            messagebox.showerror("Erreur", f"Erreur lors de la numérotation:\n{str(e)}")
    
    def save_file(self):
        """Sauvegarde le fichier modifié"""
        if not self.xml_root:
            messagebox.showwarning("Avertissement", "Aucun fichier à sauvegarder")
            return
        
        try:
            # Demander où sauvegarder
            save_path = filedialog.asksaveasfilename(
                title="Sauvegarder le fichier",
                defaultextension=".qet",
                filetypes=[("Fichiers QElectroTech", "*.qet"), ("Tous les fichiers", "*.*")],
                initialfile=os.path.basename(self.file_path)
            )
            
            if save_path:
                # Créer une copie de l'arbre XML pour la sauvegarde
                tree = ET.ElementTree(self.xml_root)
                
                # Configuration pour un beau formatage
                ET.indent(tree, space="  ", level=0)
                
                # Sauvegarder le fichier
                tree.write(save_path, encoding='utf-8', xml_declaration=True)
                
                self.status_var.set(f"Fichier sauvegardé: {os.path.basename(save_path)}")
                messagebox.showinfo("Succès", "Fichier sauvegardé avec succès")
                
        except Exception as e:
            messagebox.showerror("Erreur", f"Erreur lors de la sauvegarde:\n{str(e)}")

def main():
    """Fonction principale"""
    root = tk.Tk()
    app = QETBorneNumbering(root)
    root.mainloop()

if __name__ == "__main__":
    main()