app/application/mappers/forecast_mapper.py

"""
Mapper para casos de uso de Forecasting.

Convierte entre API schemas (Pydantic) y DTOs de aplicación.
"""

from typing import Dict, Any
from app.schemas.requests.forecast import (
    ForecastUnivariateRequest,
    ForecastMultiSeriesRequest,
    SeriesData
)
from app.schemas.responses.forecast import (
    ForecastUnivariateResponse,
    ForecastMultiSeriesResponse
)
from app.application.dtos.forecast_dtos import (
    ForecastInputDTO,
    ForecastOutputDTO,
    MultiForecastInputDTO,
    MultiForecastOutputDTO,
    SeriesInputDTO
)


class ForecastMapper:
    """
    Mapper para convertir entre API schemas y DTOs de forecasting.
    """
    
    @staticmethod
    def to_univariate_input_dto(
        request: ForecastUnivariateRequest
    ) -> ForecastInputDTO:
        """
        Convierte API request a DTO de entrada.
        
        Args:
            request: Request de la API
        
        Returns:
            ForecastInputDTO: DTO para el caso de uso
        """
        return ForecastInputDTO(
            values=request.series.values,
            prediction_length=request.prediction_length,
            quantile_levels=request.quantile_levels,
            timestamps=request.series.timestamps,
            series_id=getattr(request.series, 'series_id', 'series_0'),
            freq=request.freq
        )
    
    @staticmethod
    def from_univariate_output_dto(
        dto: ForecastOutputDTO
    ) -> ForecastUnivariateResponse:
        """
        Convierte DTO de salida a API response.
        
        Args:
            dto: DTO del caso de uso
        
        Returns:
            ForecastUnivariateResponse: Response para la API
        """
        return ForecastUnivariateResponse(
            timestamps=dto.timestamps,
            median=dto.median,
            quantiles=dto.quantiles,
            series_id=dto.series_id,
            metadata=dto.metadata
        )
    
    @staticmethod
    def to_multi_series_input_dto(
        request: ForecastMultiSeriesRequest
    ) -> MultiForecastInputDTO:
        """
        Convierte API request multi-series a DTO de entrada.
        
        Args:
            request: Request de la API
        
        Returns:
            MultiForecastInputDTO: DTO para el caso de uso
        """
        series_list = []
        for series_data in request.series_list:
            series_dto = SeriesInputDTO(
                series_id=series_data.series_id,
                values=series_data.values,
                timestamps=series_data.timestamps
            )
            series_list.append(series_dto)
        
        return MultiForecastInputDTO(
            series_list=series_list,
            prediction_length=request.prediction_length,
            quantile_levels=request.quantile_levels,
            freq=request.freq
        )
    
    @staticmethod
    def from_multi_series_output_dto(
        dto: MultiForecastOutputDTO
    ) -> ForecastMultiSeriesResponse:
        """
        Convierte DTO de salida multi-series a API response.
        
        Args:
            dto: DTO del caso de uso
        
        Returns:
            ForecastMultiSeriesResponse: Response para la API
        """
        # Convertir cada resultado individual
        results = [
            ForecastMapper.from_univariate_output_dto(result)
            for result in dto.results
        ]
        
        return ForecastMultiSeriesResponse(
            results=results,
            total_series=dto.total_series,
            successful=dto.successful,
            failed=dto.failed
        )