import logging

from fastapi import FastAPI
from injectable import load_injection_container
from fastapi.staticfiles import StaticFiles

from app.config import get_settings
from app.core.core import WebhookProcessor
from app.util.logging import LoggingHandler, ExternalLoggingHandler


class KarlApplication:
  from starlette.types import Receive, Scope, Send
  def __init__(self) -> None:
    self._set_logging()
    _instance = FastAPI(title="Karl", version="0.1.0")
    self._set_routes(_instance)
    self._set_events(_instance)
    self._init_services()

    self._instance = _instance

  async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
    await self._instance.__call__(scope, receive, send)

  def _set_logging(self):
    logging.basicConfig(level=logging.INFO, handlers=[LoggingHandler()])

    loggers = (
      "uvicorn",
      "uvicorn.access",
      "uvicorn.error",
      "fastapi",
      "asyncio",
      "starlette",
    )
    external_handler = ExternalLoggingHandler()
    for logger_name in loggers:
      logging_logger = logging.getLogger(logger_name)
      logging_logger.handlers = [external_handler]
      logging_logger.propagate = False

  def _set_routes(self, instance: FastAPI):
    from app.core.router import router as core_router
    instance.include_router(core_router)
    from app.api.v1 import router as api_v1_router
    instance.include_router(api_v1_router, prefix="/api/v1", tags=["v1"])
    instance.mount("/static", StaticFiles(directory="app/static"), name="static")

  def _set_events(self, instance: FastAPI):
    pass

  def _init_services(self):
    logger = logging.getLogger(__name__)
    load_injection_container()
    webhook_service = WebhookProcessor()
    logger.info(webhook_service.health)


def app():
  return KarlApplication()


if __name__ == "__main__":
  import uvicorn

  settings = get_settings()
  uvicorn.run(
    "app.main:app",
    factory=True,
    host=settings.app.host,
    port=settings.app.port,
    reload=settings.app.reload,
    log_config=None,
  )