"""
Reasoning Types for JTBD Dashboard

Defines standard reasoning data structures for Purchase Orders and Production Batches.
Backend generates structured data, frontend translates using i18n.

IMPORTANT: All text displayed to users is translated in the frontend.
Backend only stores type codes and parameters.
"""

from enum import Enum
from typing import Dict, Any, Optional
from pydantic import BaseModel, Field


# ============================================================
# Reasoning Types
# ============================================================

class PurchaseOrderReasoningType(str, Enum):
    """Types of reasoning for why a purchase order was created"""
    LOW_STOCK_DETECTION = "low_stock_detection"
    FORECAST_DEMAND = "forecast_demand"
    SAFETY_STOCK_REPLENISHMENT = "safety_stock_replenishment"
    SUPPLIER_CONTRACT = "supplier_contract"
    SEASONAL_DEMAND = "seasonal_demand"
    PRODUCTION_REQUIREMENT = "production_requirement"
    MANUAL_REQUEST = "manual_request"


class ProductionBatchReasoningType(str, Enum):
    """Types of reasoning for why a production batch was created"""
    FORECAST_DEMAND = "forecast_demand"
    CUSTOMER_ORDER = "customer_order"
    STOCK_REPLENISHMENT = "stock_replenishment"
    SEASONAL_PREPARATION = "seasonal_preparation"
    PROMOTION_EVENT = "promotion_event"
    URGENT_ORDER = "urgent_order"
    REGULAR_SCHEDULE = "regular_schedule"


class ConsequenceSeverity(str, Enum):
    """Severity level of consequences if action is not taken"""
    CRITICAL = "critical"  # Immediate business impact
    HIGH = "high"          # Significant impact within 48h
    MEDIUM = "medium"      # Moderate impact within week
    LOW = "low"            # Minor impact


# ============================================================
# Reasoning Data Models
# ============================================================

class PurchaseOrderReasoningData(BaseModel):
    """
    Structured reasoning data for purchase orders

    Example:
    {
        "type": "low_stock_detection",
        "parameters": {
            "supplier_name": "Harinas del Norte",
            "product_names": ["Flour Type 55", "Flour Type 45"],
            "current_stock_kg": 45.5,
            "required_stock_kg": 200,
            "days_until_stockout": 3,
            "threshold_percentage": 20
        },
        "consequence": {
            "type": "stockout_risk",
            "severity": "high",
            "impact_days": 3,
            "affected_products": ["Baguette", "Croissant"],
            "estimated_lost_orders": 15
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "forecast_confidence": 0.85,
            "ai_assisted": true
        }
    }
    """
    type: PurchaseOrderReasoningType = Field(..., description="Type of reasoning")
    parameters: Dict[str, Any] = Field(..., description="Parameters for i18n interpolation")
    consequence: Optional[Dict[str, Any]] = Field(None, description="What happens if not approved")
    metadata: Optional[Dict[str, Any]] = Field(None, description="Additional context")


class ProductionBatchReasoningData(BaseModel):
    """
    Structured reasoning data for production batches

    Example:
    {
        "type": "forecast_demand",
        "parameters": {
            "product_name": "Croissant",
            "predicted_demand": 500,
            "current_stock": 120,
            "production_needed": 380,
            "target_date": "2025-11-08",
            "confidence_score": 0.87
        },
        "urgency": {
            "level": "normal",
            "ready_by_time": "08:00",
            "customer_commitment": false
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "forecast_id": "uuid-here",
            "ai_assisted": true
        }
    }
    """
    type: ProductionBatchReasoningType = Field(..., description="Type of reasoning")
    parameters: Dict[str, Any] = Field(..., description="Parameters for i18n interpolation")
    urgency: Optional[Dict[str, Any]] = Field(None, description="Urgency information")
    metadata: Optional[Dict[str, Any]] = Field(None, description="Additional context")


# ============================================================
# Helper Functions
# ============================================================

def create_po_reasoning_low_stock(
    supplier_name: str,
    product_names: list,
    current_stock: float,
    required_stock: float,
    days_until_stockout: int,
    threshold_percentage: int = 20,
    affected_products: Optional[list] = None,
    estimated_lost_orders: Optional[int] = None
) -> Dict[str, Any]:
    """
    Create reasoning data for low stock detection

    Args:
        supplier_name: Name of the supplier
        product_names: List of product names in the order
        current_stock: Current stock level
        required_stock: Required stock level
        days_until_stockout: Days until stock runs out
        threshold_percentage: Stock threshold percentage
        affected_products: Products that will be affected
        estimated_lost_orders: Estimated number of lost orders

    Returns:
        Reasoning data dictionary
    """
    return {
        "type": PurchaseOrderReasoningType.LOW_STOCK_DETECTION.value,
        "parameters": {
            "supplier_name": supplier_name,
            "product_names": product_names,
            "product_count": len(product_names),
            "current_stock": current_stock,
            "required_stock": required_stock,
            "days_until_stockout": days_until_stockout,
            "threshold_percentage": threshold_percentage,
            "stock_percentage": round((current_stock / required_stock * 100), 1) if required_stock > 0 else 0
        },
        "consequence": {
            "type": "stockout_risk",
            "severity": ConsequenceSeverity.HIGH.value if days_until_stockout <= 2 else ConsequenceSeverity.MEDIUM.value,
            "impact_days": days_until_stockout,
            "affected_products": affected_products or [],
            "estimated_lost_orders": estimated_lost_orders or 0
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "ai_assisted": True
        }
    }


