Update api.py

api.py

@@ -1,392 +1,506 @@
 """
-Cyclone Prediction & Resource Optimization API
-Optimized for HuggingFace Spaces Deployment
+Disaster Risk Prediction & Resource Allocation API
+===================================================
+FastAPI backend exposing:
+
+Prediction Endpoints:
+  POST /predict/flood          → lane-level or zone-level flood risk
+  POST /predict/cyclone        → cyclone impact risk
+  POST /predict/landslide      → landslide susceptibility
+  POST /predict/earthquake     → earthquake structural risk
+  POST /predict/all            → multi-hazard composite score
+
+Flood Map Endpoints:
+  POST /map/flood/features     → GeoJSON risk map from explicit feature input
+  POST /map/flood/osm          → GeoJSON risk map auto-fetched from OpenStreetMap
+  POST /map/flood/geojson      → GeoJSON risk map from uploaded road GeoJSON
+
+Allocation Endpoints:
+  POST /allocate/auto          → Hungarian-optimal auto allocation
+  POST /allocate/manual        → Manual team → task assignment
+  POST /allocate/reset         → Reset all allocations
+  GET  /allocate/summary       → Current allocation state
+
+Team & Task Management:
+  POST /teams                  → Register a team
+  GET  /teams                  → List all teams
+  POST /tasks                  → Register a task
+  GET  /tasks                  → List all tasks
+
+Utilities:
+  GET  /health                 → Health check + model status
+  GET  /features/{disaster}    → Feature schema for a disaster type
+  POST /predict/flood/explain  → Fuzzy membership interpretation
 """
 
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import RedirectResponse, JSONResponse
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
+from typing import Dict, List, Optional, Tuple, Any
 import os
-import sys
-from typing import Optional, Dict, List
-from datetime import datetime
 
-# Error handling for imports
-try:
-    import pickle
-    import numpy as np
-    import pandas as pd
-except ImportError as e:
-    print(f"Warning: Failed to import dependencies: {e}")
-
-# Check if we're in HuggingFace Spaces
-IS_HUGGINGFACE = os.environ.get('SPACE_ID') is not None
-
-# Add src to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+from src.disaster_predictors import (
+    FloodPredictor, CyclonePredictor, LandslidePredictor, EarthquakePredictor,
+    MultiHazardPredictor, FEATURE_SCHEMAS, PredictionResult, RiskTier
+)
+from src.lane_flood_mapper import LaneFloodMapper
+from src.allocation import (
+    AllocationEngine, FieldTeam, Task, TaskStatus,
+    TEAMS, TASKS, ALLOCATIONS,
+    get_allocation_summary, reset_all_allocations, initialize_default_teams
+)
 
 # ============================================================================
-# INITIALIZE APP
+# APP SETUP
 # ============================================================================
 
 app = FastAPI(
-    title="Cyclone Prediction & Resource Optimization API",
-    description="ML-based cyclone prediction with real-time IMD data",
-    version="4.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc"
+    title="Disaster Risk Prediction & Resource Allocation API",
+    description="FNN-based multi-hazard risk prediction with lane-level flood mapping and optimal resource allocation",
+    version="2.0.0"
 )
 
-# ============================================================================
-# GLOBAL VARIABLES
-# ============================================================================
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-model = None
-districts_df = None
-imd_fetcher = None
-feature_engineer = None
-
-FEATURE_NAMES = [
-    'LAT', 'LON', 'MAX_WIND', 'MIN_PRESSURE', 'RAD_NE', 'RAD_SE', 'RAD_SW', 'RAD_NW',
-    'RAD50_NE', 'RAD50_SE', 'RAD50_SW', 'RAD50_NW', 'RAD64_NE', 'RAD64_SE', 'RAD64_SW', 
-    'RAD64_NW', 'MONTH', 'HOUR', 'DAY_OF_YEAR', 'SIN_DOY', 'COS_DOY', 'SIN_HOUR', 
-    'COS_HOUR', 'STORM_AGE_HOURS', 'STORM_DURATION_HOURS', 'DIST_TO_ODISHA_KM', 
-    'MOVEMENT_SPEED_KPH', 'WIND_t-6', 'WIND_t-12', 'WIND_t-18', 'WIND_t-24', 
-    'PRESSURE_t-6', 'PRESSURE_t-12', 'PRESSURE_t-18', 'PRESSURE_t-24', 'WIND_CHANGE_6H', 
-    'PRESSURE_CHANGE_6H', 'INTENSIFICATION_RATE', 'WIND_CHANGE_12H', 'PRESSURE_CHANGE_12H', 
-    'STORM_DB', 'STORM_EX', 'STORM_MD', 'STORM_TC', 'STORM_TD', 'STORM_TS', 'STORM_TY', 
-    'STORM_WV', 'AVG_RAD34', 'AVG_RAD50', 'AVG_RAD64', 'STORM_SIZE'
-]
+MODEL_DIR = os.getenv("MODEL_DIR", "models")
 
 # ============================================================================
