from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from sqlalchemy.orm import selectinload

from app.core.database import get_db
from app.core.security import get_current_user
from app.models.core_models import LoginUsers
from app.models.yard_models import ChassisMaster
from app.models.dealer_models import DealerOrderVehicle, DealerOrder, DealerOrderVehicleFeature, SpecialFeatureMaster, SpecialFeatureOptionMaster
from app.modules.procurement.bulk_engine_schemas import BulkEngineRunRequest, BulkSimulateRequest
from app.modules.procurement.bulk_engine_service import BulkProcurementEngineService

router = APIRouter(prefix="/bulk-engine", tags=["Procurement Bulk Engine"])

@router.get("/pending-chassis")
async def get_pending_chassis(db: AsyncSession = Depends(get_db)):
    """Returns all chassis in PROCUREMENT_PENDING status to be shown in the UI grid."""
    stmt = (
        select(ChassisMaster)
        .where(ChassisMaster.procurement_status == 'PROCUREMENT_PENDING')
        .options(
            selectinload(ChassisMaster.dealer_order_vehicle).selectinload(DealerOrderVehicle.model),
            selectinload(ChassisMaster.dealer_order_vehicle).selectinload(DealerOrderVehicle.body_type),
            selectinload(ChassisMaster.dealer_order_vehicle).selectinload(DealerOrderVehicle.segment),
            selectinload(ChassisMaster.dealer_order_vehicle).selectinload(DealerOrderVehicle.order).selectinload(DealerOrder.dealer),
            selectinload(ChassisMaster.dealer_order_vehicle).selectinload(DealerOrderVehicle.features).selectinload(DealerOrderVehicleFeature.feature_master),
            selectinload(ChassisMaster.dealer_order_vehicle).selectinload(DealerOrderVehicle.features).selectinload(DealerOrderVehicleFeature.option)
        )
    )
    res = await db.execute(stmt)
    return res.scalars().all()

@router.post("/simulate")
async def simulate_bulk_engine(
    request: BulkSimulateRequest,
    db: AsyncSession = Depends(get_db),
    _=Depends(get_current_user)
):
    """Simulate BOM check against available stock for multiple chassis."""
    service = BulkProcurementEngineService(db)
    return await service.simulate_bulk_check(request.chassis_ids)

@router.post("/run")
async def bulk_run_procurement_engine(
    request: BulkEngineRunRequest,
    db: AsyncSession = Depends(get_db),
    current_user: LoginUsers = Depends(get_current_user)
):
    """
    Executes the massive atomic transaction:
    - Calculates BOM for all chassis
    - Reserves available stock
    - Saves ChassisBomSnapshot with reserved_qty
    - Applies buffer to shortages
    - Creates RmPurchaseRequest (Indents) per vendor
    """
    service = BulkProcurementEngineService(db)
    try:
        result = await service.run_bulk_engine(request, current_user.user_id)
        await db.commit()
        return result
    except HTTPException:
        await db.rollback()
        raise
    except Exception as e:
        await db.rollback()
        raise HTTPException(500, f"Bulk Engine Error: {str(e)}")