from src.overhaul_scope.schema import ScopeRead
from dataclasses import dataclass
from datetime import datetime
from typing import Any, Dict, List, Optional, Union
from uuid import UUID

from pydantic import Field

from src.models import DefultBase
from src.standard_scope.schema import MasterEquipmentBase


class CalculationTimeConstrainsBase(DefultBase):
    pass


class ReferenceLinkBase(DefultBase):
    reference_id: str = Field(..., description="Reference ID")
    overhaul_reference_type: str = Field(..., description="Overhaul reference type")


class CalculationTimeConstrainsParametersRetrive(CalculationTimeConstrainsBase):
    # type: ignore
    costPerFailure: Union[dict, float] = Field(..., description="Cost per failure")
    availableScopes: List[str] = Field(..., description="Available scopes")
    recommendedScope: str = Field(..., description="Recommended scope")
    # historicalData: Dict[str, Any] = Field(..., description="Historical data")


class CalculationTimeConstrainsParametersRead(CalculationTimeConstrainsBase):
    costPerFailure: Union[dict, float] = Field(..., description="Cost per failure")
    overhaulCost: Optional[float] = Field(None, description="Overhaul cost")
    reference: Optional[List[ReferenceLinkBase]] = Field(None, description="Reference")


class CalculationTimeConstrainsParametersCreate(CalculationTimeConstrainsBase):
    overhaulCost: Optional[float] = Field(0, description="Overhaul cost")
    ohSessionId: Optional[UUID] = Field(None, description="Scope OH")
    costPerFailure: Optional[float] = Field(0, description="Cost per failure")
    simulationRBDId: Optional[str] = Field(None, description="Simulation RBD ID")


# class CalculationTimeConstrainsCreate(CalculationTimeConstrainsBase):
#     overhaulCost: float = Field(..., description="Overhaul cost")
#     scopeOH: str = Field(..., description="Scope OH")
#     costPerFailure: float = Field(..., description="Cost per failure")
#     metadata: Dict[str, Any] = Field(..., description="Metadata")


class CalculationResultsRead(CalculationTimeConstrainsBase):
    overhaul_cost: float
    corrective_cost: float
    procurement_cost: float
    num_failures: float
    day: int
    month: int
    total_cost: float
    procurement_details: Dict
    sparepart_summary: dict




class OptimumResult(CalculationTimeConstrainsBase):
    overhaul_cost: float
    corrective_cost: float
    num_failures: int
    days: int


class EquipmentResult(CalculationTimeConstrainsBase):
    id: UUID
    corrective_costs: List[float]
    overhaul_costs: List[float]
    procurement_costs: List[float]
    daily_failures: List[float]
    is_actual: Optional[List[bool]] = None
    location_tag: str
    material_cost: float
    service_cost: float
    optimum_day: int  # Added optimum result for each equipment
    is_included: bool
    master_equipment: Optional[MasterEquipmentBase] = Field(None)

class FleetStatistics(CalculationTimeConstrainsBase):
    total_equipment: int
    included_equipment: int
    excluded_equipment: int
    equipment_with_sparepart_constraints: int
    total_procurement_items: int
    critical_procurement_items: int

class OptimalAnalysis(CalculationTimeConstrainsBase):
    optimal_month: int
    planned_month: Optional[int]
    timing_recommendation: str
    optimal_total_cost: float
    optimal_breakdown: Dict
    cost_trend: str
    months_from_planned: Optional[int]
    cost_savings_vs_planned: Optional[float]
    sparepart_impact: Dict

class AnalysisMetadata(CalculationTimeConstrainsBase):
    max_interval_months: int
    last_overhaul_date: Optional[str]
    next_planned_overhaul: str
    calculation_type: str
    total_equipment_analyzed: int
    included_in_optimization: int
    optimal_stat: Optional[dict]

class CalculationTimeConstrainsReadNoResult(CalculationTimeConstrainsBase):
    id: UUID
    created_at: datetime
    optimum_oh_day: Optional[int]
    max_interval: Optional[int]
    optimum_analysis: Optional[dict]
    session: ScopeRead
    # optimum_oh_day: int
    # max_interval: int
    # optimal_analysis: dict
    # analysis_metadata: dict

class CalculationTimeConstrainsRead(CalculationTimeConstrainsBase):
    id: UUID
    reference: UUID
    scope: str
    results: List[CalculationResultsRead]
    optimum_oh: int
    optimum_oh_month: int
    equipment_results: List[EquipmentResult]
    fleet_statistics: dict
    optimal_analysis: dict
    analysis_metadata: dict


class CalculationTimeConstrainsCreate(CalculationTimeConstrainsBase):
    intervalDays: int


class CalculationTimeConstrainsSimulationRead(CalculationTimeConstrainsBase):
    simulation: CalculationResultsRead


class CalculationSelectedEquipmentUpdate(CalculationTimeConstrainsBase):
    is_included: bool
    location_tag: str
    name:str

class CreateCalculationQuery(DefultBase):
    scope_calculation_id: Optional[str] = Field(None)
    with_results: Optional[int] = Field(0)
    simulation_id: Optional[UUID] = Field(None)