def create_po_reasoning_forecast_demand(
    supplier_name: str,
    product_names: list,
    forecast_period_days: int,
    total_demand: float,
    forecast_confidence: float = 0.85
) -> Dict[str, Any]:
    """Create reasoning data for forecast-based demand"""
    return {
        "type": PurchaseOrderReasoningType.FORECAST_DEMAND.value,
        "parameters": {
            "supplier_name": supplier_name,
            "product_names": product_names,
            "product_count": len(product_names),
            "forecast_period_days": forecast_period_days,
            "total_demand": total_demand,
            "forecast_confidence": round(forecast_confidence * 100, 1)
        },
        "consequence": {
            "type": "insufficient_supply",
            "severity": ConsequenceSeverity.MEDIUM.value,
            "impact_days": forecast_period_days
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "forecast_confidence": forecast_confidence,
            "ai_assisted": True
        }
    }


def create_po_reasoning_supplier_contract(
    supplier_name: str,
    product_names: list,
    contract_terms: str = "monthly",
    contract_quantity: float = 0
) -> Dict[str, Any]:
    """Create reasoning data for supplier contract fulfillment"""
    return {
        "type": PurchaseOrderReasoningType.SUPPLIER_CONTRACT.value,
        "parameters": {
            "supplier_name": supplier_name,
            "product_names": product_names,
            "product_count": len(product_names),
            "contract_terms": contract_terms,
            "contract_quantity": contract_quantity
        },
        "consequence": {
            "type": "contract_breach",
            "severity": ConsequenceSeverity.HIGH.value,
            "impact": "contract_penalties"
        },
        "metadata": {
            "trigger_source": "contract_schedule",
            "ai_assisted": False
        }
    }


def create_po_reasoning_safety_stock(
    supplier_name: str,
    product_names: list,
    current_safety_stock: float,
    target_safety_stock: float,
    reorder_point: float
) -> Dict[str, Any]:
    """Create reasoning data for safety stock replenishment"""
    return {
        "type": PurchaseOrderReasoningType.SAFETY_STOCK_REPLENISHMENT.value,
        "parameters": {
            "supplier_name": supplier_name,
            "product_names": product_names,
            "product_count": len(product_names),
            "current_safety_stock": round(current_safety_stock, 1),
            "target_safety_stock": round(target_safety_stock, 1),
            "reorder_point": round(reorder_point, 1)
        },
        "consequence": {
            "type": "stockout_risk",
            "severity": ConsequenceSeverity.MEDIUM.value,
            "impact": "reduced_buffer"
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "ai_assisted": True
        }
    }


def create_po_reasoning_seasonal_demand(
    supplier_name: str,
    product_names: list,
    season: str,
    expected_demand_increase_pct: float
) -> Dict[str, Any]:
    """Create reasoning data for seasonal demand preparation"""
    return {
        "type": PurchaseOrderReasoningType.SEASONAL_DEMAND.value,
        "parameters": {
            "supplier_name": supplier_name,
            "product_names": product_names,
            "product_count": len(product_names),
            "season": season,
            "expected_demand_increase_pct": round(expected_demand_increase_pct, 1)
        },
        "consequence": {
            "type": "missed_opportunity",
            "severity": ConsequenceSeverity.MEDIUM.value,
            "impact": "lost_seasonal_sales"
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "ai_assisted": True
        }
    }


def create_po_reasoning_production_requirement(
    supplier_name: str,
    product_names: list,
    production_batches: int,
    required_by_date: str
) -> Dict[str, Any]:
    """Create reasoning data for production requirement"""
    return {
        "type": PurchaseOrderReasoningType.PRODUCTION_REQUIREMENT.value,
        "parameters": {
            "supplier_name": supplier_name,
            "product_names": product_names,
            "product_count": len(product_names),
            "production_batches": production_batches,
            "required_by_date": required_by_date
        },
        "consequence": {
            "type": "production_delay",
            "severity": ConsequenceSeverity.HIGH.value,
            "impact": "blocked_production"
        },
        "metadata": {
            "trigger_source": "production_schedule",
            "ai_assisted": True
        }
    }


def create_po_reasoning_manual_request(
    supplier_name: str,
    product_names: list,
    requested_by: str,
    reason: str = "manual_order"
) -> Dict[str, Any]:
    """Create reasoning data for manual purchase request"""
    return {
        "type": PurchaseOrderReasoningType.MANUAL_REQUEST.value,
        "parameters": {
            "supplier_name": supplier_name,
            "product_names": product_names,
            "product_count": len(product_names),
            "requested_by": requested_by,
            "reason": reason
        },
        "consequence": None,
        "metadata": {
            "trigger_source": "manual",
            "ai_assisted": False
        }
    }



