bakery-ia/services/external/app/api/traffic.py

# services/external/app/api/traffic.py
"""Traffic data API endpoints with improved error handling"""

from fastapi import APIRouter, Depends, HTTPException, Query, Path
from typing import List, Dict, Any
from datetime import datetime, timedelta
import structlog
from uuid import UUID
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.database import get_db
from app.services.traffic_service import TrafficService
from app.services.messaging import publish_traffic_updated
from app.schemas.traffic import (
    TrafficDataResponse,
    HistoricalTrafficRequest,
    TrafficForecastRequest
)

from shared.auth.decorators import (
    get_current_user_dep
)

router = APIRouter(tags=["traffic"])
traffic_service = TrafficService()
logger = structlog.get_logger()

@router.get("/tenants/{tenant_id}/traffic/current", response_model=TrafficDataResponse)
async def get_current_traffic(
    latitude: float = Query(..., description="Latitude"),
    longitude: float = Query(..., description="Longitude"),
    tenant_id: UUID = Path(..., description="Tenant ID"),
    current_user: Dict[str, Any] = Depends(get_current_user_dep),
):
    """Get current traffic data for location"""
    try:
        logger.debug("API: Getting current traffic", lat=latitude, lon=longitude)
        
        traffic = await traffic_service.get_current_traffic(latitude, longitude)
        
        if not traffic:
            logger.warning("No traffic data available", lat=latitude, lon=longitude)
            raise HTTPException(status_code=404, detail="Traffic data not available")
        
        # Publish event (with error handling)
        try:
            await publish_traffic_updated({
                "type": "current_requested",
                "latitude": latitude,
                "longitude": longitude,
                "timestamp": datetime.utcnow().isoformat()
            })
        except Exception as pub_error:
            logger.warning("Failed to publish traffic event", error=str(pub_error))
            # Continue processing - event publishing failure shouldn't break the API
        
        logger.debug("Successfully returning traffic data", 
                    volume=traffic.get('traffic_volume') if isinstance(traffic, dict) else getattr(traffic, 'traffic_volume', None),
                    congestion=traffic.get('congestion_level') if isinstance(traffic, dict) else getattr(traffic, 'congestion_level', None))
        return traffic
        
    except HTTPException:
        # Re-raise HTTP exceptions
        raise
    except Exception as e:
        logger.error("Unexpected error in traffic API", error=str(e))
        import traceback
        logger.error("Traffic API traceback", traceback=traceback.format_exc())
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.post("/tenants/{tenant_id}/traffic/historical")
async def get_historical_traffic(
    request: HistoricalTrafficRequest,
    db: AsyncSession = Depends(get_db),
    tenant_id: UUID = Path(..., description="Tenant ID"),
    current_user: Dict[str, Any] = Depends(get_current_user_dep),
):
    """Get historical traffic data with date range in payload"""
    try:
        # Validate date range
        if request.end_date <= request.start_date:
            raise HTTPException(status_code=400, detail="End date must be after start date")
        
        if (request.end_date - request.start_date).days > 1000:
            raise HTTPException(status_code=400, detail="Date range cannot exceed 90 days")
        
        historical_data = await traffic_service.get_historical_traffic(
            request.latitude, request.longitude, request.start_date, request.end_date, str(tenant_id)
        )
        
        # Publish event (with error handling)
        try:
            await publish_traffic_updated({
                "type": "historical_requested",
                "latitude": request.latitude,
                "longitude": request.longitude,
                "start_date": request.start_date.isoformat(),
                "end_date": request.end_date.isoformat(),
                "records_count": len(historical_data),
                "timestamp": datetime.utcnow().isoformat()
            })
        except Exception as pub_error:
            logger.warning("Failed to publish historical traffic event", error=str(pub_error))
            # Continue processing
        
        return historical_data
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error("Unexpected error in historical traffic API", error=str(e))
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

@router.post("/tenants/{tenant_id}/traffic/forecast")
async def get_traffic_forecast(
    request: TrafficForecastRequest,
    tenant_id: UUID = Path(..., description="Tenant ID"),
    current_user: Dict[str, Any] = Depends(get_current_user_dep),
):
    """Get traffic forecast for location"""
    try:
        logger.debug("API: Getting traffic forecast", 
                    lat=request.latitude, lon=request.longitude, hours=request.hours)
        
        # For now, return mock forecast data since we don't have a real traffic forecast service
        # In a real implementation, this would call a traffic forecasting service
        
        # Generate mock forecast data for the requested hours
        forecast_data = []
        from datetime import datetime, timedelta
        
        base_time = datetime.utcnow()
        for hour in range(request.hours):
            forecast_time = base_time + timedelta(hours=hour)
            
            # Mock traffic pattern (higher during rush hours)
            hour_of_day = forecast_time.hour
            if 7 <= hour_of_day <= 9 or 17 <= hour_of_day <= 19:  # Rush hours
                traffic_volume = 120
                pedestrian_count = 80
                congestion_level = "high"
                average_speed = 15
            elif 22 <= hour_of_day or hour_of_day <= 6:  # Night hours
                traffic_volume = 20
                pedestrian_count = 10
                congestion_level = "low"
                average_speed = 50
            else:  # Regular hours
                traffic_volume = 60
                pedestrian_count = 40
                congestion_level = "medium"
                average_speed = 35
            
            # Use consistent TrafficDataResponse format
            forecast_data.append({
                "date": forecast_time.isoformat(),
                "traffic_volume": traffic_volume,
                "pedestrian_count": pedestrian_count,
                "congestion_level": congestion_level,
                "average_speed": average_speed,
                "source": "madrid_opendata_forecast"
            })
        
        # Publish event (with error handling)
        try:
            await publish_traffic_updated({
                "type": "forecast_requested",
                "latitude": request.latitude,
                "longitude": request.longitude,
                "hours": request.hours,
                "timestamp": datetime.utcnow().isoformat()
            })
        except Exception as pub_error:
            logger.warning("Failed to publish traffic forecast event", error=str(pub_error))
            # Continue processing
        
        logger.debug("Successfully returning traffic forecast", records=len(forecast_data))
        return forecast_data
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error("Unexpected error in traffic forecast API", error=str(e))
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")