from typing import Type

import sys
from urllib import parse

from PyQt5.QtWidgets import QApplication
from PyQt5.QtQml import qmlRegisterType, QQmlApplicationEngine
from PyQt5.QtQuick import QQuickImageProvider

# from PyQt5.QtQuick import QQuickView
from PyQt5.QtCore import QObject, pyqtProperty, pyqtSlot

from PyQt5.QtGui import QImage

# from PyQt5.QtCore import QObject, QUrl, pyqtProperty

# from .qtmpv import MpvObject

import requests


class Show(QObject):
    def __init__(self, source, parent=None):
        super().__init__(parent)
        self._source = source

    @pyqtProperty("QString")
    def title(self) -> str:
        return self._source["title"]

    @pyqtProperty(int)
    def year(self) -> int:
        return self._source["year"]

    @pyqtProperty(int)
    def episodes(self) -> int:
        return self._source["episodes"]

    @pyqtProperty(int)
    def watched(self) -> int:
        return self._source["watched"]

    @pyqtProperty("QString")
    def poster(self) -> str:
        return self._source["poster"]


class ProviderImageProvider(QQuickImageProvider):
    def __init__(self, icon_data):
        self._icon_data = icon_data

        super(ProviderImageProvider, self).__init__(QQuickImageProvider.Image)

    def requestImage(self, p_str, size):
        print(p_str)
        print(size)

        # img = QImage.fromData(self._icon_data.encode("utf-8"))
        import base64

        data: bytes = base64.b64decode(self._icon_data)
        img = QImage.fromData(data)
        # img = QImage.fromData(self._icon_data.encode("utf-8"))

        # img = QImage(300, 300, QImage.Format_RGBA8888)
        # img.fill(Qt.red)
        return img, img.size()


def getUrl(base: str, path: str) -> dict:
    url: str = parse.urljoin(base, path)
    r: requests.Response = requests.get(url)
    return r.json()


class Provider(QObject):
    def __init__(self, url: str, parent=None):
        super().__init__(parent)
        self.url: str = url

        describe: dict = getUrl(self.url, "describe")
        self._name: str = describe["name"]
        self.logo_provider: ProviderImageProvider = ProviderImageProvider(
            describe["icon"]
        )

        shows: dict = getUrl(self.url, "shows")
        self._shows: dict[int, Show] = {e["id"]: Show(e) for e in shows["data"]}

        recently_added: dict = getUrl(self.url, "recently_added")
        self._recently_added: list[int] = recently_added["data"]

        in_progress: dict = getUrl(self.url, "in_progress")
        self._in_progress: list[int] = in_progress["data"]

    @pyqtProperty("QString")
    def name(self) -> str:
        return self._name

    @pyqtProperty("QString")
    def logo(self) -> str:
        return f"image://{self._name}/logo"

    # @pyqtProperty("QObject")
    @pyqtSlot(int, result=QObject)
    def getShow(self, id) -> Show:
        return self._shows[id]

    @pyqtProperty(list)
    def recentlyAdded(self) -> list[int]:
        return self._recently_added

    @pyqtProperty(list)
    def inProgress(self) -> list[int]:
        return self._in_progress


class DataSource:
    def __init__(self, providers=[]):
        self.providers: list[Provider] = [Provider(url) for url in providers]


def DatabaseType(data_source) -> Type:
    class Database(QObject):
        def __init__(self, parent=None):
            super().__init__(parent)

            self.data_source: DataSource = data_source

        @pyqtProperty(list)
        def Providers(self) -> list[Provider]:
            return self.data_source.providers

    return Database


def main():
    app = QApplication(sys.argv)

    # data_source = DataSource(["Anime", "TV", "Movies", "Settings"])
    data_source = DataSource(
        [
            "http://127.0.0.1:8080/a/",
            "http://127.0.0.1:8080/b/",
            "http://127.0.0.1:8080/c/",
        ]
    )

    qmlRegisterType(DatabaseType(data_source), "Ikinuki.Client", 1, 0, "Database")
    # qmlRegisterType(Provider, "Ikinuki.Client", 1, 0, "Provider")

    engine = QQmlApplicationEngine()
    for provider in data_source.providers:
        print(f"Registering provider with name {provider._name}")
        engine.addImageProvider(
            provider._name,
            provider.logo_provider,
        )
    engine.load("layouts/ikinuki-default.qml")

    win = QObject()
    win = engine.rootObjects()[0]
    win.show()

    sys.exit(app.exec_())


#
#
#
#    app = QApplication([])
#
#    qmlRegisterType(MpvObject, 'mpvtest', 1, 0, "MpvObject")
#
#    window = QQmlApplicationEngine("layouts/mpv.qml")
#    window.run
#
#    view = QQuickView()
#    url = QUrl("layouts/mpv.qml")
#
#    import locale
#
#    locale.setlocale(locale.LC_NUMERIC, 'C')
#
#    view.setSource(url)
#    view.show()
#    app.exec_()