api.py

from fastapi import FastAPI, Request, Body
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import HTMLResponse
import pandas as pd
from groq import Groq
import os
import random
import sys
import uuid
import numpy as np
from rl.agents import TierAgent
from core.config import get_weights as _cfg_weights

app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)

# ─────────────────────────────────────────────────────────────────
# PATHS — resolved relative to this script so the server can be
# started from any working directory
# ─────────────────────────────────────────────────────────────────
BASE = os.path.dirname(os.path.abspath(__file__))

def _load(rel_path: str, loader):
    full = os.path.join(BASE, rel_path)
    if not os.path.exists(full):
        print(f"\n❌  Missing dataset: {full}")
        print(f"    Place the file at that path and restart the server.\n")
        sys.exit(1)
    return loader(full)

# ─────────────────────────────────────────────────────────────────
# LOAD DATASETS
# ─────────────────────────────────────────────────────────────────
TASKS   = _load("data/dataset_rl/task_15min_L.csv", pd.read_csv)
PRICE   = _load("data/dataset_rl/price.csv",        pd.read_csv)
SERVERS = _load("data/dataset_rl/Server_L.xlsx",    pd.read_excel)
STEEL   = _load("data/steel_industry_data.csv",     pd.read_csv)

DATA_PTR  = 0
STEEL_PTR = 0

# ─────────────────────────────────────────────────────────────────
# SESSION STORE — each visitor gets isolated queue/history
# ─────────────────────────────────────────────────────────────────
_sessions: dict = {}

def _get_session(sid: str) -> dict:
    if sid not in _sessions:
        server_ids = [f"Server {int(row['ID'])}" for _, row in SERVERS.iterrows()] if len(SERVERS) else []
        _sessions[sid] = {
            "job_queue": [],
            "job_id_counter": 0,
            "submitted_ids": set(),
            "server_loads": {dc: 0 for dc in server_ids},  # jobs assigned per server
            "rr_index": {"green": 0, "balanced": 0, "performance": 0},  # round-robin pointers
        }
    return _sessions[sid]

# ─────────────────────────────────────────────────────────────────
# NORMALISE STEEL COLUMNS ONCE AT STARTUP
# ─────────────────────────────────────────────────────────────────
_ukwh_min = STEEL["Usage_kWh"].min()
_ukwh_rng = STEEL["Usage_kWh"].max() - _ukwh_min + 1e-9
_co2_min  = STEEL["CO2(tCO2)"].min()
_co2_rng  = STEEL["CO2(tCO2)"].max() - _co2_min  + 1e-9

STEEL["norm_energy"] = (STEEL["Usage_kWh"] - _ukwh_min) / _ukwh_rng
# CO2 raw values are ~50% zero — blend rank-based CO2 with NSM (time-of-day)
# so carbon_factor varies continuously (mirrors real grid carbon intensity patterns)
_nsm_norm = (STEEL["NSM"] - STEEL["NSM"].min()) / (STEEL["NSM"].max() - STEEL["NSM"].min() + 1e-9)
STEEL["norm_co2"]    = (0.5 * STEEL["CO2(tCO2)"].rank(pct=True, method="average") + 0.5 * _nsm_norm).round(4)

# ─────────────────────────────────────────────────────────────────
# SORT SERVERS BY CPU (ascending): index 0 = weakest, -1 = strongest
# ─────────────────────────────────────────────────────────────────
SERVERS   = SERVERS.sort_values("CPU").reset_index(drop=True)
n_servers = len(SERVERS)

# capacity_tier: 0.0 = smallest server, 1.0 = largest server
SERVERS["capacity_tier"] = SERVERS.index / max(n_servers - 1, 1)