-# INITIALIZATION
+# MODEL SINGLETONS (loaded once at startup)
 # ============================================================================
 
-@app.on_event("startup")
-async def startup_event():
-    """Initialize the application on startup"""
-    global model, districts_df, imd_fetcher, feature_engineer
-    
-    print("=" * 60)
-    print("🚀 Initializing Cyclone Prediction API")
-    print("=" * 60)
-    
-    # Load model
-    model_path = os.path.join("models", "xgboost_cyclone_model.pkl")
-    if os.path.exists(model_path):
-        try:
-            with open(model_path, 'rb') as f:
-                model = pickle.load(f)
-            print(f"✅ Model loaded from {model_path}")
-        except Exception as e:
-            print(f"❌ Error loading model: {e}")
-            model = None
-    else:
-        print(f"⚠️  Model file not found at {model_path}")
-        model = None
-    
-    # Load districts data
-    districts_path = os.path.join("src", "data", "districts_master.csv")
-    if os.path.exists(districts_path):
-        try:
-            districts_df = pd.read_csv(districts_path)
-            print(f"✅ Loaded {len(districts_df)} districts")
-        except Exception as e:
-            print(f"❌ Error loading districts: {e}")
-            districts_df = None
-    else:
-        print(f"⚠️  Districts file not found at {districts_path}")
-        districts_df = None
-    
-    # Initialize fetchers
-    try:
-        from live_data_fetcher import IMDCycloneDataFetcher, CycloneFeatureEngineer
-        imd_fetcher = IMDCycloneDataFetcher()
-        feature_engineer = CycloneFeatureEngineer()
-        print("✅ IMD fetchers initialized")
-    except ImportError as e:
-        print(f"⚠️  Could not import fetchers: {e}")
-        imd_fetcher = None
-        feature_engineer = None
-    
-    print("=" * 60)
-    print(f"Model loaded: {model is not None}")
-    print(f"Districts loaded: {districts_df is not None}")
-    print(f"Fetchers ready: {imd_fetcher is not None}")
-    print("=" * 60)
+flood_predictor      = FloodPredictor(MODEL_DIR)
+cyclone_predictor    = CyclonePredictor(MODEL_DIR)
+landslide_predictor  = LandslidePredictor(MODEL_DIR)
+earthquake_predictor = EarthquakePredictor(MODEL_DIR)
+multi_hazard         = MultiHazardPredictor(MODEL_DIR)
+lane_mapper          = LaneFloodMapper(flood_predictor)
 
 # ============================================================================
-# PYDANTIC MODELS
+# REQUEST / RESPONSE SCHEMAS
 # ============================================================================
 
