import uuid
from fastapi import APIRouter, Depends, Query, Request, Body
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.database import get_db
from app.core.security import require_permission
from app.models.core_models import LoginUsers
from app.modules.dealer_portal_admin.schemas import DealerPortalAccessRequest, DealerPortalAccessResponse
from app.modules.dealer_portal_admin.service import update_dealer_portal_access
from app.modules.dealer_portal import schemas as dealer_schemas, service as dealer_service
from app.modules.yard import schemas as yard_schemas, service as yard_service

router = APIRouter()


@router.post("/dealer-access", response_model=DealerPortalAccessResponse)
async def manage_dealer_access(
    req: DealerPortalAccessRequest,
    request: Request,
    admin: LoginUsers = Depends(require_permission('DEALER_PORTAL_ADMIN', 'edit')),
    db: AsyncSession = Depends(get_db),
):
    return await update_dealer_portal_access(db, admin.user_id, req, request.client.host)


@router.get("/order-masters", response_model=dealer_schemas.OrderMastersOut)
async def get_order_masters(
    _=Depends(require_permission('DEALER_PORTAL_ADMIN', 'view')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.get_order_masters(db)


@router.get("/chassis-lookup", response_model=yard_schemas.ChassisLookupOut)
async def chassis_lookup(
    chassis_no: str = Query(..., min_length=1),
    _=Depends(require_permission('DEALER_PORTAL_ADMIN', 'view')),
    db: AsyncSession = Depends(get_db),
):
    return await yard_service.lookup_chassis(db, chassis_no)


@router.get("/dealers/{dealer_id}/clients", response_model=list[dealer_schemas.ClientOut])
async def list_dealer_clients(
    dealer_id: str,
    _=Depends(require_permission('DEALER_PORTAL_ADMIN', 'view')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.list_clients(db, dealer_id)


@router.get("/clients/search", response_model=list[dealer_schemas.ClientSearchResultWithDealer])
async def search_clients(
    q: str = "",
    _=Depends(require_permission('DEALER_PORTAL_ADMIN', 'view')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.search_clients_across_dealers(db, q)


@router.get("/clients/{client_id}", response_model=dealer_schemas.ClientOut)
async def get_client(
    client_id: str,
    _=Depends(require_permission('DEALER_PORTAL_ADMIN', 'view')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.get_client_for_staff(db, client_id)


@router.get("/orders", response_model=list[dealer_schemas.OrderListItem])
async def list_orders(
    status: str | None = None,
    client_id: str | None = None,
    dealer_id: str | None = None,
    _=Depends(require_permission('DEALER_PORTAL_ADMIN', 'view')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.list_orders_for_staff(db, status, client_id, dealer_id)


@router.get("/orders/{order_id}", response_model=dealer_schemas.OrderDetailOut)
async def get_order_detail(
    order_id: uuid.UUID,
    _=Depends(require_permission('DEALER_PORTAL_ADMIN', 'view')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.get_order_detail_for_staff(db, order_id)


@router.post("/orders/{order_id}/confirm", response_model=dealer_schemas.OrderDetailOut)
async def confirm_order(
    order_id: uuid.UUID,
    admin: LoginUsers = Depends(require_permission('DEALER_PORTAL_ADMIN', 'approve')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.confirm_order(db, admin.user_id, order_id)

@router.post("/orders/{order_id}/final-confirm", response_model=dealer_schemas.OrderDetailOut)
async def final_confirm_order(
    order_id: uuid.UUID,
    admin: LoginUsers = Depends(require_permission('DEALER_PORTAL_ADMIN', 'approve')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.final_confirm_order(db, admin.user_id, order_id)

@router.post("/orders/{order_id}/allocate", response_model=dealer_schemas.OrderDetailOut)
async def allocate_chassis(
    order_id: uuid.UUID,
    allocations: dict = Body(..., embed=True),
    admin: LoginUsers = Depends(require_permission('DEALER_PORTAL_ADMIN', 'approve')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.allocate_order_chassis(db, admin.user_id, order_id, allocations)

@router.post("/orders/{order_id}/remark", response_model=dealer_schemas.OrderDetailOut)
async def add_order_remark(
    order_id: uuid.UUID,
    remark: str = Body(..., embed=True),
    admin: LoginUsers = Depends(require_permission('DEALER_PORTAL_ADMIN', 'edit')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.add_order_remark(db, admin.user_id, order_id, remark)


@router.patch("/orders/{order_id}/billing-by", response_model=dealer_schemas.OrderDetailOut)
async def set_billing_by(
    order_id: uuid.UUID,
    billing_by: str = Body(..., embed=True),
    admin: LoginUsers = Depends(require_permission('DEALER_PORTAL_ADMIN', 'edit')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.set_billing_by(db, admin.user_id, order_id, billing_by)

@router.get("/dealers/{dealer_id}/chassis", response_model=dealer_schemas.DealerChassisListResponse)
async def get_dealer_chassis_for_staff(
    dealer_id: str,
    include_spares: bool = Query(False),
    client_id: str | None = Query(None),
    yard_only: bool = Query(False),
    _=Depends(require_permission('DEALER_PORTAL_ADMIN', 'view')),
    db: AsyncSession = Depends(get_db),
):
    return await dealer_service.get_dealer_chassis(db, dealer_id, include_spares=include_spares, client_id=client_id, yard_only=yard_only)