#!/usr/bin/env python3
import sys
import re
import os

f = "radar-app/src/components/Navigation/Navigation.tsx"

try:
    # Vérifier que le fichier existe
    if not os.path.exists(f):
        print(f"❌ Fichier {f} introuvable", file=sys.stderr)
        sys.exit(1)

    with open(f, 'r', encoding='utf-8') as file:
        content = file.read()

    # VÉRIFICATION PRÉLIMINAIRE: Détecter les doublons structurels
    print("🔍 Vérification de la structure du composant...")
    
    # Compter les éléments structurels
    nav_patterns = [
        r'<nav\s',
        r'className.*[Nn]avigation',
        r'export\s+(default\s+)?function\s+Navigation',
        r'const\s+Navigation\s*='
    ]
    nav_count = sum(len(re.findall(pattern, content)) for pattern in nav_patterns)
    
    # Compter les <ul> (peut y en avoir 2 pour mobile/desktop)
    ul_count = len(re.findall(r'<ul[^>]*>', content))
    
    # Compter les logos (Image avec logo ou logoFile)
    logo_patterns = [
        r'logoFile',
        r'logo\.svg',
        r'[Ll]ogo',
        r'Image.*logo'
    ]
    logo_count = sum(len(re.findall(pattern, content)) for pattern in logo_patterns)
    
    # Compter les fonctions Navigation
    function_count = len(re.findall(r'(export\s+(default\s+)?function\s+Navigation|const\s+Navigation\s*=\s*\(|function\s+Navigation\s*\()', content))
    
    print(f"📊 Structure détectée: {nav_count} nav, {ul_count} ul, {logo_count} logo, {function_count} fonction(s)")
    
    # Détecter les duplications structurelles
    if function_count > 1:
        print(f"⚠️ ATTENTION: {function_count} fonction(s) Navigation détectée(s) - possible duplication du composant", file=sys.stderr)
        # Extraire uniquement la première fonction Navigation
        matches = list(re.finditer(r'(export\s+(default\s+)?function\s+Navigation|const\s+Navigation\s*=\s*\(|function\s+Navigation\s*\()', content))
        if len(matches) > 1:
            # Garder seulement jusqu'à la fin de la première fonction
            first_end = matches[1].start() if len(matches) > 1 else len(content)
            content = content[:first_end]
            # Trouver la fin de la fonction (dernière accolade fermante avant la prochaine fonction)
            brace_count = 0
            in_function = False
            for i, char in enumerate(content[matches[0].start():], matches[0].start()):
                if char == '{':
                    brace_count += 1
                    in_function = True
                elif char == '}':
                    brace_count -= 1
                    if in_function and brace_count == 0:
                        content = content[:i+1]
                        break
            print(f"✅ Duplication du composant supprimée")
    
    if ul_count > 3:  # Plus de 3 ul suggère une duplication
        print(f"⚠️ ATTENTION: {ul_count} éléments <ul> détectés - possible duplication", file=sys.stderr)
    
    if logo_count > 5:  # Plus de 5 références au logo suggère une duplication
        print(f"⚠️ ATTENTION: {logo_count} références au logo détectées - possible duplication", file=sys.stderr)

    # ÉTAPE 1: Supprimer TOUS les liens Équipe existants (même s'il n'y en a qu'un)
    print("🧹 Nettoyage de tous les liens Équipe existants...")
    
    # APPROCHE AGRESSIVE: Supprimer tous les blocs <li> contenant un lien vers /team
    # Utiliser plusieurs patterns pour capturer tous les cas possibles
    # Pattern 1: <li>...<Link href="/team"...>...</Link>...</li>
    team_link_block_pattern = r'<li[^>]*>.*?<Link[^>]*href=["\']/?team(/|\.html)?["\'][^>]*>.*?</Link>.*?</li>'
    content_cleaned = re.sub(team_link_block_pattern, '', content, flags=re.DOTALL | re.IGNORECASE)
    
    # Pattern 2: Supprimer aussi les lignes contenant href="/team" même si elles ne sont pas dans un <li> complet
    content_cleaned = re.sub(r'.*href=["\']/?team(/|\.html)?["\'].*\n', '', content_cleaned, flags=re.IGNORECASE)
    
    # Pattern 3: Supprimer les blocs <li> qui pourraient contenir /team sur plusieurs lignes (format différent)
    content_cleaned = re.sub(r'<li[^>]*>.*?/team.*?</li>', '', content_cleaned, flags=re.DOTALL | re.IGNORECASE)
    
    # Compter combien de liens ont été supprimés
    remaining_before = len(re.findall(r'href=["\']/?team(/|\.html)?["\']', content))
    remaining_after = len(re.findall(r'href=["\']/?team(/|\.html)?["\']', content_cleaned))
    team_links_removed = remaining_before - remaining_after
    
    if team_links_removed > 0:
        print(f"✅ {team_links_removed} lien(s) Équipe supprimé(s) (regex multiligne)")
    elif remaining_after > 0:
        print(f"⚠️ {remaining_after} lien(s) Équipe encore présent(s) après nettoyage regex, nettoyage manuel...")
        # Nettoyage manuel ligne par ligne si la regex n'a pas tout capturé
        lines = content_cleaned.splitlines(keepends=True)
        if lines and not lines[-1].endswith('\n'):
            lines[-1] = lines[-1] + '\n'
        
        new_lines = []
        skip_team_link = False
        manual_removed = 0
        
        i = 0
        while i < len(lines):
            line = lines[i]
            
            # Détecter le début d'un lien Équipe
            team_link_match = re.search(r'href=["\']/?team(/|\.html)?["\']|href=\{["\']/?team', line)
            if team_link_match and not skip_team_link:
                skip_team_link = True
                manual_removed += 1
                i += 1
                continue
            
            if skip_team_link:
                if '</li>' in line:
                    skip_team_link = False
                i += 1
                continue
            
            new_lines.append(line)
            i += 1
        
        if manual_removed > 0:
            content_cleaned = ''.join(new_lines)
            print(f"✅ {manual_removed} lien(s) Équipe supplémentaire(s) supprimé(s) (nettoyage manuel)")
    
    lines = content_cleaned.splitlines(keepends=True)
    if lines and not lines[-1].endswith('\n'):
        lines[-1] = lines[-1] + '\n'
    
    # ÉTAPE 2: Vérifier qu'il n'y a plus aucun lien team avant d'ajouter
    final_check = len(re.findall(r'href=["\']/?team(/|\.html)?["\']', content_cleaned))
    if final_check > 0:
        print(f"⚠️ ATTENTION: {final_check} lien(s) Équipe encore présent(s) après nettoyage, nettoyage supplémentaire...", file=sys.stderr)
        # Nettoyage supplémentaire avec une regex plus agressive
        content_cleaned = re.sub(r'.*?href=["\']/?team(/|\.html)?["\'].*?\n', '', content_cleaned, flags=re.MULTILINE | re.IGNORECASE)
        # Supprimer aussi les blocs <li> vides qui pourraient rester
        content_cleaned = re.sub(r'<li[^>]*>\s*</li>\s*\n', '', content_cleaned)
        final_check_2 = len(re.findall(r'href=["\']/?team(/|\.html)?["\']', content_cleaned))
        if final_check_2 > 0:
            print(f"❌ ERREUR: {final_check_2} lien(s) Équipe toujours présent(s) après nettoyage supplémentaire!", file=sys.stderr)
            print("📄 Contenu autour des liens restants:", file=sys.stderr)
            for match in re.finditer(r'href=["\']/?team(/|\.html)?["\']', content_cleaned):
                start = max(0, match.start() - 50)
                end = min(len(content_cleaned), match.end() + 50)
                print(f"  {content_cleaned[start:end]}", file=sys.stderr)
        else:
            print(f"✅ Tous les liens Équipe supprimés après nettoyage supplémentaire")
    
    # ÉTAPE 3: Ajouter un seul lien Équipe au bon endroit
    insert_idx = -1
    for i, line in enumerate(lines):
        if 'href="/overview"' in line:
            for j in range(i, min(i+10, len(lines))):
                if '</Link>' in lines[j] and j+1 < len(lines) and '</li>' in lines[j+1]:
                    insert_idx = j + 2
                    break
            break

    if insert_idx > 0:
        new_lines = lines[:insert_idx] + [
            '        <li className={styles.item}>\n',
            '          <Link href="/team">\n',
            '            <span className={styles.label}>👥 Équipe</span>\n',
            '          </Link>\n',
            '        </li>\n'
        ] + lines[insert_idx:]
        with open(f, 'w', encoding='utf-8') as file:
            file.writelines(new_lines)
        
        # Vérifier qu'il n'y a qu'un seul lien maintenant (inclut /team, /team/, /team.html)
        with open(f, 'r', encoding='utf-8') as file:
            final_content = file.read()
        final_count = len(re.findall(r'href=["\']/?team(/|\.html)?["\']', final_content))
        
        if final_count == 1:
            print("✅ Navigation.tsx modifié - 1 seul lien Équipe présent")
            sys.exit(0)
        else:
            print(f"⚠️ Attention: {final_count} lien(s) Équipe détecté(s) après modification", file=sys.stderr)
            sys.exit(1)
    else:
        print("❌ Impossible de trouver l'emplacement pour insérer le lien", file=sys.stderr)
        sys.exit(1)
except Exception as e:
    print(f"❌ Erreur Python: {e}", file=sys.stderr)
    import traceback
    traceback.print_exc(file=sys.stderr)
    sys.exit(1)