-class SimpleCycloneInput(BaseModel):
-    LAT: float = Field(..., description="Latitude", example=15.5)
-    LON: float = Field(..., description="Longitude", example=85.3)
-    MAX_WIND: Optional[float] = Field(65, description="Current max wind speed (knots)")
-    MIN_PRESSURE: Optional[float] = Field(990, description="Current min pressure (hPa)")
-    STORM_TYPE: Optional[str] = Field("TS", description="Storm type")
-
-class PredictionResponse(BaseModel):
-    predicted_intensity: float
-    predicted_intensity_kmh: float
-    intensity_category: str
-    status: str
-    data_source: str
-    current_parameters: Optional[Dict] = None
-    distance_to_odisha_km: Optional[float] = None
+class PredictionRequest(BaseModel):
+    features: Dict[str, float] = Field(
+        ...,
+        description="Feature values. Get schema from GET /features/{disaster_type}"
+    )
+    n_mc_samples: int = Field(
+        default=50,
+        ge=10, le=200,
+        description="Monte Carlo dropout samples for uncertainty estimation"
+    )
+
+
+class MultiHazardRequest(BaseModel):
+    features_by_type: Dict[str, Dict[str, float]] = Field(
+        ...,
+        description='{"flood": {...}, "cyclone": {...}, ...}'
+    )
+    weights: Optional[Dict[str, float]] = Field(
+        default=None,
+        description="Custom disaster weights, e.g. {'flood': 0.5, 'cyclone': 0.3, ...}"
+    )
+    n_mc_samples: int = 30
+
+
+class LaneFeaturesRequest(BaseModel):
+    segments: List[Dict[str, Any]] = Field(
+        ...,
+        description="""List of segments, each containing:
+          segment_id (str), road_name (str, optional),
+          road_type (str, optional), coordinates [[lat,lon],...],
+          features: {flood feature dict}"""
+    )
+
+
+class OSMMapRequest(BaseModel):
+    bbox: Tuple[float, float, float, float] = Field(
+        ...,
+        description="Bounding box (south, west, north, east)"
+    )
+    base_features: Dict[str, float] = Field(
+        ...,
+        description="Zone-level flood features applied to all road segments"
+    )
+    segment_overrides: Optional[List[Dict]] = Field(
+        default=None,
+        description="Per-segment feature overrides: [{segment_id, features}]"
+    )
+
+
+class GeoJSONMapRequest(BaseModel):
+    geojson: Dict = Field(..., description="GeoJSON FeatureCollection of road segments")
+    feature_mapping: Dict[str, str] = Field(
+        ...,
+        description='{"flood_feature_name": "geojson_property_name"}'
+    )
+
+
+class AutoAllocateRequest(BaseModel):
+    strategy: str = Field(
+        default="balanced",
+        description="priority_based | proximity_based | balanced"
+    )
+    optimize_routes: bool = True
+    priority_weight: float = Field(
+        default=0.5, ge=0.0, le=1.0,
+        description="Weight of priority vs proximity in 'balanced' strategy"
+    )
+
+
+class ManualAllocateRequest(BaseModel):
+    team_assignments: Dict[str, List[str]] = Field(
+        ...,
+        description="{team_id: [task_id, ...]}"
+    )
+    optimize_routes: bool = True
+    respect_capacity: bool = True
+
+
+def prediction_result_to_dict(result: PredictionResult) -> dict:
+    return {
+        "risk_score": result.risk_score,
+        "risk_tier": result.risk_tier.value,
+        "uncertainty": result.uncertainty,
+        "confidence_interval": {
+            "lower": result.confidence_interval[0],
+            "upper": result.confidence_interval[1]
+        },
+        "feature_memberships": result.feature_memberships,
+    }
+
 
 # ============================================================================
-# HELPER FUNCTIONS
+# HEALTH & METADATA
 # ============================================================================
 
-def build_model_input(engineered_features: dict):
-    """Build properly formatted DataFrame for model prediction"""
-    safe_features = {}
-    for feat in FEATURE_NAMES:
-        value = engineered_features.get(feat)
-        if value is None or (isinstance(value, float) and np.isnan(value)):
-            safe_features[feat] = 0.0
-        else:
-            safe_features[feat] = value
-    
-    return pd.DataFrame([[safe_features[f] for f in FEATURE_NAMES]],
-                       columns=FEATURE_NAMES)
-
-def get_intensity_category(wind_speed_knots):
-    """Categorize cyclone intensity"""
-    if wind_speed_knots < 34:
-        return "Tropical Depression"
-    elif wind_speed_knots < 64:
-        return "Tropical Storm"
-    elif wind_speed_knots < 83:
-        return "Category 1 Cyclone"
-    elif wind_speed_knots < 96:
-        return "Category 2 Cyclone"
-    elif wind_speed_knots < 113:
-        return "Category 3 Cyclone (Major)"
-    elif wind_speed_knots < 137:
-        return "Category 4 Cyclone (Major)"
-    else:
-        return "Category 5 Cyclone (Catastrophic)"
+@app.get("/health")
+def health():
+    return {
+        "status": "ok",
+        "models": {
+            "flood":      flood_predictor.is_ready(),
+            "cyclone":    cyclone_predictor.is_ready(),
+            "landslide":  landslide_predictor.is_ready(),
+            "earthquake": earthquake_predictor.is_ready(),
+        },
+        "model_architecture": "Fuzzy Neural Network (ANFIS-style)",
+        "allocation_algorithm": "Hungarian + 2-opt route optimization",
+    }
+
+
+@app.get("/features/{disaster_type}")
+def get_feature_schema(disaster_type: str):
+    if disaster_type not in FEATURE_SCHEMAS:
+        raise HTTPException(404, f"Unknown disaster type: {disaster_type}. Valid: {list(FEATURE_SCHEMAS)}")
+    return {
+        "disaster_type": disaster_type,
+        "features": FEATURE_SCHEMAS[disaster_type],
+        "count": len(FEATURE_SCHEMAS[disaster_type]),
+    }
+
 
 # ============================================================================
