from io import BytesIO

from fastapi import APIRouter, Depends, Response, Query

from backend.dependecies import SessionDependency
from generators.residual_qr_code_generator import ResidualQRCodeGenerator
from schemas.residues import *
from services.auth import authorized_user
from services.residues import ResiduesService

residues_router = APIRouter(
    prefix="/residues",
    tags=["residues"],
)


@residues_router.get(
    '/pallet/{pallet_id}',
    response_model=GetResidualPalletResponse,
    operation_id='get_residual_pallet',
    dependencies=[Depends(authorized_user)],
)
async def get_pallet(
        session: SessionDependency,
        pallet_id: int,
):
    return await ResiduesService(session).get_pallet(pallet_id)


@residues_router.post(
    '/pallet',
    response_model=CreateResidualPalletResponse,
    operation_id='create_residual_pallet',
    dependencies=[Depends(authorized_user)],
)
async def create_pallet(
        session: SessionDependency,
        request: CreateResidualPalletRequest,
):
    return await ResiduesService(session).create_pallet(request)


@residues_router.delete(
    '/pallet/{pallet_id}',
    response_model=DeleteResidualPalletResponse,
    operation_id='delete_residual_pallet',
    dependencies=[Depends(authorized_user)],
)
async def delete_pallet(
        session: SessionDependency,
        pallet_id: int,
):
    return await ResiduesService(session).delete_pallet(pallet_id)


@residues_router.post(
    '/product',
    response_model=CreateResidualProductResponse,
    operation_id='create_residual_product',
    dependencies=[Depends(authorized_user)],
)
async def create_residual_product(
        session: SessionDependency,
        request: CreateResidualProductRequest,
):
    return await ResiduesService(session).create_residual_product(request)


@residues_router.post(
    '/product/{residual_product_id}',
    response_model=UpdateResidualProductResponse,
    operation_id='update_residual_product',
    dependencies=[Depends(authorized_user)],
)
async def update_residual_product(
        session: SessionDependency,
        request: UpdateResidualProductRequest,
        residual_product_id: int,
):
    return await ResiduesService(session).update_residual_product(request, residual_product_id)


@residues_router.delete(
    '/product/{residual_product_id}',
    response_model=DeleteResidualProductResponse,
    operation_id='delete_residual_product',
    dependencies=[Depends(authorized_user)],
)
async def delete_residual_product(
        session: SessionDependency,
        residual_product_id: int,
):
    return await ResiduesService(session).delete_residual_product(residual_product_id)


@residues_router.get(
    '/box/{box_id}',
    response_model=GetResidualBoxResponse,
    operation_id='get_residual_box',
    dependencies=[Depends(authorized_user)],
)
async def get_box(
        session: SessionDependency,
        box_id: int,
):
    return await ResiduesService(session).get_box(box_id)


@residues_router.post(
    '/box',
    response_model=CreateResidualBoxResponse,
    operation_id='create_residual_box',
    dependencies=[Depends(authorized_user)],
)
async def create_box(
        session: SessionDependency,
        request: CreateResidualBoxRequest,
):
    return await ResiduesService(session).create_box(request)


@residues_router.delete(
    '/box/{box_id}',
    response_model=DeleteResidualBoxResponse,
    operation_id='delete_residual_box',
    dependencies=[Depends(authorized_user)],
)
async def delete_box(
        session: SessionDependency,
        box_id: int,
):
    return await ResiduesService(session).delete_box(box_id)


@residues_router.post(
    '/receipt',
    response_model=LoadReceiptResponse,
    operation_id='receipt',
)
async def receipt(
        session: SessionDependency,
        request: LoadReceiptRequest,
):
    return await ResiduesService(session).load_receipt(request)


@residues_router.get(
    "/pdf/",
    operation_id="get_pdf",
)
async def generate_pdf(
        session: SessionDependency,
        pallet_ids: str = Query(""),
        box_ids: str = Query(""),
):
    pdf_file: BytesIO = await ResidualQRCodeGenerator(session).generate(pallet_ids, box_ids)
    return Response(pdf_file.getvalue(), media_type="application/pdf")