feat: Add main CSS styles for the application

feat: Refactor Dashboard template to extend base layout and improve structure

feat: Enhance Parameter Input template with improved layout and feedback mechanisms

feat: Update Scenario Form template to utilize base layout and improve user experience

feat: Create base layout template for consistent styling across pages

feat: Add Consumption, Costs, Equipment, Maintenance, Production, Reporting, and Simulations templates with placeholders for future functionality

feat: Implement base header and footer partials for consistent navigation and footer across the application

routes/ui.py

@@ -1,6 +1,15 @@
-from fastapi import APIRouter, Request
+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()
 
@@ -8,13 +17,138 @@ router = APIRouter()
 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):
+async def scenario_form(request: Request, db: Session = Depends(get_db)):
     """Render the scenario creation form."""
-    return templates.TemplateResponse("ScenarioForm.html", {"request": request})
+    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):
+async def parameter_form(request: Request, db: Session = Depends(get_db)):
     """Render the parameter input form."""
-    return templates.TemplateResponse("ParameterInput.html", {"request": request})
+    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))