from pathlib import Path
from urllib.parse import urlparse

from PySide6.QtCore import Property, QObject, QRunnable, QThreadPool, Signal, Slot
from PySide6.QtQml import QmlElement, QmlSingleton

from leek.mod_installer import (
    ModInstaller,
    NoModExceptionError,
    UnsupportedArchiveTypeError,
)

QML_IMPORT_NAME = "Leek.QModInstaller"
QML_IMPORT_MAJOR_VERSION = 1


# Qt follows C++ naming conventions
# ruff: noqa: N802
@QmlElement
@QmlSingleton
class QModInstaller(QObject):
    """
    Qt Wrapper around the ModInstaller() class
    """

    __mod_installer: ModInstaller
    __status: str

    def __init__(self, parent=None):
        super().__init__(parent=parent)
        self.__status = "uninitialized"

    mod_path_changed = Signal(name="modPathChanged")

    @Property(str, notify=mod_path_changed)
    def modPath(self) -> str:
        return self.test

    @modPath.setter  # type: ignore[no-redef]
    def modPath(self, value: str) -> None:
        try:
            # In python 3.13 pathlib gained a from_uri() method which would be very useful
            parsed_path: str = urlparse(value, "file").path
            self.__mod_installer = ModInstaller(Path(parsed_path))
            self.__status = "initialized"
            self.status_changed.emit()
        except UnsupportedArchiveTypeError:
            self.__status = "UnsupportedArchiveTypeError"
            self.status_changed.emit()
        except NoModExceptionError:
            self.__status = "NoModExceptionError"
            self.status_changed.emit()

    install_status_changed = Signal(name="installStatusChanged")

    @Property(bool, notify=install_status_changed)
    def installed(self) -> bool:
        return self.__mod_installer.is_installed

    status_changed = Signal(name="statusChanged")

    @Property(str, notify=status_changed)
    def status(self) -> str:
        return self.__status

    finished_install = Signal(name="finishedInstall")

    @Slot()
    def install(self) -> None:
        worker = InstallWorker(InstallWorkerSignals(), self.__mod_installer)
        worker.signals.installed.connect(self.finished_install)
        QThreadPool.globalInstance().start(worker)


class InstallWorker(QRunnable):
    __installer: ModInstaller

    def __init__(self, signals, installer: ModInstaller) -> None:
        super().__init__()
        self.signals = signals
        self.__installer = installer

    # @Slot()
    def run(self) -> None:
        self.__installer.install()
        self.signals.installed.emit()


class InstallWorkerSignals(QObject):
    def __init__(self):
        super().__init__()

    installed = Signal()