from typing import List
from typing import Optional
from typing import Union

from fastapi import APIRouter
from fastapi.params import Query

from src.auth.service import CurrentUser, Token
from src.database.core import DbSession
from src.models import StandardResponse

from .flows import create_calculation
from .flows import get_create_calculation_parameters
from .flows import get_or_create_scope_equipment_calculation
from .schema import CalculationResultsRead
from .schema import CalculationSelectedEquipmentUpdate
from .schema import CalculationTimeConstrainsCreate
from .schema import CalculationTimeConstrainsParametersCreate
from .schema import CalculationTimeConstrainsParametersRead
from .schema import CalculationTimeConstrainsParametersRetrive
from .schema import CalculationTimeConstrainsRead
from .service import get_calculation_result
from .service import get_calculation_result_by_day
from .service import bulk_update_equipment

router = APIRouter()


@router.post("", response_model=StandardResponse[Union[str, CalculationTimeConstrainsRead]])
async def create_calculation_time_constrains(token:Token ,db_session: DbSession, current_user: CurrentUser, calculation_time_constrains_in: CalculationTimeConstrainsParametersCreate, scope_calculation_id: Optional[str] = Query(None), with_results: Optional[int] = Query(0)):
    """Save calculation time constrains Here"""

    if scope_calculation_id:
        results = await get_or_create_scope_equipment_calculation(db_session=db_session, scope_calculation_id=scope_calculation_id, calculation_time_constrains_in=calculation_time_constrains_in)
    else:
        results = await create_calculation(token=token ,db_session=db_session, calculation_time_constrains_in=calculation_time_constrains_in, created_by=current_user.name)


    if not with_results:
        results = str(results.id)

    return StandardResponse(data=results, message="Data created successfully")


@router.get("/parameters", response_model=StandardResponse[Union[CalculationTimeConstrainsParametersRetrive, CalculationTimeConstrainsParametersRead]])
async def get_calculation_parameters(db_session: DbSession, calculation_id: Optional[str] = Query(default=None)):
    """Get all calculation parameter."""

    parameters = await get_create_calculation_parameters(db_session=db_session, calculation_id=calculation_id)

    return StandardResponse(
        data=parameters,
        message="Data retrieved successfully",
    )


@router.get("/{calculation_id}", response_model=StandardResponse[CalculationTimeConstrainsRead])
async def get_calculation_results(db_session: DbSession, calculation_id):
    results = await get_calculation_result(db_session=db_session, calculation_id=calculation_id)

    return StandardResponse(
        data=results,
        message="Data retrieved successfully",
    )


@router.post("/{calculation_id}/simulation", response_model=StandardResponse[CalculationResultsRead])
async def get_simulation_result(db_session:DbSession, calculation_id, calculation_simuation_in: CalculationTimeConstrainsCreate):
    simulation_result = await get_calculation_result_by_day(db_session=db_session, calculation_id=calculation_id, simulation_day=calculation_simuation_in.intervalDays)

    return StandardResponse(data=simulation_result, message="Data retrieved successfully")

@router.put("/{calculation_id}", response_model=StandardResponse[List[str]])
async def update_selected_equipment(db_session: DbSession, calculation_id, calculation_time_constrains_in: List[CalculationSelectedEquipmentUpdate]):
    results = await bulk_update_equipment(db=db_session, selected_equipments=calculation_time_constrains_in, calculation_data_id=calculation_id)

    return StandardResponse(
        data=results,
        message="Data retrieved successfully",
    )