"""
Application principale du client desktop MyMind
"""
import sys
import os
from pathlib import Path

# Détecter si on est en mode production (sans console)
# Si stdout/stderr ne sont pas disponibles, on est probablement lancé avec pythonw.exe
IS_PRODUCTION = (
    not hasattr(sys.stdout, 'write') or 
    sys.stdout is None or 
    sys.stderr is None or
    getattr(sys, 'frozen', False)  # Mode exécutable PyInstaller
)

# Rediriger stdout/stderr vers nul en mode production pour éviter les erreurs
if IS_PRODUCTION:
    try:
        sys.stdout = open(os.devnull, 'w')
        sys.stderr = open(os.devnull, 'w')
    except:
        pass

# IMPORTANT: Tous les imports doivent être au niveau supérieur pour que PyInstaller les détecte
# PyInstaller fait une analyse statique et ne voit pas les imports conditionnels

# Configurer sys.path AVANT les imports
if getattr(sys, 'frozen', False):
    # Mode exécutable (PyInstaller)
    # S'assurer que _MEIPASS est dans sys.path
    if hasattr(sys, '_MEIPASS'):
        if sys._MEIPASS not in sys.path:
            sys.path.insert(0, sys._MEIPASS)
elif Path(__file__).parent.name == 'app':
    # Mode portable - les modules sont dans le même répertoire (app/)
    # Pas besoin d'ajouter au path, les imports directs fonctionneront
    pass
else:
    # Mode développement - ajouter le répertoire parent
    sys.path.insert(0, str(Path(__file__).parent.parent))

# Imports - PyInstaller les détectera maintenant car ils sont au niveau supérieur
# En mode développement, utiliser le préfixe desktop_client
# En mode exécutable, les imports directs fonctionneront car les modules sont dans _MEIPASS
try:
    # Essayer d'abord les imports directs (pour PyInstaller)
    from config import Config
    from api_client import APIClient
    from shortcut_handler import ShortcutHandler
    from gui import MyMindGUI
    from updater import Updater
except ImportError:
    # Fallback: imports avec préfixe (pour le mode développement)
    from desktop_client.config import Config
    from desktop_client.api_client import APIClient
    from desktop_client.shortcut_handler import ShortcutHandler
    from desktop_client.gui import MyMindGUI
    from desktop_client.updater import Updater

def check_and_install_customtkinter():
    """Vérifie et installe CustomTkinter si nécessaire"""
    try:
        import customtkinter  # type: ignore
        return True
    except ImportError:
        if not IS_PRODUCTION:
            print("[MyMind] CustomTkinter non trouvé, installation en cours...")
        try:
            import subprocess
            import sys
            subprocess.check_call([sys.executable, "-m", "pip", "install", "customtkinter>=5.2.0", "--quiet"])
            if not IS_PRODUCTION:
                print("[MyMind] CustomTkinter installé avec succès")
            return True
        except Exception as e:
            if not IS_PRODUCTION:
                print(f"[MyMind] ERREUR: Impossible d'installer CustomTkinter: {e}")
            return False

