from fastapi import HTTPException, UploadFile, status
from fastapi.security import HTTPAuthorizationCredentials
from icecream import ic

from app.admin import oauth_token
from app.controllers.events import EventController
from app.controllers.group import GroupController
from app.controllers.musicians import MusicianController
from app.controllers.users import UserController
from app.models.event import EventSeries, NewEventSeries
from app.models.group import Group
from app.models.musician import Musician
from app.models.user import User


class MainController:
    """
    The main controller and entry point for all API requests.
    All methods are either pass-throughs to the appropriate controller or
    are used to coordinate multiple controllers.

    token-based authentication is handled here as needed per the nature of the data being accessed.
    """

    def __init__(self) -> None:
        self.event_controller = EventController()
        self.musician_controller = MusicianController()
        self.user_controller = UserController()
        self.group_controller = GroupController()

    async def get_musicians(self) -> list[Musician]:
        return await self.musician_controller.get_musicians()

    async def get_musician(self, id: int) -> Musician:
        return await self.musician_controller.get_musician(id)

    async def update_musician(
        self,
        musician: Musician,
        url_param_id: int,
        token: HTTPAuthorizationCredentials,
        file: UploadFile | None = None,
    ) -> Musician:

        if musician.id != url_param_id:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="ID in URL does not match ID in request body",
            )
        _, sub = oauth_token.email_and_sub(token)
        await self.user_controller.get_user_by_sub(sub)
        return await self.musician_controller.update_musician(
            musician_id=musician.id,
            new_bio=musician.bio,
            file=file,
        )

    async def get_events(self) -> list[EventSeries]:
        return await self.event_controller.get_all_series()

    async def get_event(self, id: int) -> EventSeries:
        return await self.event_controller.get_one_series_by_id(id)

    async def create_event(
        self, series: NewEventSeries, token: HTTPAuthorizationCredentials
    ) -> EventSeries:
        _, sub = oauth_token.email_and_sub(token)
        await self.user_controller.get_user_by_sub(sub)
        return await self.event_controller.create_series(series)

    async def add_series_poster(
        self, series_id: int, poster: UploadFile, token: HTTPAuthorizationCredentials
    ) -> EventSeries:
        _, sub = oauth_token.email_and_sub(token)
        await self.user_controller.get_user_by_sub(sub)
        return await self.event_controller.add_series_poster(series_id, poster)

    async def delete_series(self, id: int, token: HTTPAuthorizationCredentials) -> None:
        _, sub = oauth_token.email_and_sub(token)
        await self.user_controller.get_user_by_sub(sub)
        await self.event_controller.delete_series(id)

    async def update_series(
        self, route_id: int, series: EventSeries, token: HTTPAuthorizationCredentials
    ) -> EventSeries:
        _, sub = oauth_token.email_and_sub(token)
        await self.user_controller.get_user_by_sub(sub)
        return await self.event_controller.update_series(route_id, series)

    async def get_users(self) -> list[User]:
        return await self.user_controller.get_users()

    async def get_user(self, id: int) -> User:
        return await self.user_controller.get_user_by_id(id)

    async def create_user(self, token: HTTPAuthorizationCredentials) -> User:
        return await self.user_controller.create_user(token)

    async def get_group(self) -> Group:
        return await self.group_controller.get_group()

    async def update_group_bio(
        self, bio: str, token: HTTPAuthorizationCredentials
    ) -> Group:
        _, sub = oauth_token.email_and_sub(token)
        await self.user_controller.get_user_by_sub(sub)
        return await self.group_controller.update_group_bio(bio)