-# API ENDPOINTS
+# PREDICTION ENDPOINTS
 # ============================================================================
 
-@app.get("/")
-async def root():
-    """Redirect to docs"""
-    return RedirectResponse(url="/docs")
+@app.post("/predict/flood")
+def predict_flood(req: PredictionRequest):
+    errors = flood_predictor.validate_input(req.features)
+    if errors:
+        raise HTTPException(422, {"validation_errors": errors})
+    result = flood_predictor.predict(req.features, req.n_mc_samples)
+    return {"disaster_type": "flood", **prediction_result_to_dict(result)}
+
+
+@app.post("/predict/cyclone")
+def predict_cyclone(req: PredictionRequest):
+    errors = cyclone_predictor.validate_input(req.features)
+    if errors:
+        raise HTTPException(422, {"validation_errors": errors})
+    result = cyclone_predictor.predict(req.features, req.n_mc_samples)
+    return {"disaster_type": "cyclone", **prediction_result_to_dict(result)}
+
+
+@app.post("/predict/landslide")
+def predict_landslide(req: PredictionRequest):
+    errors = landslide_predictor.validate_input(req.features)
+    if errors:
+        raise HTTPException(422, {"validation_errors": errors})
+    result = landslide_predictor.predict(req.features, req.n_mc_samples)
+    return {"disaster_type": "landslide", **prediction_result_to_dict(result)}
+
+
+@app.post("/predict/earthquake")
+def predict_earthquake(req: PredictionRequest):
+    errors = earthquake_predictor.validate_input(req.features)
+    if errors:
+        raise HTTPException(422, {"validation_errors": errors})
+    result = earthquake_predictor.predict(req.features, req.n_mc_samples)
+    return {"disaster_type": "earthquake", **prediction_result_to_dict(result)}
+
+
+@app.post("/predict/all")
+def predict_all(req: MultiHazardRequest):
+    result = multi_hazard.predict_all(req.features_by_type, req.weights)
+
+    # Serialize PredictionResult objects
+    by_disaster_serialized = {}
+    for dt, pred_result in result["by_disaster"].items():
+        by_disaster_serialized[dt] = prediction_result_to_dict(pred_result)
 
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
     return {
-        "status": "healthy",
-        "model_loaded": model is not None,
-        "districts_loaded": districts_df is not None,
-        "fetchers_ready": imd_fetcher is not None and feature_engineer is not None,
-        "timestamp": datetime.now().isoformat(),
-        "environment": "HuggingFace Spaces" if IS_HUGGINGFACE else "Local"
+        "composite_risk_score": result["composite_risk_score"],
+        "composite_risk_tier": result["composite_risk_tier"].value,
+        "active_predictors": result["active_predictors"],
+        "by_disaster": by_disaster_serialized,
     }
 
