diagram_ph/app/api/v1/endpoints/properties.py

"""
Endpoints pour les calculs de proprietes thermodynamiques
"""

from fastapi import APIRouter, HTTPException, status

from app.models.properties import (
    PropertyCalculationRequest,
    PropertyCalculationResponse,
    SaturationRequest,
    SaturationResponse
)
from app.services.thermodynamics import get_thermodynamics_service


router = APIRouter()


@router.post(
    "/calculate",
    response_model=PropertyCalculationResponse,
    summary="Calculer les proprietes thermodynamiques",
    description="Calcule les proprietes thermodynamiques d'un refrigerant selon differents parametres d'entree"
)
async def calculate_properties(request: PropertyCalculationRequest):
    """
    Calcule les proprietes thermodynamiques d'un refrigerant.
    
    Types de calcul disponibles:
    - **px**: A partir de pression et qualite
    - **pT**: A partir de pression et temperature
    - **ph**: A partir de pression et enthalpie
    - **Tx**: A partir de temperature et qualite
    
    Args:
        request: Parametres du calcul
        
    Returns:
        PropertyCalculationResponse: Proprietes calculees
        
    Raises:
        400: Parametres invalides
        404: Refrigerant non trouve
        500: Erreur de calcul
    """
    try:
        service = get_thermodynamics_service()
        
        if request.calculation_type == "px":
            if request.pressure is None or request.quality is None:
                raise HTTPException(
                    status_code=status.HTTP_400_BAD_REQUEST,
                    detail="Pression et qualite requises pour le calcul px"
                )
            result = service.calculate_from_px(
                request.refrigerant,
                request.pressure,
                request.quality
            )
            
        elif request.calculation_type == "pT":
            if request.pressure is None or request.temperature is None:
                raise HTTPException(
                    status_code=status.HTTP_400_BAD_REQUEST,
                    detail="Pression et temperature requises pour le calcul pT"
                )
            result = service.calculate_from_pT(
                request.refrigerant,
                request.pressure,
                request.temperature
            )
            
        elif request.calculation_type == "ph":
            if request.pressure is None or request.enthalpy is None:
                raise HTTPException(
                    status_code=status.HTTP_400_BAD_REQUEST,
                    detail="Pression et enthalpie requises pour le calcul ph"
                )
            result = service.calculate_from_ph(
                request.refrigerant,
                request.pressure,
                request.enthalpy
            )
            
        elif request.calculation_type == "Tx":
            if request.temperature is None or request.quality is None:
                raise HTTPException(
                    status_code=status.HTTP_400_BAD_REQUEST,
                    detail="Temperature et qualite requises pour le calcul Tx"
                )
            result = service.calculate_from_Tx(
                request.refrigerant,
                request.temperature,
                request.quality
            )
            
        else:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail=f"Type de calcul invalide: {request.calculation_type}"
            )
        
        return result
        
    except HTTPException:
        raise
    except ValueError as e:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=str(e)
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Erreur lors du calcul des proprietes: {str(e)}"
        )


@router.post(
    "/saturation",
    response_model=SaturationResponse,
    summary="Proprietes de saturation",
    description="Obtient les proprietes de saturation (liquide et vapeur) a une pression donnee"
)
async def get_saturation_properties(request: SaturationRequest):
    """
    Obtient les proprietes de saturation d'un refrigerant.
    
    Retourne les proprietes du liquide sature et de la vapeur saturee
    a la pression specifiee, ainsi que la temperature de saturation
    et la chaleur latente de vaporisation.
    
    Args:
        request: Refrigerant et pression
        
    Returns:
        SaturationResponse: Proprietes de saturation
        
    Raises:
        404: Refrigerant non trouve
        500: Erreur de calcul
    """
    try:
        service = get_thermodynamics_service()
        result = service.get_saturation_properties(
            request.refrigerant,
            request.pressure
        )
        return result
        
    except ValueError as e:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=str(e)
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Erreur lors du calcul des proprietes de saturation: {str(e)}"
        )


@router.get(
    "/",
    summary="Information sur les endpoints de proprietes",
    description="Retourne la liste des endpoints disponibles pour les calculs de proprietes"
)
async def properties_info():
    """
    Retourne les informations sur les endpoints disponibles.
    
    Returns:
        dict: Liste des endpoints et leurs descriptions
    """
    return {
        "endpoints": [
            {
                "path": "/api/v1/properties/calculate",
                "method": "POST",
                "description": "Calcule les proprietes thermodynamiques",
                "calculation_types": [
                    {
                        "type": "px",
                        "description": "A partir de pression et qualite",
                        "required": ["pressure", "quality"]
                    },
                    {
                        "type": "pT",
                        "description": "A partir de pression et temperature",
                        "required": ["pressure", "temperature"]
                    },
                    {
                        "type": "ph",
                        "description": "A partir de pression et enthalpie",
                        "required": ["pressure", "enthalpy"]
                    },
                    {
                        "type": "Tx",
                        "description": "A partir de temperature et qualite",
                        "required": ["temperature", "quality"]
                    }
                ]
            },
            {
                "path": "/api/v1/properties/saturation",
                "method": "POST",
                "description": "Obtient les proprietes de saturation",
                "required": ["refrigerant", "pressure"]
            }
        ],
        "units": {
            "pressure": "Pa (Pascal)",
            "temperature": "K (Kelvin)",
            "enthalpy": "J/kg",
            "entropy": "J/kg.K",
            "density": "kg/m3",
            "quality": "0-1 (sans dimension)"
        },
        "example": {
            "refrigerant": "R134a",
            "calculation_type": "px",
            "pressure": 500000,
            "quality": 0.5
        }
    }