from typing import Dict, List, Optional, Type

import redis.asyncio as redis
from fastapi import FastAPI
from pydantic import HttpUrl
from starlette.middleware.base import BaseHTTPMiddleware
from tortoise import Model

from fastapi_admin import i18n

from . import middlewares, template
from .providers import Provider
from .resources import Dropdown
from .resources import Model as ModelResource
from .resources import Resource
from .routes import router


class FastAPIAdmin(FastAPI):
    logo_url: str
    login_logo_url: str
    admin_path: str
    resources: List[Type[Resource]] = []
    model_resources: Dict[Type[Model], Type[Resource]] = {}
    redis: redis.Redis
    language_switch: bool = True
    favicon_url: Optional[HttpUrl] = None

    async def configure(
        self,
        redis: redis.Redis,
        logo_url: str = None,
        default_locale: str = "en_US",
        language_switch: bool = True,
        admin_path: str = "/admin",
        template_folders: Optional[List[str]] = None,
        providers: Optional[List[Provider]] = None,
        favicon_url: Optional[HttpUrl] = None,
    ):
        self.redis = redis
        i18n.set_locale(default_locale)
        self.admin_path = admin_path
        self.language_switch = language_switch
        self.logo_url = logo_url
        self.favicon_url = favicon_url
        if template_folders:
            template.add_template_folder(*template_folders)
        await self._register_providers(providers)

    async def _register_providers(self, providers: Optional[List[Provider]] = None):
        for p in providers or []:
            await p.register(self)

    def register_resources(self, *resource: Type[Resource]):
        for r in resource:
            self.register(r)

    def _set_model_resource(self, resource: Type[Resource]):
        if issubclass(resource, ModelResource):
            self.model_resources[resource.model] = resource
        elif issubclass(resource, Dropdown):
            for r in resource.resources:
                self._set_model_resource(r)

    def register(self, resource: Type[Resource]):
        self._set_model_resource(resource)
        self.resources.append(resource)

    def get_model_resource(self, model: Type[Model]):
        r = self.model_resources.get(model)
        return r() if r else None


app = FastAPIAdmin(
    title="FastAdmin",
    description="A fast admin dashboard based on fastapi and tortoise-orm with tabler ui.",
)
app.add_middleware(BaseHTTPMiddleware, dispatch=middlewares.language_processor)
app.include_router(router)