def main():
    """Point d'entrée principal"""
    if not IS_PRODUCTION:
        print("=== MyMind Desktop Client ===")
        print("Demarrage...")
        print()
    
    # Vérifier et installer CustomTkinter si nécessaire
    if not check_and_install_customtkinter():
        try:
            import tkinter as tk
            from tkinter import messagebox
            root = tk.Tk()
            root.withdraw()
            messagebox.showerror(
                "Dépendance manquante",
                "CustomTkinter est requis mais n'a pas pu être installé automatiquement.\n\n"
                "Veuillez installer manuellement avec:\n"
                "pip install customtkinter>=5.2.0"
            )
            root.destroy()
        except:
            pass
        sys.exit(1)
    
    # Charger la configuration
    config = Config()
    
    # Créer le client API
    api_urls = config.get_api_urls()
    working_url = config.get('api_url')
    api_client = APIClient(api_urls, working_url)
    
    # Vérifier que toutes les méthodes nécessaires sont présentes
    if not hasattr(api_client, 'get_form_list_items'):
        error_msg = """
⚠️ ERREUR : Version de l'application obsolète ⚠️

L'application nécessite une mise à jour. La méthode 'get_form_list_items' 
n'est pas disponible dans votre version d'APIClient.

Solutions :
1. Si vous utilisez un exécutable (.exe) : Téléchargez la dernière version
2. Si vous utilisez Python : Vérifiez que tous les fichiers sont à jour
3. Videz le cache Python : Supprimez les dossiers __pycache__ et les fichiers .pyc
4. Redémarrez complètement l'application

Chemin du fichier api_client.py actuel :
{}
        """.format(Path(__file__).parent / 'api_client.py' if Path(__file__).parent.name == 'app' else 'N/A')
        
        if not IS_PRODUCTION:
            print(error_msg)
        
        # Afficher une boîte de dialogue d'erreur
        try:
            import tkinter as tk
            from tkinter import messagebox
            root = tk.Tk()
            root.withdraw()
            messagebox.showerror(
                "Version obsolète",
                "L'application nécessite une mise à jour.\n\n"
                "La méthode 'get_form_list_items' n'est pas disponible.\n\n"
                "Veuillez mettre à jour tous les fichiers ou télécharger\n"
                "la dernière version de l'application."
            )
            root.destroy()
        except:
            pass
        
        sys.exit(1)
    
    # Vérifier les mises à jour au lancement (en arrière-plan)
    updater = None
    if config.get('check_updates', True):
        try:
            updater = Updater(api_client, config)
            if not IS_PRODUCTION:
                print("[MyMind] Vérification des mises à jour...")
            # Vérification asynchrone pour ne pas bloquer le démarrage
            updater.check_and_update_async()
        except Exception as e:
            if not IS_PRODUCTION:
                print(f"[MyMind] Erreur lors de la vérification des mises à jour: {e}")
    
    # Authentification optionnelle via la config (email / mot de passe)
    auth_email = config.get('auth_email') or ''
    auth_password = config.get('auth_password') or ''
    if auth_email and auth_password:
        if not IS_PRODUCTION:
            print(f"[MyMind] Tentative de connexion pour l'utilisateur {auth_email}...")
        if api_client.login(auth_email, auth_password):
            if not IS_PRODUCTION:
                print("[MyMind] Authentification réussie.")
        else:
            if not IS_PRODUCTION:
                print("[MyMind] Échec de l'authentification. Vérifiez email/mot de passe dans ~/.mymind/config.json.")
    
    # Créer le gestionnaire de raccourcis
    def on_shortcut_found(shortcut):
        """Callback appelé quand un raccourci est trouvé"""
        if not IS_PRODUCTION:
            print(f"[MyMind] Raccourci trouve: {shortcut.get('keyword')} -> {shortcut.get('text', '')[:50]}...")
    
    shortcut_handler = ShortcutHandler(api_client, config, on_shortcut_found)
    
    # Démarrer le gestionnaire de raccourcis
    try:
        shortcut_handler.start()
        if not IS_PRODUCTION:
            print("[MyMind] Gestionnaire de raccourcis demarre")
            print("[MyMind] Mode debug active - les logs s'affichent dans la console")
            print()
    except Exception as e:
        if not IS_PRODUCTION:
            print(f"ERREUR lors du demarrage du gestionnaire: {e}")
            print("Verifiez que vous avez les permissions necessaires pour intercepter les touches.")
            import traceback
            traceback.print_exc()
        return
    
    # Créer l'interface graphique
    def on_close():
        """Callback appelé à la fermeture"""
        if not IS_PRODUCTION:
            print("Arrêt du gestionnaire de raccourcis...")
        shortcut_handler.stop()
        if not IS_PRODUCTION:
            print("Au revoir !")
    
    gui = MyMindGUI(config, api_client, shortcut_handler, on_close, updater)
    
    # Lancer l'interface
    try:
        gui.run()
    except KeyboardInterrupt:
        on_close()
    except Exception as e:
        if not IS_PRODUCTION:
            print(f"Erreur: {e}")
            import traceback
            traceback.print_exc()
        on_close()

if __name__ == "__main__":
    main()
