from typing import Optional
from uuid import UUID
import numpy as np
from sqlalchemy import Select, func, select
from sqlalchemy.orm import joinedload
from src.workorder.model import MasterWorkOrder
from src.scope_equipment.model import ScopeEquipment
from src.database.core import DbSession
from src.overhaul_scope.service import get_all
from .schema import CalculationTimeConstrainsParametersRead, CalculationTimeConstrainsParametersRetrive, CalculationTimeConstrainsParametersCreate
from .service import get_calculation_by_reference_and_parameter, get_calculation_result, get_overhaul_cost_by_time_chart, get_corrective_cost_time_chart, create_param_and_data, get_calculation_data_by_id, create_calculation_result_service, get_avg_cost_by_asset
from src.scope_equipment.service import get_by_assetnum


async def get_create_calculation_parameters(*, db_session: DbSession, calculation_id: str):
    if calculation_id is not None:
        calculation = get_calculation_data_by_id(calculation_id)

        if not calculation:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="A data with this id does not exist.",
            )

        return CalculationTimeConstrainsParametersRead(
            costPerFailure=calculation.parameter.avg_failure_cost,
            overhaulCost=calculation.parameter.overhaul_cost,
            reference=calculation
        )

    stmt = (
        select(
            ScopeEquipment.scope_id,
            func.avg(MasterWorkOrder.total_cost_max).label('average_cost')
        )
        .outerjoin(MasterWorkOrder, ScopeEquipment.assetnum == MasterWorkOrder.assetnum)
        .group_by(ScopeEquipment.scope_id)
        .order_by(ScopeEquipment.scope_id)
    )

    results = await db_session.execute(stmt)
    costFailure = results.all()
    scopes = await get_all(db_session=db_session)
    avaiableScopes = {scope.id: scope.scope_name for scope in scopes}
    costFailurePerScope = {avaiableScopes.get(
        costPerFailure[0]): costPerFailure[1] for costPerFailure in costFailure}

    return CalculationTimeConstrainsParametersRetrive(
        costPerFailure=costFailurePerScope,
        availableScopes=avaiableScopes.values(),
        recommendedScope="A",
        # historicalData={
        #     "averageOverhaulCost": 10000000,
        #     "lastCalculation": {
        #         "id": "calc_122",
        #         "date": "2024-10-15",
        #         "scope": "B",
        #     },
        # },
    )


async def create_calculation(*, db_session: DbSession, calculation_time_constrains_in: CalculationTimeConstrainsParametersCreate, created_by: str):
    calculation_data = await create_param_and_data(
        db_session=db_session, calculation_param_in=calculation_time_constrains_in, created_by=created_by)

    results = await create_calculation_result_service(db_session=db_session, calculation_id=calculation_data.id)

    return results


async def get_or_create_scope_equipment_calculation(*, db_session: DbSession, scope_calculation_id, calculation_time_constrains_in: Optional[CalculationTimeConstrainsParametersCreate]):
    scope_calculation = await get_calculation_data_by_id(db_session=db_session, calculation_id=scope_calculation_id)

    if not scope_calculation:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="A data with this id does not exist.",
        )

    # Check if calculation already exist
    scope_equipment_calculation = await get_calculation_by_reference_and_parameter(
        db_session=db_session, calculation_reference_id=calculation_time_constrains_in.assetnum, parameter_id=scope_calculation.parameter_id)

    if not scope_equipment_calculation:
        # Update Parameter input from scope calculation
        costFailure = await get_avg_cost_by_asset(
            db_session=db_session, assetnum=calculation_time_constrains_in.assetnum)

        calculation_time_constrains_in.costPerFailure = costFailure
        calculation_time_constrains_in.overhaulCost = scope_calculation.parameter.overhaul_cost

        scope_equipment_calculation = await create_param_and_data(
            db_session=db_session, calculation_param_in=calculation_time_constrains_in, created_by=scope_calculation.created_by, parameter_id=scope_calculation.parameter_id)

        results = await create_calculation_result_service(db_session=db_session, calculation_id=scope_equipment_calculation.id, costPerFailure=costFailure)

        return results

    results = await get_calculation_result(db_session=db_session, calculation_id=scope_equipment_calculation.id)

    return results