# -*- coding: utf-8 -*-

######################
# Init static module #
######################

# Imports
from typing import Iterable
from tubot.static import env
from tubot.static.functions import validate
from tubot.torrent.apis import qBitTorrent
from tubot.torrent.types import ServerTypes
from tubot.torrent.abc import TorrentAPI
from tubot.dirgetter.types import GetterTypes
from tubot.dirgetter.abc import DirGetter
from tubot.dirgetter.getter import OSGetter, Jellyfin
from tubot.db.types import CacheDBTypes
from tubot.db.abc import CacheDB
from tubot.db.cache import PythonCache, RedisCache
from asyncio import create_task, gather


class InitBuilder(object):
    """
    Init all bot modules
    """

    TORRENT_SERVER: ServerTypes | TorrentAPI
    DG: GetterTypes | DirGetter
    CACHE: CacheDBTypes | CacheDB

    def set_torrent_server(self, server_type: ServerTypes) -> "InitBuilder":
        self.TORRENT_SERVER = server_type
        return self

    def set_directory_getter(self, dg_type: GetterTypes) -> "InitBuilder":
        self.DG = dg_type
        return self

    def set_cache_type(self, cache_type: CacheDBTypes) -> "InitBuilder":
        self.CACHE = cache_type
        return self

    async def init_ts(self) -> None:
        host = env.TS_HOST()()
        user = env.TS_USER()()
        pwd = env.TS_PASSWORD()()
        match self.TORRENT_SERVER:
            case ServerTypes.qBitTorrent:
                self.TORRENT_SERVER = qBitTorrent(host, user, pwd)
            case _:
                raise TypeError
        await validate(self.TORRENT_SERVER)

    async def init_dg(self) -> None:
        match self.DG:
            case GetterTypes.OS:
                base_dir = env.DG_OS_FOLDER()()
                self.DG = OSGetter(base_dir)
            case GetterTypes.Jellyfin:
                host = env.DG_JELLYFIN_HOST()()
                key = env.DG_JELLYFIN_TOKEN()()
                self.DG = Jellyfin(host, key)
            case _:
                raise TypeError
        await validate(self.DG)

    async def init_cache(self) -> None:
        match self.CACHE:
            case CacheDBTypes.PythonPKL:
                self.CACHE = PythonCache()
            case CacheDBTypes.Redis:
                host = env.REDIS_HOST()()
                self.CACHE = RedisCache(host)
            case _:
                raise TypeError
        await validate(self.CACHE)

    async def init_all_modules(self) -> None:
        tasks = (create_task(self.init_ts()), create_task(self.init_dg()), create_task(self.init_cache()))
        await gather(*tasks)

    @property
    def tuple(self) -> Iterable:
        return (self.TORRENT_SERVER, self.DG, self.CACHE)


async def init_modules() -> Iterable:
    ts = ServerTypes(env.TORRENT_SERVER()())
    dg = GetterTypes(env.DIR_GETTER()())
    cache = CacheDBTypes(env.CACHE_TYPE()())
    builder = InitBuilder().set_torrent_server(ts).set_directory_getter(dg).set_cache_type(cache)
    await builder.init_all_modules()
    return builder.tuple