import asyncio
import sys
from pathlib import Path
import logging
import base64

from PySide6.QtCore import QTimer
from PySide6.QtGui import QIcon
from PySide6.QtWidgets import QMainWindow

from src.conf import ConfManager
from src.download import DownloadManager
from src.handler import WebHandler
from windows.site_window import SiteWindow

import resources_rc


class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        # Création d'un logger spécifique pour cette classe
        self.logger = logging.getLogger("MainWindow")
        self.logger.info("Initialisation de la fenêtre principale")

        # initialise main app
        self.setWindowTitle("Oxpanel")
        self.setMinimumSize(1024, 768)
        self.setWindowIcon(QIcon(":/oxpanel.ico"))
        self.url = "http://127.0.0.1:8000/" if "--dev" in sys.argv else "https://oxpanel.com/"
        self.logger.debug(f"URL configurée: {self.url}")

        # initialise every module
        self.logger.debug("Initialisation des modules")
        self.conf = ConfManager(self)
        self.download_manager = DownloadManager(self)
        self.web_handler = WebHandler(self.download_manager, self)

        # initialise windows
        self.logger.debug("Initialisation des fenêtres")
        self.site_window = SiteWindow(self)
        self.setCentralWidget(self.site_window)

        # connection des signaux
        self.site_window.on_cookie_added.connect(lambda cookie: asyncio.ensure_future(self.download_manager.add_cookie(cookie)))
        self.logger.debug("Signaux connectés")

        # initialisation du gestionnaire de téléchargement
        self.dm_loop = None
        QTimer.singleShot(0, self.setup_async_tasks)

        self.logger.info("Fenêtre principale initialisée avec succès")

    def setup_async_tasks(self):
        # Lancer les tâches asyncio une fois que l'application est prête
        self.logger.debug("Configuration des tâches asynchrones")
        self.dm_loop = asyncio.ensure_future(self.download_manager.loop_queue())
        self.logger.debug("File d'attente de téléchargement démarrée")

    def handle_files(self, file_paths):
        """
        Traite les fichiers reçus via "Ouvrir avec" ou d'une autre instance.

        Args:
            file_paths (list): Liste des chemins de fichiers à traiter
        """
        if not self.web_handler.site_loaded:
            QTimer.singleShot(100, lambda: self.handle_files(file_paths))
            self.logger.info("Site pas prêt, report de l'envoie des fichiers")
            return

        self.logger.info(f"Traitement de {len(file_paths)} fichiers reçus")
        for file_path in file_paths:
            file_path = Path(file_path)
            self.logger.debug(f"Traitement du fichier : {file_path}")

            # Exemple: vérifier si le fichier existe
            if file_path.exists():
                self.logger.debug(f"Le fichier {file_path} existe")
                try:
                    with file_path.open("rb") as file:
                        file_content = file.read()
                        encoded_content = base64.b64encode(file_content).decode("utf-8")
                        self.web_handler.on_message.emit({
                            "context": "upload_torrent",
                            "content": encoded_content
                        })
                except Exception as e:
                    self.logger.error(f"Erreur lors de la lecture ou de l'encodage du fichier {file_path}: {e}")
            else:
                self.logger.warning(f"Le fichier {file_path} n'existe pas")