import fastapi
from starlette.responses import FileResponse

from src.api.dependencies import get_repository
from src.data.model.schemas.shop import Shop
from src.data.repositories import order as repo
from src.data.repositories.agent import AgentRepository
from fastapi import APIRouter, Response
from src.data.model.schemas import order as schema
from src.data.exports.order import generate_xml
from src.mailing.mailing import send_order

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


@router.post(
    path="/order/",
    summary="Puts new order and sends email to customer",
    operation_id="putOrder",
    name="orders::order"
)
async def order(
        do_order: schema.DoOrder,
        repo: repo.OrderRepository = fastapi.Depends(get_repository(repo_type=repo.OrderRepository)),
        agent_repo: AgentRepository = fastapi.Depends(get_repository(repo_type=AgentRepository))
) -> dict[str, int]:
    done_order = await repo.do_order(do_order)
    partner = await agent_repo.get_partner(done_order.partner_id)
    email = await agent_repo.get_partner_email(done_order.partner_id)

    send_order(email, done_order, partner, do_order.shop)

    return {"id": done_order.id}


@router.get(
    path="/order/{partner_id}",
    operation_id="getOrders",
    summary="Get paginated list of orders according to selected parameters",
    name="orders::get-orders",
    response_model=schema.PagedOrders
)
async def get_orders(
        partner_id: int,
        agent_id: int | None,
        sales_order_type_code: int | None,
        shop: Shop,
        from_item: int,
        take: int,
        current_season: bool,
        repo: repo.OrderRepository = fastapi.Depends(get_repository(repo_type=repo.OrderRepository))
) -> schema.PagedOrders:
    get_order = schema.GetOrder(
        partner_id=partner_id,
        agent_id=agent_id,
        sales_order_type_code=sales_order_type_code,
        shop=shop,
        from_item=from_item,
        take=take,
        current_season=current_season
    )
    return await repo.get_orders(get_order)


@router.get(
    path="/select-order/{id}",
    operation_id="getOrder",
    summary="Get order by id",
    name="orders::get-orders",
    response_model=schema.Order
)
async def get_order(
        id: int,
        repo: repo.OrderRepository = fastapi.Depends(get_repository(repo_type=repo.OrderRepository))
) -> schema.Order:
    order = await repo.get_order(id)
    return order


@router.get(
    path="/imports",
    operation_id="getOrderImport",
    # response_model=FileResponse,
    name="orders::get-import"
)
async def get_import(repo: repo.OrderRepository = fastapi.Depends(get_repository(repo_type=repo.OrderRepository))):
    orders = await repo.get_unprocessed_orders()
    return Response(content=generate_xml(orders), media_type="applicaion/xml")