import datetime
from pathlib import Path
from urllib import parse

from fastapi import APIRouter
from fastapi.responses import HTMLResponse, RedirectResponse

from gallery.easel.core import AppRequest
from gallery.easel.depends.api import api_resolver
from gallery.easel.depends.date import DateDepends
from gallery.easel.depends.schedule import (
    GROUP_CANNELS_MAP,
    ScheduleApiDepends,
    ScheduleGroupChannelsDepends,
)
from gallery.sketch.bundle import ApiBundle
from gallery.sketch.schedule.api import ScheduleApi
from gallery.sketch.schedule.model import Schedule

from ..common.utils.template import build_templates
from .filters import timedelta_format


def context_procesor(request: AppRequest) -> dict:
    return {
        "providers": request.app.state.api.get_api_providers(ScheduleApi),
    }


templates = build_templates(
    Path(__file__).parent / "templates",
    {
        "timedelta_format": timedelta_format,
    },
    context_procesor,
)

router = APIRouter(prefix="/schedule")


@router.get("/", response_class=HTMLResponse)
async def get_schedule_index(request: AppRequest, provider: str | None = None, query: str | None = None):
    if query and provider:
        schedule_api = api_resolver(ScheduleApi)(request, provider)
        channels = await schedule_api.find_channels(query)
    else:
        channels = []
    return templates.TemplateResponse(
        request=request,
        name="index.html",
        context={"channels": [item.model_dump() for item in channels], "groups": GROUP_CANNELS_MAP.keys()},
    )


async def _get_group_schedule(api: ApiBundle, channels: list[tuple[str, str]], date: datetime.date) -> list[Schedule]:
    return [
        await api.get_api(ScheduleApi, provider).get_schedule(channel_id, date) for provider, channel_id in channels
    ]


@router.get("/group/{group_id}", response_class=RedirectResponse)
async def get_group_default(group_id: str):
    return RedirectResponse(f"{parse.quote(group_id)}/today")


@router.get("/group/{group_id}/{date}", response_class=HTMLResponse)
async def get_group(request: AppRequest, channels: ScheduleGroupChannelsDepends, date: DateDepends):
    responses = [
        await request.app.state.api.get_api(ScheduleApi, channel.provider).get_schedule(channel.id, date)
        for channel in channels
    ]
    return templates.TemplateResponse(
        request=request,
        name="group.html",
        context={"responses": responses},
    )


@router.get("/{provider}/{channel}", response_class=RedirectResponse)
async def get_channel_default(channel: str):
    return RedirectResponse(f"{channel}/today")


@router.get("/{provider}/{channel}/{date}", response_class=HTMLResponse)
async def get_channel(request: AppRequest, schedule_api: ScheduleApiDepends, channel: str, date: DateDepends):
    response = await schedule_api.get_schedule(channel, date)
    return templates.TemplateResponse(
        request=request,
        name="channel.html",
        context={"response": response},
    )