from collections import defaultdict
from datetime import datetime, timezone
from typing import Any, Dict, Optional

from fastapi import APIRouter, Depends, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy.orm import Session

from models.parameters import Parameter
from models.scenario import Scenario
from routes.dependencies import get_db

router = APIRouter()

# Set up Jinja2 templates directory
templates = Jinja2Templates(directory="templates")


def _context(request: Request, extra: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
    payload: Dict[str, Any] = {
        "request": request,
        "current_year": datetime.now(timezone.utc).year,
    }
    if extra:
        payload.update(extra)
    return payload


def _render(
    request: Request,
    template_name: str,
    extra: Optional[Dict[str, Any]] = None,
):
    return templates.TemplateResponse(template_name, _context(request, extra))


def _load_scenarios(db: Session) -> Dict[str, Any]:
    scenarios: list[Dict[str, Any]] = [
        {
            "id": item.id,
            "name": item.name,
            "description": item.description,
        }
        for item in db.query(Scenario).order_by(Scenario.name).all()
    ]
    return {"scenarios": scenarios}


def _load_parameters(db: Session) -> Dict[str, Any]:
    grouped: defaultdict[int, list[Dict[str, Any]]] = defaultdict(list)
    for param in db.query(Parameter).order_by(Parameter.scenario_id, Parameter.id):
        grouped[param.scenario_id].append(
            {
                "id": param.id,
                "name": param.name,
                "value": param.value,
                "distribution_type": param.distribution_type,
                "distribution_parameters": param.distribution_parameters,
            }
        )
    return {"parameters_by_scenario": dict(grouped)}


def _load_costs(_: Session) -> Dict[str, Any]:
    return {"capex_entries": [], "opex_entries": []}


def _load_consumption(_: Session) -> Dict[str, Any]:
    return {"consumption_records": []}


def _load_production(_: Session) -> Dict[str, Any]:
    return {"production_records": []}


def _load_equipment(_: Session) -> Dict[str, Any]:
    return {"equipment_items": []}


def _load_maintenance(_: Session) -> Dict[str, Any]:
    return {"maintenance_records": []}


def _load_simulations(_: Session) -> Dict[str, Any]:
    return {"simulation_runs": []}


def _load_reporting(_: Session) -> Dict[str, Any]:
    return {"report_summaries": []}


@router.get("/ui/scenarios", response_class=HTMLResponse)
async def scenario_form(request: Request, db: Session = Depends(get_db)):
    """Render the scenario creation form."""
    context = _load_scenarios(db)
    return _render(request, "ScenarioForm.html", context)


@router.get("/ui/dashboard", response_class=HTMLResponse)
async def dashboard(request: Request):
    """Render the reporting dashboard."""
    return _render(request, "Dashboard.html")


@router.get("/ui/parameters", response_class=HTMLResponse)
async def parameter_form(request: Request, db: Session = Depends(get_db)):
    """Render the parameter input form."""
    context: Dict[str, Any] = {}
    context.update(_load_scenarios(db))
    context.update(_load_parameters(db))
    return _render(request, "ParameterInput.html", context)


@router.get("/ui/costs", response_class=HTMLResponse)
async def costs_view(request: Request, db: Session = Depends(get_db)):
    """Render the costs placeholder view."""
    return _render(request, "costs.html", _load_costs(db))


@router.get("/ui/consumption", response_class=HTMLResponse)
async def consumption_view(request: Request, db: Session = Depends(get_db)):
    """Render the consumption placeholder view."""
    return _render(request, "consumption.html", _load_consumption(db))


@router.get("/ui/production", response_class=HTMLResponse)
async def production_view(request: Request, db: Session = Depends(get_db)):
    """Render the production placeholder view."""
    return _render(request, "production.html", _load_production(db))


@router.get("/ui/equipment", response_class=HTMLResponse)
async def equipment_view(request: Request, db: Session = Depends(get_db)):
    """Render the equipment placeholder view."""
    return _render(request, "equipment.html", _load_equipment(db))


@router.get("/ui/maintenance", response_class=HTMLResponse)
async def maintenance_view(request: Request, db: Session = Depends(get_db)):
    """Render the maintenance placeholder view."""
    return _render(request, "maintenance.html", _load_maintenance(db))


@router.get("/ui/simulations", response_class=HTMLResponse)
async def simulations_view(request: Request, db: Session = Depends(get_db)):
    """Render the simulations placeholder view."""
    return _render(request, "simulations.html", _load_simulations(db))


@router.get("/ui/reporting", response_class=HTMLResponse)
async def reporting_view(request: Request, db: Session = Depends(get_db)):
    """Render the reporting placeholder view."""
    return _render(request, "reporting.html", _load_reporting(db))