import sys
import app.utils.paths as paths
from PyQt6.QtCore import Qt
from PyQt6.QtWidgets import QApplication
from PyQt6.QtGui import QIcon
from app.ui.main_window import MainWindow
from app.ui.windows.splash_screen import SplashScreen
from app.core.main_manager import MainManager

preloaded_window = None

def preload_application(progress_callback, splash=None):
    """
    Fonction de préchargement qui s'exécute pendant l'affichage du splash screen
    
    Args:
        progress_callback: Fonction pour mettre à jour le texte de progression
        splash: Référence au splash screen (optionnel)
        
    Returns:
        bool: True si tout s'est bien passé, False sinon
    """
    global preloaded_window
    
    try:
        main_manager = MainManager.get_instance()
        
        language_manager = main_manager.get_language_manager()
        update_manager = main_manager.get_update_manager()
        license_manager = main_manager.get_license_manager()
        settings_manager = main_manager.get_settings_manager()
        # Vérifier la licence uniquement si le système est activé
        if settings_manager.get_config("enable_licensing"):
            progress_callback(language_manager.get_text("verifying_license"))
            license_manager.verify_license()
        
        progress_callback(language_manager.get_text("checking_updates"))
        if update_manager.check_for_update(splash, splash):
            return False
        
        progress_callback(language_manager.get_text("initializing"))
        preloaded_window = MainWindow()

        progress_callback(language_manager.get_text("loading_complete"))

        return True
        
    except Exception:
        return False

def main() -> int:
    global preloaded_window
    try:
        QApplication.setAttribute(Qt.ApplicationAttribute.AA_ShareOpenGLContexts, True)
    except Exception:
        return 0

    try:
        main_manager: MainManager = MainManager.get_instance()
        
        theme_manager = main_manager.get_theme_manager()
        settings_manager = main_manager.get_settings_manager()
    except Exception as e:
        print(f"Error occurred while initializing managers: {e}")
        return 0

    try:
        app: QApplication = QApplication(sys.argv)
    except Exception:
        return 0

    try:
        app.setStyleSheet(theme_manager.get_sheet())
        app.setApplicationName(settings_manager.get_config("app_name"))
        app.setWindowIcon(QIcon(paths.get_asset_path("icon")))
    except Exception:
        return 0

    splash_image_path = paths.get_asset_path(settings_manager.get_config("splash_image"))
    use_splash = splash_image_path and paths.Path(splash_image_path).exists()

    if use_splash:
        try:
            splash = SplashScreen(preload_function=lambda callback: preload_application(callback, splash))
            splash.show_splash()
        except Exception as e:
            return 0

        def on_splash_finished(success):
            global preloaded_window
            if not success:
                app.quit()
                return
            try:
                if preloaded_window:
                    preloaded_window.show()
                else:
                    window = MainWindow()
                    window.show()
            except Exception:
                app.quit()

        splash.finished.connect(on_splash_finished)
        return app.exec()
    else:
        def dummy_progress(text):
            pass
        success = preload_application(dummy_progress)
        if not success:
            return 0
        try:
            window = preloaded_window if preloaded_window else MainWindow()
            window.show()
        except Exception:
            return 0
        return app.exec()

if __name__ == "__main__":
    sys.exit(main())