from typing import Annotated

from fastapi import APIRouter, Depends
from sqlalchemy.ext.asyncio import AsyncSession

from backend.dependecies import SessionDependency
from backend.session import get_session
from models import User
from schemas.deal import *
from services.auth import get_current_user
from services.deal import DealService

deal_router = APIRouter(
    prefix='/deal',
    tags=['deal'],
    dependencies=[Depends(get_current_user)]
)


# region Deal
@deal_router.post('/create')
async def create(
        request: DealCreateRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)]
):
    return await DealService(session).create(request, user)


@deal_router.post(
    '/delete',
    response_model=DealDeleteResponse,
    operation_id='deleteDeal'
)
async def delete(
        request: DealDeleteRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).delete(request)


@deal_router.post('/quickCreate', response_model=DealQuickCreateResponse)
async def quick_create(
        request: DealQuickCreateRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)]
):
    return await DealService(session).quick_create(request, user)


@deal_router.post('/changeStatus', response_model=DealChangeStatusResponse)
async def change_status(
        request: DealChangeStatusRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)]
):
    return await DealService(session).change_status_manual(request, user)


@deal_router.get('/summaries',
                 response_model=DealSummaryResponse,
                 operation_id='getDealSummaries'
                 )
async def get_summary(
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).get_summary()


@deal_router.post(
    '/summaries/reorder',
    response_model=DealSummaryResponse,
    operation_id='reorderDealSummaries'
)
async def reorder(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: DealSummaryReorderRequest,
        user: Annotated[User, Depends(get_current_user)]
):
    return await DealService(session).reorder(request, user)


@deal_router.get(
    '/get-all',
    response_model=DealGetAllResponse,
    operation_id='getAllDeals'
)
async def get_all(
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).get_all()


# endpoint to get deal by id
@deal_router.get(
    '/get/{deal_id}',
    response_model=DealSchema,
    operation_id='getDealById'
)
async def get_deal_by_id(
        deal_id: int,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).get_by_id(deal_id)


@deal_router.post(
    '/update-general-info',
    response_model=DealUpdateGeneralInfoResponse,
    operation_id='updateDealGeneralInfo'
)
async def update_general_info(
        request: DealUpdateGeneralInfoRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).update_general_info(request)

@deal_router.post(
    '/add-kit',
    response_model=DealAddKitResponse,
    operation_id='add_kit_to_deal'
)
async def add_kit_to_deal(
        session:SessionDependency,
        request:DealAddKitRequest
):
    return await DealService(session).add_kit_to_deal(request)
# endregion

# region Deal services

@deal_router.post(
    '/services/add/multiple',
    response_model=DealAddServicesResponse,
    operation_id='addMultipleDealServices'
)
async def services_add(
        request: DealAddServicesRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).add_services(request)


@deal_router.post(
    '/services/add',
    response_model=DealAddServiceResponse,
    operation_id='addDealService'
)
async def services_add(
        request: DealAddServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).add_service(request)


@deal_router.post(
    '/services/update-quantity',
    response_model=DealUpdateServiceQuantityResponse,
    operation_id='updateDealServiceQuantity'
)
async def services_update_quantity(
        request: DealUpdateServiceQuantityRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).update_service_quantity(request)


@deal_router.post(
    '/services/update',
    response_model=DealUpdateServiceResponse,
    operation_id='updateDealService'
)
async def services_update(
        request: DealUpdateServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).update_service(request)


@deal_router.post(
    '/services/delete',
    response_model=DealDeleteServiceResponse,
    operation_id='deleteDealService'
)
async def services_delete(
        request: DealDeleteServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).delete_service(request)


@deal_router.post(
    '/services/delete/multiple',
    response_model=DealDeleteServicesResponse,
    operation_id='deleteMultipleDealServices'
)
async def services_delete(
        request: DealDeleteServicesRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).delete_services(request)


@deal_router.post(
    '/services/copy',
    response_model=DealServicesCopyResponse,
    operation_id='copy_product_services'
)
async def services_copy(
        session: SessionDependency,
        request: DealServicesCopyRequest
):
    return await DealService(session).copy_services(request)


# endregion

# region Deal products
@deal_router.post(
    '/products/update-quantity',
    response_model=DealUpdateProductQuantityResponse,
    operation_id='updateDealProductQuantity')
async def products_update(
        request: DealUpdateProductQuantityRequest,
        session: Annotated[AsyncSession, Depends(get_session)]):
    return await DealService(session).update_product_quantity(request)


@deal_router.post(
    '/products/add',
    response_model=DealAddProductResponse,
    operation_id='addDealProduct')
async def products_add(
        request: DealAddProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)]):
    return await DealService(session).add_product(request)


@deal_router.post(
    '/products/delete',
    response_model=DealDeleteProductResponse,
    operation_id='deleteDealProduct')
async def products_delete(
        request: DealDeleteProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)]):
    return await DealService(session).delete_product(request)


@deal_router.post(
    '/products/delete/multiple',
    response_model=DealDeleteProductsResponse,
    operation_id='deleteMultipleDealProducts')
async def products_delete(
        request: DealDeleteProductsRequest,
        session: Annotated[AsyncSession, Depends(get_session)]):
    return await DealService(session).delete_products(request)


@deal_router.post(
    '/product/update',
    response_model=DealUpdateProductResponse,
    operation_id='updateDealProduct'
)
async def products_update(
        request: DealUpdateProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).update_product(request)


@deal_router.post(
    '/product/add-kit',
    response_model=DealProductAddKitResponse,
    operation_id='add_kit_to_deal_product'
)
async def add_kit_to_deal_product(
        session: SessionDependency,
        request: DealProductAddKitRequest
):
    return await DealService(session).add_kit_to_deal_product(request)
# endregion