def create_batch_reasoning_forecast_demand(
    product_name: str,
    predicted_demand: float,
    current_stock: float,
    production_needed: float,
    target_date: str,
    confidence_score: float = 0.85
) -> Dict[str, Any]:
    """Create reasoning data for forecast-based production"""
    return {
        "type": ProductionBatchReasoningType.FORECAST_DEMAND.value,
        "parameters": {
            "product_name": product_name,
            "predicted_demand": round(predicted_demand, 1),
            "current_stock": round(current_stock, 1),
            "production_needed": round(production_needed, 1),
            "target_date": target_date,
            "confidence_score": round(confidence_score * 100, 1)
        },
        "urgency": {
            "level": "normal",
            "ready_by_time": "08:00",
            "customer_commitment": False
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "confidence_score": confidence_score,
            "ai_assisted": True
        }
    }


def create_batch_reasoning_customer_order(
    product_name: str,
    customer_name: str,
    order_quantity: float,
    delivery_date: str,
    order_number: str
) -> Dict[str, Any]:
    """Create reasoning data for customer order fulfillment"""
    return {
        "type": ProductionBatchReasoningType.CUSTOMER_ORDER.value,
        "parameters": {
            "product_name": product_name,
            "customer_name": customer_name,
            "order_quantity": round(order_quantity, 1),
            "delivery_date": delivery_date,
            "order_number": order_number
        },
        "urgency": {
            "level": "high",
            "ready_by_time": "07:00",
            "customer_commitment": True
        },
        "metadata": {
            "trigger_source": "customer_order",
            "ai_assisted": False
        }
    }


def create_batch_reasoning_regular_schedule(
    product_name: str,
    scheduled_quantity: float,
    production_schedule: str = "daily"
) -> Dict[str, Any]:
    """Create reasoning data for regular scheduled production"""
    return {
        "type": ProductionBatchReasoningType.REGULAR_SCHEDULE.value,
        "parameters": {
            "product_name": product_name,
            "scheduled_quantity": round(scheduled_quantity, 1),
            "production_schedule": production_schedule
        },
        "urgency": {
            "level": "normal",
            "ready_by_time": "08:00",
            "customer_commitment": False
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "ai_assisted": False
        }
    }


def create_batch_reasoning_stock_replenishment(
    product_name: str,
    current_stock: float,
    minimum_stock: float,
    replenishment_quantity: float
) -> Dict[str, Any]:
    """Create reasoning data for stock replenishment production"""
    return {
        "type": ProductionBatchReasoningType.STOCK_REPLENISHMENT.value,
        "parameters": {
            "product_name": product_name,
            "current_stock": round(current_stock, 1),
            "minimum_stock": round(minimum_stock, 1),
            "replenishment_quantity": round(replenishment_quantity, 1)
        },
        "urgency": {
            "level": "medium",
            "ready_by_time": "07:30",
            "customer_commitment": False
        },
        "metadata": {
            "trigger_source": "inventory_alert",
            "ai_assisted": True
        }
    }


def create_batch_reasoning_seasonal_preparation(
    product_name: str,
    season: str,
    expected_demand: float,
    preparation_quantity: float
) -> Dict[str, Any]:
    """Create reasoning data for seasonal preparation production"""
    return {
        "type": ProductionBatchReasoningType.SEASONAL_PREPARATION.value,
        "parameters": {
            "product_name": product_name,
            "season": season,
            "expected_demand": round(expected_demand, 1),
            "preparation_quantity": round(preparation_quantity, 1)
        },
        "urgency": {
            "level": "normal",
            "ready_by_time": "08:00",
            "customer_commitment": False
        },
        "metadata": {
            "trigger_source": "orchestrator_auto",
            "ai_assisted": True
        }
    }


def create_batch_reasoning_promotion_event(
    product_name: str,
    event_name: str,
    event_date: str,
    promotional_quantity: float
) -> Dict[str, Any]:
    """Create reasoning data for promotional event production"""
    return {
        "type": ProductionBatchReasoningType.PROMOTION_EVENT.value,
        "parameters": {
            "product_name": product_name,
            "event_name": event_name,
            "event_date": event_date,
            "promotional_quantity": round(promotional_quantity, 1)
        },
        "urgency": {
            "level": "high",
            "ready_by_time": "06:00",
            "customer_commitment": True
        },
        "metadata": {
            "trigger_source": "manual",
            "ai_assisted": False
        }
    }


def create_batch_reasoning_urgent_order(
    product_name: str,
    customer_name: str,
    urgent_quantity: float,
    required_by_time: str,
    reason: str = "urgent_request"
) -> Dict[str, Any]:
    """Create reasoning data for urgent order production"""
    return {
        "type": ProductionBatchReasoningType.URGENT_ORDER.value,
        "parameters": {
            "product_name": product_name,
            "customer_name": customer_name,
            "urgent_quantity": round(urgent_quantity, 1),
            "required_by_time": required_by_time,
            "reason": reason
        },
        "urgency": {
            "level": "urgent",
            "ready_by_time": required_by_time,
            "customer_commitment": True
        },
        "metadata": {
            "trigger_source": "urgent_order",
            "ai_assisted": False
        }
    }

