import asyncio
from typing import Dict, List, Optional
from temporalio.client import Client
from fastapi import APIRouter, HTTPException, status
from fastapi.params import Query

from src.calculation_target_reliability.utils import wait_for_workflow
from src.config import TEMPORAL_URL, TR_RBD_ID
from src.database.core import DbSession, CollectorDbSession
from src.auth.service import Token
from src.models import StandardResponse

from .service import  run_rbd_simulation, get_simulation_results, identify_worst_eaf_contributors
from .schema import OptimizationResult
router = APIRouter()


# @router.get("", response_model=StandardResponse[List[Dict]])
# async def get_target_reliability(
#     db_session: DbSession,
#     scope_name: Optional[str] = Query(None),
#     eaf_threshold: float = Query(100),
# ):
#     """Get all scope pagination."""
#     results = await get_all_target_reliability(
#         db_session=db_session, scope_name=scope_name, eaf_threshold=eaf_threshold
#     )

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


@router.get("", response_model=StandardResponse[OptimizationResult])
async def get_target_reliability(
    db_session: DbSession,
    token: Token,
    collector_db: CollectorDbSession,
    oh_session_id: Optional[str] = Query(None),
    eaf_input: float = Query(99.8),
    duration: int = Query(17520),
    simulation_id: Optional[str] = Query(None),
    cut_hours = Query(0)
):
    """Get all scope pagination."""
    if not oh_session_id:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="oh_session_id is required",
        )

    # results = await get_eaf_timeline(
    #     db_session=db_session,
    #     oh_session_id=oh_session_id,
    #     eaf_input=eaf_input,
    #     oh_duration=duration
    # )
    
    if duration != 17520:
        if not simulation_id:
            raise HTTPException(
                    status_code=status.HTTP_425_TOO_EARLY,  # or 409 Conflict
                    detail="Simulation still running. Please wait.",
            )
        else:
            temporal_client = await Client.connect(TEMPORAL_URL)
            handle = temporal_client.get_workflow_handle(f"simulation-{simulation_id}")
            desc = await handle.describe()
            status_name = desc.status.name

            if status_name in ["RUNNING", "CONTINUED_AS_NEW"]:
                raise HTTPException(
                    status_code=status.HTTP_425_TOO_EARLY,  # or 409 Conflict
                    detail="Simulation still running. Please wait.",
            )
    else:
        simulation_id = TR_RBD_ID
        

    results = await get_simulation_results(
        simulation_id=simulation_id,
        token=token
    )
    
    optimize_result = await identify_worst_eaf_contributors(
        simulation_result=results,
        target_eaf=eaf_input,
        db_session=db_session,
        oh_session_id=oh_session_id,
        collector_db=collector_db,
        simulation_id=simulation_id,
        duration=duration,
        po_duration=1200,
        cut_hours=float(cut_hours)
    )


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