"""Delivery API controller skeleton."""

from fastapi import APIRouter, Depends, HTTPException, Request, status

from app.adapters.delivery_providers.cdek import CDEKProvider
from app.config import Settings
from app.controllers.http_client import build_controller_http_client
from app.repositories.cache.redis_cache import PriceCache
from app.schemas.order import OrderCreateRequest, OrderCreateResponse
from app.schemas.request import DeliveryRequest
from app.schemas.response import DeliveryPrice
from app.services.aggregator import (
    AggregatorService,
    AggregatorServiceError,
    InvalidDeliveryRequestError,
    InvalidOrderCreateRequestError,
)

router = APIRouter(prefix="/delivery", tags=["delivery"])


_AGGREGATOR_SERVICE_STATE_KEY = "aggregator_service"


def _build_aggregator_service(settings: Settings) -> AggregatorService:
    http_client = build_controller_http_client(
        timeout_seconds=settings.adapter.cdek_timeout_seconds
    )
    cdek_provider = CDEKProvider.from_adapter_config(
        http_client=http_client,
        adapter_config=settings.adapter,
    )
    providers = (cdek_provider,)
    cache = PriceCache.from_repository_config(settings.repository)
    service = AggregatorService(
        providers=providers,
        cache=cache,
        order_adapter=cdek_provider,
        weight_round_scale=settings.business_logic.weight_round_scale,
        provider_price_multiplier=settings.business_logic.provider_price_multiplier,
    )
    return service


async def get_aggregator_service(request: Request) -> AggregatorService:
    cached_service = getattr(request.app.state, _AGGREGATOR_SERVICE_STATE_KEY, None)
    if cached_service is not None:
        return cached_service

    settings = request.app.state.settings
    service = _build_aggregator_service(settings)
    setattr(request.app.state, _AGGREGATOR_SERVICE_STATE_KEY, service)
    return service


@router.post(
    "/price",
    response_model=list[DeliveryPrice],
)
async def get_delivery_price(
    delivery_request: DeliveryRequest,
    service: AggregatorService = Depends(get_aggregator_service),
) -> list[DeliveryPrice]:
    try:
        return await service.get_all_prices(delivery_request)
    except InvalidDeliveryRequestError as exc:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail={
                "code": "invalid_delivery_request",
                "message": "Delivery request contains unknown or unsupported location.",
            },
        ) from exc
    except AggregatorServiceError as exc:
        raise HTTPException(
            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
            detail={
                "code": "aggregator_service_error",
                "message": "Delivery price aggregation is temporarily unavailable.",
            },
        ) from exc


@router.post(
    "/order",
    response_model=OrderCreateResponse,
)
async def create_delivery_order(
    order_request: OrderCreateRequest,
    service: AggregatorService = Depends(get_aggregator_service),
) -> OrderCreateResponse:
    try:
        return await service.create_order(order_request)
    except InvalidOrderCreateRequestError as exc:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail={
                "code": "invalid_order_create_request",
                "message": "Order request contains invalid or unsupported CDEK data.",
            },
        ) from exc
    except AggregatorServiceError as exc:
        raise HTTPException(
            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
            detail={
                "code": "order_creation_unavailable",
                "message": "CDEK order creation is temporarily unavailable.",
            },
        ) from exc