-@app.get("/info")
-async def get_api_info():
-    """Get API information"""
-    return {
-        "title": "Cyclone Prediction & Resource Optimization API",
-        "version": "4.0.0",
-        "status": "operational",
-        "model_loaded": model is not None,
-        "districts_loaded": districts_df is not None,
-        "total_districts": len(districts_df) if districts_df is not None else 0,
-        "endpoints": {
-            "docs": "/docs",
-            "health": "/health",
-            "predict": "/predict/manual (POST)",
-            "districts": "/data/districts",
-            "live_cyclones": "/live/cyclones",
-            "live_predict": "/live/predict"
-        },
-        "example_request": {
-            "url": "/predict/manual",
-            "method": "POST",
-            "body": {
-                "LAT": 15.5,
-                "LON": 85.3,
-                "MAX_WIND": 65,
-                "MIN_PRESSURE": 990
+
+@app.post("/predict/flood/explain")
+def explain_flood(req: PredictionRequest):
+    """
+    Returns fuzzy membership degrees per feature.
+    Shows how much each input feature falls into LOW / MEDIUM / HIGH fuzzy sets.
+    Useful for interpretability and debugging model behavior.
+    """
+    errors = flood_predictor.validate_input(req.features)
+    if errors:
+        raise HTTPException(422, {"validation_errors": errors})
+
+    result = flood_predictor.predict(req.features, req.n_mc_samples)
+    memberships = result.feature_memberships
+
+    explanation = {}
+    if memberships:
+        for feat, degrees in memberships.items():
+            explanation[feat] = {
+                "LOW":    round(degrees[0], 4),
+                "MEDIUM": round(degrees[1], 4),
+                "HIGH":   round(degrees[2], 4),
+                "dominant_set": ["LOW", "MEDIUM", "HIGH"][int(np.argmax(degrees))]
             }
-        }
+
+    return {
+        "risk_score": result.risk_score,
+        "risk_tier": result.risk_tier.value,
+        "fuzzy_explanation": explanation,
     }
 
-@app.post("/predict/manual", response_model=PredictionResponse)
-async def predict_from_manual_input(cyclone_data: SimpleCycloneInput):
-    """Predict cyclone intensity from manual input"""
-    if model is None:
-        raise HTTPException(status_code=503, detail="Model not loaded. Check /health endpoint.")
+
+import numpy as np  # needed for explain endpoint
+
+
+# ============================================================================
+# LANE-LEVEL FLOOD MAP ENDPOINTS
+# ============================================================================
+
+@app.post("/map/flood/features")
+def flood_map_from_features(req: LaneFeaturesRequest):
+    """
+    Primary endpoint: generate lane-level flood risk GeoJSON
+    from explicit per-segment feature values.
     
-    if feature_engineer is None:
-        raise HTTPException(status_code=503, detail="Feature engineer not initialized.")
+    Returns a GeoJSON FeatureCollection where each LineString feature
+    has risk_score, risk_tier, color, and uncertainty properties.
+    """
+    if not flood_predictor.is_ready():
+        raise HTTPException(503, "Flood model not loaded. Run train_model.py first.")
+    return lane_mapper.map_from_features(req.segments)
+
+
+@app.post("/map/flood/osm")
+def flood_map_from_osm(req: OSMMapRequest):
+    """
+    Fetch road network from OpenStreetMap for a bounding box
+    and generate flood risk GeoJSON using zone-level features.
     
+    Requires osmnx: pip install osmnx
+    """
+    if not flood_predictor.is_ready():
+        raise HTTPException(503, "Flood model not loaded. Run train_model.py first.")
     try:
-        raw_data = cyclone_data.model_dump()
-        engineered_features = feature_engineer.engineer_features(raw_data)
-        
-        input_df = build_model_input(engineered_features)
-        prediction = model.predict(input_df)
-        predicted_wind = float(prediction[0])
-        
-        return PredictionResponse(
-            predicted_intensity=round(predicted_wind, 2),
-            predicted_intensity_kmh=round(predicted_wind * 1.852, 2),
-            intensity_category=get_intensity_category(predicted_wind),
-            status="success",
-            data_source="Manual Input",
-            current_parameters={
-                "latitude": engineered_features['LAT'],
-                "longitude": engineered_features['LON'],
-                "current_wind": engineered_features['MAX_WIND'],
-                "current_pressure": engineered_features['MIN_PRESSURE']
-            },
-            distance_to_odisha_km=round(engineered_features['DIST_TO_ODISHA_KM'], 2)
+        return lane_mapper.map_from_osm(
+            req.bbox, req.base_features, req.segment_overrides
         )
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Prediction error: {str(e)}")
-
-@app.get("/live/cyclones")
-async def get_active_cyclones():
-    """Fetch active cyclone alerts from IMD"""
-    if imd_fetcher is None:
-        raise HTTPException(status_code=503, detail="IMD fetcher not initialized")
-    
-    try:
-        result = imd_fetcher.fetch_active_cyclones()
-        return result
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error fetching IMD data: {str(e)}")
-
-@app.get("/live/bulletin")
-async def get_live_bulletin():
-    """Fetch hourly bulletin from IMD"""
-    if imd_fetcher is None:
-        raise HTTPException(status_code=503, detail="IMD fetcher not initialized")
-    
-    try:
-        result = imd_fetcher.fetch_hourly_bulletin()
-        if not result or result.get("status") != "success":
-            return {
-                "status": "no_active_cyclone",
-                "message": "No active cyclone bulletin available",
-                "timestamp": datetime.now().isoformat()
-            }
-        return result
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
-
-@app.get("/live/predict")
-async def predict_from_live_imd():
-    """Predict using live IMD bulletin data"""
-    if model is None:
-        raise HTTPException(status_code=503, detail="Model not loaded")
-    
-    if imd_fetcher is None or feature_engineer is None:
-        raise HTTPException(status_code=503, detail="Fetchers not initialized")
-    
-    try:
-        bulletin_result = imd_fetcher.fetch_hourly_bulletin()
-        
-        if bulletin_result.get('status') != 'success':
-            return JSONResponse(
-                status_code=200,
-                content={
-                    "status": "no_active_cyclone",
-                    "message": "No active cyclone bulletin available",
-                    "timestamp": datetime.now().isoformat()
-                }
-            )
-        
-        params = imd_fetcher.parse_cyclone_parameters(bulletin_result['content'])
-        
-        if not params or 'LAT' not in params or 'LON' not in params:
-            return JSONResponse(
-                status_code=200,
-                content={
-                    "status": "no_active_cyclone",
-                    "message": "No cyclone detected in bulletin",
-                    "timestamp": datetime.now().isoformat()
-                }
-            )
-        
-        engineered_features = feature_engineer.engineer_features(params)
-        input_df = build_model_input(engineered_features)
-        prediction = model.predict(input_df)
-        predicted_wind = float(prediction[0])
-        
-        return {
-            "status": "success",
-            "data_source": "IMD RSMC Live Bulletin",
-            "predicted_intensity_knots": round(predicted_wind, 2),
-            "predicted_intensity_kmh": round(predicted_wind * 1.852, 2),
-            "intensity_category": get_intensity_category(predicted_wind),
-            "current_parameters": {
-                "latitude": params.get('LAT'),
-                "longitude": params.get('LON'),
-                "current_wind_knots": params.get('MAX_WIND'),
-                "current_pressure_hpa": params.get('MIN_PRESSURE')
-            },
-            "distance_to_odisha_km": round(engineered_features['DIST_TO_ODISHA_KM'], 2),
-            "timestamp": datetime.now().isoformat()
-        }
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
-
-@app.get("/data/districts")
-async def get_districts():
-    """Get list of all districts"""
-    if districts_df is None:
-        raise HTTPException(status_code=503, detail="Districts data not loaded")
-    
-    try:
-        districts_data = districts_df[[
-            'District', 'Latitude', 'Longitude', 'Flood_Zone',
-            'Vulnerability_Index', 'Infrastructure_Score', 'Is_Coastal'
-        ]].to_dict('records')
-        
-        return {
-            "total_districts": len(districts_data),
-            "districts": districts_data
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
-
-# Error handlers
-@app.exception_handler(404)
-async def not_found_handler(request, exc):
-    return JSONResponse(
-        status_code=404,
-        content={
-            "error": "Endpoint not found",
-            "available_endpoints": [
-                "/docs", "/health", "/info", 
-                "/predict/manual", "/data/districts",
-                "/live/cyclones", "/live/predict"
-            ]
-        }
-    )
+    except RuntimeError as e:
+        raise HTTPException(400, str(e))
+
+
+@app.post("/map/flood/geojson")
+def flood_map_from_geojson(req: GeoJSONMapRequest):
+    """
+    Generate flood risk map from your own road GeoJSON.
+    Provide a feature_mapping to tell the API which GeoJSON property
+    corresponds to which flood input feature.
+    """
+    if not flood_predictor.is_ready():
+        raise HTTPException(503, "Flood model not loaded. Run train_model.py first.")
+    return lane_mapper.map_from_geojson(req.geojson, req.feature_mapping)
+
+
+# ============================================================================
+# ALLOCATION ENDPOINTS
+# ============================================================================
 
-@app.exception_handler(500)
-async def internal_error_handler(request, exc):
-    return JSONResponse(
-        status_code=500,
-        content={
-            "error": "Internal server error",
-            "message": str(exc)
-        }
+@app.post("/allocate/auto")
+def auto_allocate(req: AutoAllocateRequest):
+    """
+    Automatically allocate unassigned tasks to available teams.
+    Uses Hungarian algorithm for optimal bipartite matching,
+    then 2-opt for route optimization.
+    """
+    if req.strategy not in ("priority_based", "proximity_based", "balanced"):
+        raise HTTPException(400, "strategy must be priority_based | proximity_based | balanced")
+
+    allocations = AllocationEngine.auto_allocation(
+        strategy=req.strategy,
+        optimize_routes=req.optimize_routes,
+        priority_weight=req.priority_weight
     )
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    return {
+        "allocations_created": len(allocations),
+        "strategy": req.strategy,
+        "assignment_algorithm": "Hungarian (scipy.optimize.linear_sum_assignment)",
+        "route_algorithm": "Priority-weighted nearest neighbor + 2-opt",
+        "allocations": [a.dict() for a in allocations],
+    }
+
+
+@app.post("/allocate/manual")
+def manual_allocate(req: ManualAllocateRequest):
+    """Manually specify team → task assignments."""
+    results = []
+    errors = []
+
+    for team_id, task_ids in req.team_assignments.items():
+        try:
+            allocation = AllocationEngine.manual_allocation(
+                team_id, task_ids,
+                optimize_route=req.optimize_routes,
+                respect_capacity=req.respect_capacity
+            )
+            results.append(allocation.dict())
+        except HTTPException as e:
+            errors.append({"team_id": team_id, "error": e.detail})
+
+    return {
+        "successful_allocations": len(results),
+        "failed_allocations": len(errors),
+        "allocations": results,
+        "errors": errors,
+    }
+
+
+@app.post("/allocate/reset")
+def reset_allocations():
+    """Reset all allocations and task statuses to unassigned."""
+    reset_all_allocations()
+    return {"status": "reset", "message": "All allocations cleared, tasks reset to UNASSIGNED"}
+
+
+@app.get("/allocate/summary")
+def allocation_summary():
+    return get_allocation_summary()
+
+
+# ============================================================================
+# TEAM MANAGEMENT
+# ============================================================================
+
+@app.post("/teams", status_code=201)
+def create_team(team: FieldTeam):
+    if team.id in TEAMS:
+        raise HTTPException(409, f"Team {team.id} already exists")
+    TEAMS[team.id] = team
+    return team
+
+
+@app.get("/teams")
+def list_teams():
+    return list(TEAMS.values())
+
+
+@app.get("/teams/{team_id}")
+def get_team(team_id: str):
+    if team_id not in TEAMS:
+        raise HTTPException(404, f"Team {team_id} not found")
+    return TEAMS[team_id]
+
+
+@app.delete("/teams/{team_id}")
+def delete_team(team_id: str):
+    if team_id not in TEAMS:
+        raise HTTPException(404)
+    del TEAMS[team_id]
+    return {"deleted": team_id}
+
+
+# ============================================================================
+# TASK MANAGEMENT
+# ============================================================================
+
+@app.post("/tasks", status_code=201)
+def create_task(task: Task):
+    if task.id in TASKS:
+        raise HTTPException(409, f"Task {task.id} already exists")
+    TASKS[task.id] = task
+    return task
+
+
+@app.get("/tasks")
+def list_tasks(
+    status: Optional[str] = Query(None, description="Filter by status"),
+    disaster_type: Optional[str] = Query(None)
+):
+    tasks = list(TASKS.values())
+    if status:
+        tasks = [t for t in tasks if t.status.value == status]
+    if disaster_type:
+        tasks = [t for t in tasks if t.disaster_type == disaster_type]
+    return tasks
+
+
+@app.get("/tasks/{task_id}")
+def get_task(task_id: str):
+    if task_id not in TASKS:
+        raise HTTPException(404)
+    return TASKS[task_id]
+
+
+@app.patch("/tasks/{task_id}/status")
+def update_task_status(task_id: str, status: TaskStatus):
+    if task_id not in TASKS:
+        raise HTTPException(404)
+    TASKS[task_id].status = status
+    return TASKS[task_id]
+
+
+@app.delete("/tasks/{task_id}")
+def delete_task(task_id: str):
+    if task_id not in TASKS:
+        raise HTTPException(404)
+    del TASKS[task_id]
+    return {"deleted": task_id}
+
+
+# ============================================================================
+# STARTUP
+# ============================================================================
+
+@app.on_event("startup")
+def startup():
+    initialize_default_teams()
+    ready = [k for k, p in {
+        "flood": flood_predictor, "cyclone": cyclone_predictor,
+        "landslide": landslide_predictor, "earthquake": earthquake_predictor
+    }.items() if p.is_ready()]
+
+    print(f"[API] Models ready: {ready or 'None — run train_model.py'}")
+    print(f"[API] Default teams initialized: {list(TEAMS.keys())}")