# ─────────────────────────────────────────────────────────────────
# HARD TIER POOLS — each priority competes ONLY within its pool
#
# green       → bottom third  (most energy-efficient / lowest CO2)
# balanced    → middle third  (moderate capability)
# performance → top third     (most powerful / fastest)
# ─────────────────────────────────────────────────────────────────
def get_tier_pool(priority: str) -> pd.DataFrame:
    third = max(n_servers // 3, 1)
    if priority == "green":
        pool = SERVERS.iloc[:third]
    elif priority == "performance":
        pool = SERVERS.iloc[n_servers - third:]
    else:  # balanced
        start = third
        end   = n_servers - third
        pool  = SERVERS.iloc[start:end] if end > start else SERVERS.iloc[third: third + 1]
    return pool if len(pool) > 0 else SERVERS


# ─────────────────────────────────────────────────────────────────
# SCORING WEIGHTS (perf, cost, co2, lat)
# ─────────────────────────────────────────────────────────────────
PRIORITY_WEIGHTS = {
    #                  perf   cost   co2    lat
    "green":          (0.10,  0.25,  0.40,  0.25),
    "balanced":       (0.25,  0.25,  0.25,  0.25),
    "performance":    (0.40,  0.10,  0.10,  0.40),
}

# ─────────────────────────────────────────────────────────────────
# GROQ CLIENT
# ─────────────────────────────────────────────────────────────────
GROQ_KEY    = os.getenv("GROQ_API_KEY", "")
groq_client = Groq(api_key=GROQ_KEY)


# ─────────────────────────────────────────────────────────────────
# RL TIER AGENTS — one per priority, action = server index in pool
# ─────────────────────────────────────────────────────────────────
_rl_agents: dict[str, TierAgent] = {}

def _pool_server_names(priority: str) -> list[str]:
    """Sorted server names in the tier pool for this priority."""
    return sorted(f"Server {int(row['ID'])}" for _, row in get_tier_pool(priority).iterrows())


def _rl_reward(priority: str, chosen_dc: str, scores: dict,
               breakdown: dict, server_loads: dict) -> float:
    """
    Reward = tier-weighted quality score − overload penalty.
    Uses PRIORITY_WEIGHTS (perf, cost, co2, lat) which always has 4 values.
    """
    w  = PRIORITY_WEIGHTS[priority]   # (perf, cost, co2, lat)
    bd = breakdown[chosen_dc]
    quality  = (bd["perf_score"] * w[0] + bd["cost_score"] * w[1]
              + bd["co2_score"]  * w[2] + bd["lat_score"]  * w[3])
    pool_dcs = [dc for dc, b in breakdown.items() if b["in_pool"]]
    avg_load = sum(server_loads.get(dc, 0) for dc in pool_dcs) / max(len(pool_dcs), 1)
    overload = max(0.0, server_loads.get(chosen_dc, 0) - avg_load) / 5.0
    return float(quality - overload)

def _init_rl_agents():
    """Pre-train one TierAgent per priority for 500 simulated episodes."""
    try:
        from rl.rl_env import CloudEnv
        env = CloudEnv(os.path.join(BASE, "data", "steel_industry_data.csv"))

        for priority in ["green", "balanced", "performance"]:
            pool   = _pool_server_names(priority)
            agent  = TierAgent(priority, n_servers=len(pool), lr=0.05, epsilon=0.3)
            wts    = _cfg_weights(priority)
            # Simulate load distributions during pre-training
            for ep in range(500):
                raw_state = env.reset()
                # Simulate varied server loads
                sim_loads = [float(np.random.randint(0, 20)) for _ in pool]
                feat      = agent.build_features(
                    sim_loads,
                    raw_state[2] if len(raw_state) > 2 else 0.5,  # carbon proxy
                    raw_state[3] if len(raw_state) > 3 else 0.05,  # price proxy
                    float(np.random.rand()),
                    float(np.random.rand()),
                )
                action  = agent.act(feat, explore=True)
                # Reward: green agent should prefer low-load, low-carbon;
                #         perf agent should prefer low-load, high-throughput
                # Reward: quality benefit minus STRONG overload penalty
                # Training emphasises avoiding overloaded servers so agent
                # learns load-aware distribution, not just quality chasing.
                avg_load     = sum(sim_loads) / max(len(sim_loads), 1)
                overload     = max(0.0, sim_loads[action] - avg_load) / 10.0
                quality_sim  = (wts[0] * float(np.random.rand())
                              + (wts[2] if len(wts) > 2 else 0.2) * (1.0 - (raw_state[2] if len(raw_state) > 2 else 0.5)))
                reward       = quality_sim - 0.8 * overload  # strong penalty
                agent.learn(feat, action, reward)
            _rl_agents[priority] = agent

        print(f"RL TierAgents trained: {list(_rl_agents.keys())}")
    except Exception as e:
        print(f"RL agent training skipped: {e}")

_init_rl_agents()


# ─────────────────────────────────────────────────────────────────
# SESSION INIT
# ─────────────────────────────────────────────────────────────────
@app.get("/session")
def new_session():
    sid = str(uuid.uuid4())
    _get_session(sid)
    return {"session_id": sid}


# ─────────────────────────────────────────────────────────────────
# JOB SUBMISSION
# ─────────────────────────────────────────────────────────────────
@app.post("/submit")
def submit_job(job: dict, request: Request):
    sid = request.headers.get("X-Session-ID", "default")
    s = _get_session(sid)
    s["job_id_counter"] += 1
    new_id = s["job_id_counter"]
    job["job_id"] = new_id
    s["submitted_ids"].add(new_id)
    s["job_queue"].append(job)
    return {"job_id": new_id}


# ─────────────────────────────────────────────────────────────────
# RESET
# ─────────────────────────────────────────────────────────────────
@app.post("/submit_batch")
def submit_batch(request: Request, jobs: list = Body(...)):
    sid = request.headers.get("X-Session-ID", "default")
    s = _get_session(sid)
    ids = []
    for job in jobs:
        s["job_id_counter"] += 1
        job["job_id"] = s["job_id_counter"]
        s["submitted_ids"].add(job["job_id"])
        s["job_queue"].append(job)
        ids.append(job["job_id"])
    return {"job_ids": ids, "count": len(ids)}


@app.post("/reset")
def reset_state(request: Request):
    global DATA_PTR, STEEL_PTR
    sid = request.headers.get("X-Session-ID", "default")
    s = _get_session(sid)
    s["job_queue"]      = []
    s["submitted_ids"]  = set()
    s["job_id_counter"] = 0
    s["server_loads"]   = {f"Server {int(row['ID'])}": 0 for _, row in SERVERS.iterrows()}
    s["rr_index"]       = {"green": 0, "balanced": 0, "performance": 0}
    DATA_PTR = 0
    STEEL_PTR = 0
    return {"status": "reset ok"}


# ─────────────────────────────────────────────────────────────────
# BUILD SYSTEM STATE FROM DATASETS
# ─────────────────────────────────────────────────────────────────
def compute_state() -> dict:
    global DATA_PTR, STEEL_PTR
    task  = TASKS.iloc[DATA_PTR  % len(TASKS)]
    price = PRICE.iloc[DATA_PTR  % len(PRICE)]
    steel = STEEL.iloc[STEEL_PTR % len(STEEL)]
    DATA_PTR  += 1
    STEEL_PTR += 1
    cpu_util = float(task.get("plan_cpu_i",   50)) / 100.0
    mem_util = float(task.get("plan_mem_int", 50)) / 100.0
    load     = min(max((cpu_util + mem_util) / 2.0, 0.0), 1.0)
    return {
        "load":             round(load, 4),
        "energy_price":     round(float(price.get("price_1", 50)) / 100.0, 4),
        "carbon_factor":    round(float(steel["norm_co2"]),    4),
        "energy_factor":    round(float(steel["norm_energy"]), 4),
        "steel_energy_kwh": round(float(steel["Usage_kWh"]),   4),
        "steel_co2":        round(float(steel["CO2(tCO2)"]),   6),
        "load_type":        str(steel["Load_Type"]),
        "week_status":      str(steel["WeekStatus"]),
        "day_of_week":      str(steel["Day_of_week"]),
    }


# ─────────────────────────────────────────────────────────────────
# POWER MODEL
# ─────────────────────────────────────────────────────────────────
def server_power(row, load: float) -> float:
    return row["P_idle"] + (row["P_peak"] - row["P_idle"]) * load


# ─────────────────────────────────────────────────────────────────
# MIN-MAX NORMALISE within a list
# ─────────────────────────────────────────────────────────────────
def minmax(values: list) -> list:
    mn, mx = min(values), max(values)
    rng = mx - mn + 1e-9
    return [(v - mn) / rng for v in values]


# ─────────────────────────────────────────────────────────────────
# COMPUTE SCORES
# ─────────────────────────────────────────────────────────────────
def compute_scores(state: dict, priority: str, server_loads: dict) -> tuple[dict, dict, dict]:
    w        = PRIORITY_WEIGHTS[priority]
    pool_df  = get_tier_pool(priority)
    pool_pos = set(pool_df.index.tolist())

    server_ids = []
    raw_perfs, raw_costs, raw_co2s, raw_lats, raw_kwhs = [], [], [], [], []

    for pos, row in SERVERS.iterrows():
        dc   = f"Server {int(row['ID'])}"
        perf = (row["CPU"] * row["cpu_rate"] + row["GPU"] * row["gpu_rate"]) / 1000.0
        pwr  = server_power(row, state["load"])
        ekwh = pwr / 1000.0
        cost = ekwh * state["energy_price"]
        co2  = ekwh * (0.35 + state["carbon_factor"])
        lat  = 1.0 / (row["cpu_rate"] + 1e-9)
        server_ids.append(dc)
        raw_perfs.append(perf)
        raw_costs.append(cost)
        raw_co2s.append(co2)
        raw_lats.append(lat)
        raw_kwhs.append(ekwh)

    pool_positions = [i for i, pos in enumerate(SERVERS.index) if pos in pool_pos]

    def pool_vals(raw):
        return [raw[i] for i in pool_positions]

    nm_perf = minmax(pool_vals(raw_perfs))
    nm_cost = [1.0 - v for v in minmax(pool_vals(raw_costs))]
    nm_co2  = [1.0 - v for v in minmax(pool_vals(raw_co2s))]
    nm_lat  = [1.0 - v for v in minmax(pool_vals(raw_lats))]

    pool_norm = {}
    for rank, srv_i in enumerate(pool_positions):
        pool_norm[server_ids[srv_i]] = (
            nm_perf[rank], nm_cost[rank], nm_co2[rank], nm_lat[rank]
        )

    scores, metrics, score_breakdown = {}, {}, {}

    for i, dc in enumerate(server_ids):
        in_pool = (SERVERS.index[i] in pool_pos)

        if in_pool:
            ps, cs, gs, ls = pool_norm[dc]
            # Pure quality score — RL agent uses this via _rl_reward, not blended in here
            score = round(min(max(ps * w[0] + cs * w[1] + gs * w[2] + ls * w[3], 0.0), 1.0), 4)
        else:
            ps = cs = gs = ls = score = 0.0

        scores[dc]  = score
        metrics[dc] = {
            "energy_kwh":    round(raw_kwhs[i],  6),
            "cost":          round(raw_costs[i], 6),
            "co2":           round(raw_co2s[i],  6),
            "capacity_tier": round(SERVERS.iloc[i]["capacity_tier"], 4),
        }
        score_breakdown[dc] = {
            "perf_score":     round(ps, 4),
            "cost_score":     round(cs, 4),
            "co2_score":      round(gs, 4),
            "lat_score":      round(ls, 4),
            "capacity_score": round(SERVERS.iloc[i]["capacity_tier"], 4),
            "final":          round(score, 4),
            "in_pool":        in_pool,
            "server_load":    server_loads.get(dc, 0),
        }

    return scores, metrics, score_breakdown


# ─────────────────────────────────────────────────────────────────
# XAI – LLM EXPLANATION VIA GROQ (with caching)
# Cache key = (server, priority, carbon_band) — max ~27 unique Groq
# calls across the whole session regardless of batch size.
# ─────────────────────────────────────────────────────────────────
_xai_cache: dict = {}

def _xai_key(chosen_dc: str, priority: str, carbon_factor: float) -> str:
    band = "low" if carbon_factor < 0.33 else "high" if carbon_factor > 0.66 else "med"
    return f"{chosen_dc}|{priority}|{band}"

def generate_explanation(job, state, chosen_dc, scores, breakdown, metrics,
                         rl_q: dict | None = None) -> str:
    priority   = job["priority"]
    cache_key  = _xai_key(chosen_dc, priority, state["carbon_factor"])
    if cache_key in _xai_cache:
        return _xai_cache[cache_key]

    w          = PRIORITY_WEIGHTS[priority]
    pool_names = [
        f"Server {int(row['ID'])}"
        for _, row in get_tier_pool(priority).iterrows()
    ]
    cm = metrics[chosen_dc]

    bd_text = "\n".join(
        f"  {dc}: perf={b['perf_score']:.3f} cost={b['cost_score']:.3f} "
        f"co2={b['co2_score']:.3f} lat={b['lat_score']:.3f} "
        f"in_pool={b['in_pool']} final={b['final']:.3f}"
        for dc, b in sorted(breakdown.items(), key=lambda x: x[1]["final"], reverse=True)
    )

    prompt = f"""You are an XAI assistant for a sustainable cloud job scheduler.

The scheduler uses TIER-POOL routing: each priority maps to a server tier.
  green       → small/efficient servers  (lowest CO2 + cost)
  balanced    → mid-tier servers         (moderate capability)
  performance → large/powerful servers   (highest throughput)

Eligible pool for this job: {pool_names}
Only pool servers compete; others are excluded for sustainability reasons.

Job: priority={priority}, latency={job.get('latency','N/A')}
State: load={state['load']:.3f}, energy_price={state['energy_price']:.4f}, carbon={state['carbon_factor']:.4f}
Weights: perf×{w[0]}, cost×{w[1]}, co2×{w[2]}, lat×{w[3]}

Scores:
{bd_text}

Chosen: {chosen_dc} | energy={cm['energy_kwh']:.4f}kWh cost={cm['cost']:.6f} co2={cm['co2']:.6f} tier={cm['capacity_tier']:.2f}
RL Q-values: {rl_q if rl_q else 'N/A'}

In 3-4 sentences explain why {chosen_dc} won. Reference the RL agent's Q-value decision,
mention tier routing, dominant metric, and grid carbon conditions. Do not greet or use "I"."""

    try:
        resp = groq_client.chat.completions.create(
            model="llama-3.3-70b-versatile",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=200,
            temperature=0.4,
            timeout=10,
        )
        result = resp.choices[0].message.content.strip()
    except Exception:
        # Natural-language fallback using RL Q-values and quality scores
        bd   = breakdown[chosen_dc]
        pool_rivals = sorted(
            [(k, v["final"]) for k, v in breakdown.items() if k != chosen_dc and v["in_pool"]],
            key=lambda x: x[1], reverse=True,
        )

        tier_desc = {"green": "energy-efficient", "balanced": "mid-tier", "performance": "high-throughput"}[priority]
        dominant  = max(
            [("CO₂ efficiency", bd["co2_score"]), ("cost efficiency", bd["cost_score"]),
             ("throughput", bd["perf_score"]), ("low latency", bd["lat_score"])],
            key=lambda x: x[1]
        )[0]
        carbon_desc = "low" if state["carbon_factor"] < 0.33 else "high" if state["carbon_factor"] > 0.66 else "moderate"
        rival_txt   = f" outperforming {pool_rivals[0][0]} (score {pool_rivals[0][1]:.3f})" if pool_rivals else ""

        result = (
            f"{chosen_dc} was chosen by the RL agent from the {priority} tier pool "
            f"({', '.join(pool_names)}), which contains {tier_desc} servers. "
            f"With {carbon_desc} grid carbon intensity and system load at {state['load']:.0%}, "
            f"the agent prioritised {dominant} — scoring {bd['final']:.3f}{rival_txt}. "
            f"The {priority} weighting profile (perf×{w[0]}, cost×{w[1]}, CO₂×{w[2]}, lat×{w[3]}) "
            f"guided this decision while balancing current server loads across the tier."
        )

    _xai_cache[cache_key] = result
    return result


# ─────────────────────────────────────────────────────────────────
# SCHEDULER ENDPOINT
# ─────────────────────────────────────────────────────────────────
@app.post("/run")
def run_scheduler(request: Request):
    sid = request.headers.get("X-Session-ID", "default")
    s = _get_session(sid)
    # Ensure server_loads key exists for older sessions
    if "server_loads" not in s:
        s["server_loads"] = {f"Server {int(row['ID'])}": 0 for _, row in SERVERS.iterrows()}
    if "rr_index" not in s:
        s["rr_index"] = {"green": 0, "balanced": 0, "performance": 0}

    scheduled_jobs = []
    prev_feat: dict = {}  # last feature vector per priority for TD(next_state)

    while s["job_queue"]:
        job      = s["job_queue"].pop(0)
        priority = job["priority"]
        state    = compute_state()
        scores, metrics, breakdown = compute_scores(state, priority, s["server_loads"])

        pool_servers = sorted(dc for dc, b in breakdown.items() if b["in_pool"])

        # ── RL AGENT PICKS THE SERVER ─────────────────────────────
        feat   = None
        reward = scores.get(max(pool_servers, key=lambda dc: scores[dc]), 0.5)
        if priority in _rl_agents:
            agent = _rl_agents[priority]
            pool_loads = [float(s["server_loads"].get(dc, 0)) for dc in pool_servers]
            feat = agent.build_features(
                pool_loads,
                state["carbon_factor"],
                state["energy_price"],
                job.get("cpu", 50) / 100.0,
                job.get("memory", 50) / 100.0,
            )
            # Explore during runtime so agent keeps learning
            action    = agent.act(feat, explore=True)
            chosen_dc = pool_servers[action]

            # Compute reward: quality score of chosen server − overload penalty
            reward = _rl_reward(priority, chosen_dc, scores, breakdown, s["server_loads"])

            # TD update: use previous feature as "last state" for this tier
            next_feat_prev = prev_feat.get(priority)
            agent.learn(feat, action, reward, next_feat=next_feat_prev)
            prev_feat[priority] = feat
        else:
            # Fallback: pick highest quality score
            chosen_dc = max({dc: scores[dc] for dc in pool_servers}, key=lambda dc: scores[dc])

        s["server_loads"][chosen_dc] = s["server_loads"].get(chosen_dc, 0) + 1

        if priority in _rl_agents and feat is not None:
            rl_q = {pool_servers[i]: float(np.round(_rl_agents[priority].q_values(feat)[i], 4))
                    for i in range(len(pool_servers))}
        else:
            rl_q = {}
        explanation = generate_explanation(job, state, chosen_dc, scores, breakdown, metrics, rl_q)

        # Quality score = static score of chosen server (0–1, stable, meaningful for display)
        # RL reward is the training signal (can go negative due to overload penalty)
        quality_score = round(scores.get(chosen_dc, 0.5), 4)

        scheduled_jobs.append({
            "job_id":          job["job_id"],
            "chosen_dc":       chosen_dc,
            "scores":          scores,
            "score_breakdown": breakdown,
            "rl_q_values":     rl_q,
            "rl_reward":       round(reward, 4),   # internal RL signal
            "reward":          quality_score,       # display metric (quality, always 0–1)
            "priority":        priority,
            "latency":         job.get("latency", "N/A"),
            "state":           state,
            "power_kwh":       metrics[chosen_dc]["energy_kwh"],
            "cost":            metrics[chosen_dc]["cost"],
            "co2":             metrics[chosen_dc]["co2"],
            "all_metrics":     metrics,
            "explanation":     explanation,
        })
    return {"scheduled_jobs": scheduled_jobs, "server_loads": s["server_loads"]}


# ─────────────────────────────────────────────────────────────────
# INFO — exposes n_servers + pool assignments to frontend
# ─────────────────────────────────────────────────────────────────
@app.get("/info")
def get_info():
    pools = {
        p: [f"Server {int(row['ID'])}" for _, row in get_tier_pool(p).iterrows()]
        for p in ["green", "balanced", "performance"]
    }
    return {
        "n_servers":  n_servers,
        "server_ids": [f"Server {int(row['ID'])}" for _, row in SERVERS.iterrows()],
        "tier_pools": pools,
    }


# ─────────────────────────────────────────────────────────────────
# DEBUG: view tier pool assignments
# ─────────────────────────────────────────────────────────────────
@app.get("/tiers")
def show_tiers():
    green_pool = [f"Server {int(r['ID'])}" for _, r in get_tier_pool("green").iterrows()]
    bal_pool   = [f"Server {int(r['ID'])}" for _, r in get_tier_pool("balanced").iterrows()]
    perf_pool  = [f"Server {int(r['ID'])}" for _, r in get_tier_pool("performance").iterrows()]
    result = {}
    for _, row in SERVERS.iterrows():
        dc = f"Server {int(row['ID'])}"
        result[dc] = {
            "capacity_tier":        round(row["capacity_tier"], 4),
            "in_green_pool":        dc in green_pool,
            "in_balanced_pool":     dc in bal_pool,
            "in_performance_pool":  dc in perf_pool,
        }
    return {"server_tiers": result, "total_servers": n_servers}


# ─────────────────────────────────────────────────────────────────
# SUSTAINABILITY HINT
# ─────────────────────────────────────────────────────────────────
@app.get("/sustainability")
def get_sustainability_hint():
    """Returns current carbon factor and scheduling recommendation."""
    try:
        steel = STEEL.iloc[STEEL_PTR % len(STEEL)]
        cf = float(steel["norm_co2"])
        if cf < 0.33:
            rec = "performance"
            msg = "Low carbon intensity — ideal for any workload"
        elif cf < 0.66:
            rec = "balanced"
            msg = "Moderate carbon intensity — prefer balanced jobs"
        else:
            rec = "green"
            msg = "High carbon intensity — prioritize green jobs"
        return {"carbon_factor": round(cf, 4), "recommendation": rec, "message": msg}
    except Exception:
        return {"carbon_factor": 0.5, "recommendation": "balanced", "message": "Unable to read carbon data"}


# ─────────────────────────────────────────────────────────────────
# HEALTH CHECK
# ─────────────────────────────────────────────────────────────────
_DASHBOARD = os.path.join(BASE, "frontend", "templates", "dashboard.html")

@app.get("/")
def root():
    return HTMLResponse(open(_DASHBOARD, encoding="utf-8").read())

@app.get("/health")
def health():
    return {"message": "TaskPilot API — tier-pool routing active"}