main.py

import sys
import os
import math
import json
import bz2
import gzip
import zipfile
import tarfile
import shutil
import glob
import hashlib
import threading
import zstandard as zstd
from fastapi import FastAPI, BackgroundTasks, UploadFile, File
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse, JSONResponse
from demoparser2 import DemoParser
import uvicorn
import pandas as pd
import numpy as np

try:
    import rarfile
    HAS_RAR = True
except ImportError:
    HAS_RAR = False

app = FastAPI()

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

# Anchor working paths OUTSIDE src-tauri so Tauri watcher does not trigger rebuild loops
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
if os.path.basename(SCRIPT_DIR) == "src-tauri":
    BASE_DIR = os.path.dirname(SCRIPT_DIR)
else:
    BASE_DIR = SCRIPT_DIR

BAKED_BASE_DIR = os.path.join(BASE_DIR, "baked_demos")
TEMP_EXTRACT_DIR = os.path.join(BASE_DIR, "temp_extracted")
TEMP_UPLOADS_DIR = os.path.join(BASE_DIR, "temp_uploads")
CONFIG_FILE_PATH = os.path.join(BASE_DIR, "config.json")

os.makedirs(BAKED_BASE_DIR, exist_ok=True)
os.makedirs(TEMP_EXTRACT_DIR, exist_ok=True)
os.makedirs(TEMP_UPLOADS_DIR, exist_ok=True)

CURRENT_DEMO_FOLDER = ""
ZSTD_COMPRESSOR = zstd.ZstdCompressor(level=19)

BAKING_STATE = {
    "active": False,
    "step": "Idle",
    "percent": 0,
    "current_file": 1,
    "total_files": 1,
    "current_filename": "",
    "error": None
}

DEFAULT_CONFIG = {
    "active_theme": "default",
    "selected_font": "jetbrains",
    "player_radius": 10,
    "grid_opacity": 0.15,
    "active_map_filter": "grayscale(1) brightness(0.6) contrast(1.3)",
    "keybinds": {
        "playPause": "Space",
        "nextRound": "ArrowRight",
        "prevRound": "ArrowLeft",
        "drawMode": "KeyD",
        "panMode": "KeyB",
        "clearDrawings": "KeyC"
    },
    "steam_auth_code": "",
    "most_recent_match_token": ""
}

def load_user_config():
    if os.path.exists(CONFIG_FILE_PATH):
        try:
            with open(CONFIG_FILE_PATH, "r", encoding="utf-8") as f:
                saved = json.load(f)
                merged = DEFAULT_CONFIG.copy()
                merged.update(saved)
                return merged
        except Exception as e:
            print(f"Error loading config.json: {e}")
    return DEFAULT_CONFIG.copy()

def save_user_config(config_data):
    try:
        with open(CONFIG_FILE_PATH, "w", encoding="utf-8") as f:
            json.dump(config_data, f, indent=2)
        return True
    except Exception as e:
        print(f"Error saving config.json: {e}")
        return False

def safe_int(val, default=0):
    if val is None or pd.isna(val):
        return default
    try:
        return int(float(val))
    except (ValueError, TypeError):
        return default

def sanitize_for_json(obj):
    if isinstance(obj, dict):
        return {k: sanitize_for_json(v) for k, v in obj.items()}
    elif isinstance(obj, list):
        return [sanitize_for_json(v) for v in obj]
    elif isinstance(obj, (np.integer, int)):
        return int(obj)
    elif isinstance(obj, (np.floating, float)):
        if math.isnan(obj) or math.isinf(obj):
            return 0
        return float(obj)
    elif isinstance(obj, (np.bool_, bool)):
        return bool(obj)
    elif pd.isna(obj):
        return None
    return obj

def clean_dataframe(df):
    if not isinstance(df, pd.DataFrame) or df.empty:
        return []
    
    df_clean = df.replace([np.inf, -np.inf], np.nan).copy()
    for col in df_clean.columns:
        if pd.api.types.is_numeric_dtype(df_clean[col]):
            df_clean[col] = df_clean[col].fillna(0)
        else:
            df_clean[col] = df_clean[col].fillna("")
            
    return sanitize_for_json(df_clean.to_dict(orient="records"))

def extract_all_demos_from_archive(file_path):
    if os.path.exists(TEMP_EXTRACT_DIR):
        shutil.rmtree(TEMP_EXTRACT_DIR, ignore_errors=True)
    os.makedirs(TEMP_EXTRACT_DIR, exist_ok=True)

    lower_path = file_path.lower()
    extracted_dem_files = []

    if lower_path.endswith(".zip"):
        with zipfile.ZipFile(file_path, 'r') as zip_ref:
            zip_ref.extractall(TEMP_EXTRACT_DIR)
    elif lower_path.endswith((".tar.gz", ".tgz", ".tar.bz2", ".tbz2", ".tar")):
        with tarfile.open(file_path, 'r:*') as tar_ref:
            tar_ref.extractall(TEMP_EXTRACT_DIR)
    elif lower_path.endswith(".rar"):
        if HAS_RAR:
            with rarfile.RarFile(file_path, 'r') as rf:
                rf.extractall(TEMP_EXTRACT_DIR)
        else:
            try:
                shutil.unpack_archive(file_path, TEMP_EXTRACT_DIR)
            except Exception as e:
                print(f"Error unpacking RAR file: {e}")
    elif lower_path.endswith(".bz2"):
        target_dem = os.path.join(TEMP_EXTRACT_DIR, os.path.basename(file_path)[:-4])
        with bz2.BZ2File(file_path, 'rb') as source, open(target_dem, 'wb') as target:
            shutil.copyfileobj(source, target)
        return [target_dem]
    elif lower_path.endswith(".gz"):
        target_dem = os.path.join(TEMP_EXTRACT_DIR, os.path.basename(file_path)[:-3])
        with gzip.open(file_path, 'rb') as source, open(target_dem, 'wb') as target:
            shutil.copyfileobj(source, target)
        return [target_dem]
    elif lower_path.endswith(".dem"):
        return [file_path]

    extracted_dem_files = glob.glob(os.path.join(TEMP_EXTRACT_DIR, "**", "*.dem"), recursive=True)
    return extracted_dem_files if extracted_dem_files else [file_path]

def get_file_hash(file_path):
    stat = os.stat(file_path)
    hasher = hashlib.md5()
    hasher.update(f"{stat.st_size}-{os.path.basename(file_path)}".encode('utf-8'))
    return hasher.hexdigest()

def read_metadata_from_folder(folder_path):
    meta_zst = os.path.join(folder_path, "metadata.json.zst")
    if os.path.exists(meta_zst):
        dctx = zstd.ZstdDecompressor()
        with open(meta_zst, "rb") as f:
            decompressed = dctx.decompress(f.read())
            return json.loads(decompressed.decode("utf-8"))
    return None

class CS2DemoParser:
    def __init__(self, demo_path):
        self.demo_path = demo_path
        self.parser = DemoParser(self.demo_path)
        self.user_id_to_name = {}

    def get_map_name(self):
        try:
            header = self.parser.parse_header()
            return header.get("map_name", "de_dust2").split("/")[-1].replace(".vpk", "")
        except Exception as e:
            print(f"Error parsing header map_name: {e}")
            return "de_dust2"

    def get_team_names(self, raw_df=None):
        team_2_name = "Team Alpha"
        team_3_name = "Team Bravo"
        try:
            header = self.parser.parse_header()
            if isinstance(header, dict):
                for k, v in header.items():
                    if k.lower() in ["team_name_2", "team_name_t", "t_team_name"] and v:
                        team_2_name = str(v)
                    elif k.lower() in ["team_name_3", "team_name_ct", "ct_team_name"] and v:
                        team_3_name = str(v)
        except Exception as e:
            print(f"Header team name parse error: {e}")

        if (team_2_name == "Team Alpha" or team_3_name == "Team Bravo") and isinstance(raw_df, pd.DataFrame) and not raw_df.empty:
            if "clan_name" in raw_df.columns:
                t_clans = [c for c in raw_df[raw_df["team_num"] == 2]["clan_name"].dropna().unique() if c and str(c).strip() != ""]
                ct_clans = [c for c in raw_df[raw_df["team_num"] == 3]["clan_name"].dropna().unique() if c and str(c).strip() != ""]
                if t_clans and team_2_name == "Team Alpha":
                    team_2_name = str(t_clans[0])
                if ct_clans and team_3_name == "Team Bravo":
                    team_3_name = str(ct_clans[0])

        return {"team_2": team_2_name, "team_3": team_3_name}

    def get_raw_ticks_df(self):
        fields = [
            "X", "Y", "Z",
            "yaw", "pitch",
            "team_num", "name", "user_id", "tick", "clan_name",
            "is_alive", "is_freeze_period", "is_bomb_planted",
            "round_in_progress", "team_rounds_total",
            "health", "armor_value", "has_helmet", "has_defuser",
            "active_weapon", "active_weapon_name", "active_weapon_ammo",
            "inventory", "balance", "is_defusing"
        ]
        
        df = pd.DataFrame()
        while fields:
            try:
                df = self.parser.parse_ticks(fields)
                break
            except Exception as e:
                err_str = str(e)
                if "Columns not found:" in err_str:
                    import re
                    missing_cols = re.findall(r"'([^']*)'", err_str)
                    if missing_cols:
                        fields = [f for f in fields if f not in missing_cols]
                    else:
                        raise e
                else:
                    raise e

        if df.empty:
            return pd.DataFrame()

        if "yaw" in df.columns and "eye_angles_y" not in df.columns:
            df["eye_angles_y"] = df["yaw"]

        valid_names = df[(df["name"] != "") & (df["user_id"].notna())].drop_duplicates(subset=["user_id"])
        for _, row in valid_names.iterrows():
            uid = safe_int(row["user_id"])
            if uid > 0:
                self.user_id_to_name[uid] = str(row["name"])

        df = df.sort_values(by=["name", "tick"])
        fill_cols = [c for c in ["X", "Y", "Z", "yaw", "pitch", "eye_angles_y", "health", "armor_value", "balance", "has_helmet", "has_defuser", "active_weapon_ammo", "team_num", "is_alive", "is_defusing", "is_bomb_planted"] if c in df.columns]
        df[fill_cols] = df.groupby("name")[fill_cols].ffill().bfill()

        return df.sort_values(by="tick").reset_index(drop=True)

    def encode_round_soa_delta(self, round_df):
        if round_df.empty:
            return {"weapons": [], "players": {}}

        weapons_map = {}
        weapons_list = []

        def get_weapon_id(wpn_name):
            wpn = str(wpn_name or "").strip()
            if wpn not in weapons_map:
                weapons_map[wpn] = len(weapons_list)
                weapons_list.append(wpn)
            return weapons_map[wpn]

        players_data = {}
        for player_name, group in round_df.groupby("name"):
            if not player_name:
                continue

            group_sorted = group.sort_values(by="tick")
            p_id = safe_int(group_sorted.iloc[0].get("user_id"))
            p_team = safe_int(group_sorted.iloc[0].get("team_num"))

            ticks = group_sorted["tick"].astype(int).values
            xs = np.round(group_sorted["X"].values * 10).astype(int)
            ys = np.round(group_sorted["Y"].values * 10).astype(int)
            zs = np.round(group_sorted["Z"].fillna(0).values * 10).astype(int)
            yaws = np.round(group_sorted["yaw"].fillna(0).values * 10).astype(int)
            
            hps = group_sorted["health"].fillna(100).astype(int).values
            arms = group_sorted["armor_value"].fillna(0).astype(int).values
            bals = group_sorted["balance"].fillna(0).astype(int).values
            helms = group_sorted["has_helmet"].fillna(0).astype(int).values
            defkits = group_sorted["has_defuser"].fillna(0).astype(int).values
            ammos = group_sorted["active_weapon_ammo"].fillna(0).astype(int).values

            alives = group_sorted["is_alive"].fillna(True).astype(int).values
            defs = group_sorted["is_defusing"].fillna(False).astype(int).values
            bombs = group_sorted["is_bomb_planted"].fillna(False).astype(int).values

            wpn_ids = [get_weapon_id(w) for w in group_sorted["active_weapon_name"].values]

            inv_list = []
            if "inventory" in group_sorted.columns:
                for inv_item in group_sorted["inventory"].values:
                    if isinstance(inv_item, list):
                        inv_ids = [get_weapon_id(w) for w in inv_item]
                    elif isinstance(inv_item, str) and inv_item.strip():
                        inv_ids = [get_weapon_id(w.strip()) for w in inv_item.split(",")]
                    else:
                        inv_ids = []
                    inv_list.append(inv_ids)
            else:
                inv_list = [[] for _ in range(len(ticks))]

            dt = np.diff(ticks, prepend=0).tolist()
            dx = np.diff(xs, prepend=0).tolist()
            dy = np.diff(ys, prepend=0).tolist()
            dz = np.diff(zs, prepend=0).tolist()
            dyaw = np.diff(yaws, prepend=0).tolist()

            players_data[str(player_name)] = {
                "id": p_id,
                "team": p_team,
                "dt": dt,
                "dx": dx,
                "dy": dy,
                "dz": dz,
                "dyaw": dyaw,
                "hp": hps.tolist(),
                "arm": arms.tolist(),
                "bal": bals.tolist(),
                "helm": helms.tolist(),
                "defkit": defkits.tolist(),
                "ammo": ammos.tolist(),
                "wpn": wpn_ids,
                "inv": inv_list,
                "alive": alives.tolist(),
                "def": defs.tolist(),
                "bomb": bombs.tolist()
            }

        return {
            "weapons": weapons_list,
            "players": players_data
        }

    def get_weapon_fires(self):
        try:
            return clean_dataframe(self.parser.parse_event("weapon_fire"))
        except Exception:
            return []

    def get_kills(self, raw_df=None):
        try:
            records = clean_dataframe(self.parser.parse_event("player_death"))
            for r in records:
                att_team = r.get("attacker_team_num") or r.get("attacker_team") or 0
                vic_team = r.get("user_team_num") or r.get("user_team") or r.get("team_num") or 0
                
                u_id = safe_int(r.get("user_id"))
                u_name = r.get("user_name")
                k_tick = safe_int(r.get("tick"))

                if isinstance(raw_df, pd.DataFrame) and not raw_df.empty:
                    victim_ticks = raw_df[(raw_df["tick"] <= k_tick) & ((raw_df["user_id"] == u_id) | (raw_df["name"] == u_name))]
                    if not victim_ticks.empty:
                        last_vic_pos = victim_ticks.iloc[-1]
                        r["x"] = float(last_vic_pos["X"])
                        r["y"] = float(last_vic_pos["Y"])
                        if not vic_team:
                            vic_team = safe_int(last_vic_pos["team_num"])

                r["attacker_team_num"] = safe_int(att_team, 0)
                r["user_team_num"] = safe_int(vic_team, 0)
            return records
        except Exception:
            return []

    def get_player_blinds(self):
        try:
            records = clean_dataframe(self.parser.parse_event("player_blind"))
            for r in records:
                user_team = r.get("user_team_num") or r.get("team_num") or 2
                r["user_team"] = safe_int(user_team, 2)
            return records
        except Exception:
            return []

    def get_grenade_events(self, raw_df=None, shots=None):
        events = []
        event_types = ["smokegrenade_detonate", "flashbang_detonate", "hegrenade_detonate", "inferno_startburn", "decoy_started"]
        util_keywords = {
            "smokegrenade_detonate": ["smoke"],
            "flashbang_detonate": ["flash"],
            "hegrenade_detonate": ["hegrenade", "he"],
            "inferno_startburn": ["molotov", "incendiary", "fire"],
            "decoy_started": ["decoy"]
        }

        for evt_name in event_types:
            try:
                records = clean_dataframe(self.parser.parse_event(evt_name))
                for r in records:
                    r["event_type"] = evt_name
                    det_tick = safe_int(r.get("tick"))
                    u_id = safe_int(r.get("user_id"))
                    u_name = str(r.get("user_name") or "").strip()

                    if not u_name and u_id > 0:
                        u_name = self.user_id_to_name.get(u_id, "")

                    throw_tick = max(0, det_tick - 180)
                    throw_x, throw_y = None, None
                    keywords = util_keywords.get(evt_name, [])

                    if isinstance(shots, list) and (u_id <= 0 and not u_name):
                        matching_shots = [
                            s for s in shots
                            if any(kw in str(s.get("weapon", "")).lower() for kw in keywords)
                            and 60 <= (det_tick - safe_int(s.get("tick"))) <= 400
                        ]
                        if matching_shots:
                            best_shot = matching_shots[-1]
                            u_id = safe_int(best_shot.get("user_id"))
                            u_name = str(best_shot.get("user_name") or "").strip()
                            throw_tick = safe_int(best_shot.get("tick"))
                    elif isinstance(shots, list) and (u_id > 0 or u_name):
                        matching_shots = [
                            s for s in shots 
                            if ((u_id > 0 and safe_int(s.get("user_id")) == u_id) or (u_name and str(s.get("user_name", "")).strip() == u_name))
                            and 60 <= (det_tick - safe_int(s.get("tick"))) <= 400
                        ]
                        if matching_shots:
                            throw_tick = safe_int(matching_shots[-1].get("tick"))

                    if isinstance(raw_df, pd.DataFrame) and not raw_df.empty and (u_id > 0 or u_name):
                        cond = (raw_df["tick"] <= throw_tick)
                        if u_id > 0:
                            cond &= (raw_df["user_id"] == u_id)
                        else:
                            cond &= (raw_df["name"] == u_name)
                        
                        user_ticks = raw_df[cond]
                        if not user_ticks.empty:
                            last_pos = user_ticks.iloc[-1]
                            throw_x = float(last_pos["X"])
                            throw_y = float(last_pos["Y"])
                            r["user_team"] = safe_int(last_pos["team_num"])
                            if not u_name:
                                u_name = str(last_pos["name"])

                    r["user_id"] = u_id
                    r["user_name"] = u_name
                    r["throw_tick"] = throw_tick
                    if throw_x is not None and throw_y is not None:
                        r["throw_x"] = throw_x
                        r["throw_y"] = throw_y

                    events.append(r)
            except Exception:
                pass
        return events

    def get_bomb_events(self):
        events = []
        for evt_name in ["bomb_planted", "bomb_defused", "bomb_dropped", "bomb_pickup"]:
            try:
                records = clean_dataframe(self.parser.parse_event(evt_name))
                for r in records:
                    r["event_type"] = evt_name
                    events.append(r)
            except Exception:
                pass
        return events

    def get_rounds(self):
        try:
            starts = self.parser.parse_event("round_start")
            freeze_ends = self.parser.parse_event("round_freeze_end")
            ends = self.parser.parse_event("round_end")

            if not hasattr(ends, "iloc") or len(ends) == 0:
                return []

            official_start_tick = 0
            try:
                begin_match = self.parser.parse_event("begin_new_match")
                if hasattr(begin_match, "iloc") and not begin_match.empty:
                    official_start_tick = safe_int(begin_match.iloc[0].get("tick"), 0)
            except Exception:
                pass

            rounds = []
            for i in range(len(ends)):
                end_tick = safe_int(ends.iloc[i].get("tick"))
                if end_tick < official_start_tick:
                    continue

                valid_starts = starts[(starts["tick"] < end_tick) & (starts["tick"] >= official_start_tick)] if hasattr(starts, "iloc") and not starts.empty else pd.DataFrame()
                if valid_starts.empty:
                    valid_starts = starts[starts["tick"] < end_tick] if hasattr(starts, "iloc") and not starts.empty else pd.DataFrame()
                    if valid_starts.empty:
                        continue

                start_tick = safe_int(valid_starts.iloc[-1]["tick"])
                if hasattr(freeze_ends, "iloc") and not freeze_ends.empty:
                    valid_freezes = freeze_ends[(freeze_ends["tick"] >= start_tick) & (freeze_ends["tick"] <= end_tick)]
                    if not valid_freezes.empty:
                        start_tick = safe_int(valid_freezes.iloc[0]["tick"])

                w = ends.iloc[i].get("winner")
                winner = safe_int(w, None)
                if isinstance(w, str):
                    w_upper = w.strip().upper()
                    if w_upper in ["T", "TERRORIST", "2"]:
                        winner = 2
                    elif w_upper in ["CT", "COUNTERTERRORIST", "3"]:
                        winner = 3

                rounds.append({
                    "start": start_tick,
                    "end": end_tick,
                    "winner": winner
                })

            return sanitize_for_json(rounds)
        except Exception as e:
            print(f"Error parsing rounds: {e}")
            return []

def bake_single_demo_file(dem_file_path, file_index, total_files):
    global CURRENT_DEMO_FOLDER, BAKING_STATE
    filename = os.path.basename(dem_file_path)
    demo_hash = get_file_hash(dem_file_path)
    base_name = filename.split('.')[0]

    CURRENT_DEMO_FOLDER = os.path.join(BAKED_BASE_DIR, f"{base_name}_{demo_hash}")
    os.makedirs(CURRENT_DEMO_FOLDER, exist_ok=True)
    meta_file = os.path.join(CURRENT_DEMO_FOLDER, "metadata.json.zst")

    if os.path.exists(meta_file):
        BAKING_STATE.update({
            "step": f"Found Cached Match: {filename}",
            "percent": 100,
            "current_file": file_index,
            "total_files": total_files,
            "current_filename": filename
        })
        return os.path.basename(CURRENT_DEMO_FOLDER)

    parser = CS2DemoParser(dem_file_path)
    clean_map_name = parser.get_map_name()

    BAKING_STATE.update({
        "step": f"Step 1/4: Parsing Tick Positions for {filename}...",
        "percent": 25,
        "current_file": file_index,
        "total_files": total_files,
        "current_filename": filename
    })
    raw_df = parser.get_raw_ticks_df()

    BAKING_STATE.update({
        "step": f"Step 2/4: Extracting Combat Events & Teams...",
        "percent": 50
    })
    rounds = parser.get_rounds()
    shots = parser.get_weapon_fires()
    blinds = parser.get_player_blinds()
    kills = parser.get_kills(raw_df)
    grenades = parser.get_grenade_events(raw_df, shots)
    bomb_events = parser.get_bomb_events()
    team_names = parser.get_team_names(raw_df)

    BAKING_STATE.update({
        "step": f"Step 3/4: Encoding SoA + Delta + Zstd Level 19 ({len(rounds)} Rounds)...",
        "percent": 75
    })
    for idx, r in enumerate(rounds):
        r_start = r["start"]
        r_end = r["end"] if r["end"] else raw_df["tick"].max()
        r_df = raw_df[(raw_df["tick"] >= r_start) & (raw_df["tick"] <= r_end)]
        r_df_sampled = r_df.iloc[::2].reset_index(drop=True)
        soa_delta_data = parser.encode_round_soa_delta(r_df_sampled)

        round_file = os.path.join(CURRENT_DEMO_FOLDER, f"round_{idx}.json.zst")
        json_bytes = json.dumps(soa_delta_data).encode("utf-8")
        with open(round_file, "wb") as f:
            f.write(ZSTD_COMPRESSOR.compress(json_bytes))

    BAKING_STATE.update({
        "step": f"Step 4/4: Finalizing Metadata & Caching...",
        "percent": 95
    })
    metadata = {
        "map_name": clean_map_name,
        "team_names": team_names,
        "rounds": rounds,
        "grenades": grenades,
        "shots": shots,
        "blinds": blinds,
        "kills": kills,
        "bomb_events": bomb_events
    }
    meta_bytes = json.dumps(metadata).encode("utf-8")
    with open(meta_file, "wb") as f:
        f.write(ZSTD_COMPRESSOR.compress(meta_bytes))

    BAKING_STATE.update({"percent": 100, "step": "Bake Complete!"})
    return os.path.basename(CURRENT_DEMO_FOLDER)

def process_and_bake_archive_task(archive_path):
    global BAKING_STATE
    try:
        BAKING_STATE.update({
            "active": True,
            "step": "Unpacking Archive Files...",
            "percent": 10,
            "current_file": 1,
            "total_files": 1,
            "current_filename": os.path.basename(archive_path),
            "error": None
        })

        dem_files = extract_all_demos_from_archive(archive_path)
        total_files = len(dem_files)
        
        last_folder_id = None
        for idx, dem_path in enumerate(dem_files):
            last_folder_id = bake_single_demo_file(dem_path, idx + 1, total_files)

        BAKING_STATE.update({
            "active": False,
            "step": "Complete",
            "percent": 100,
            "last_folder_id": last_folder_id
        })
    except Exception as e:
        print(f"Error during baking pipeline: {e}")
        BAKING_STATE.update({
            "active": False,
            "step": "Error",
            "error": str(e)
        })

# CONFIG API ENDPOINTS
@app.get("/api/config")
def get_config_endpoint():
    return JSONResponse(content=load_user_config())

@app.post("/api/config")
def save_config_endpoint(config_data: dict):
    success = save_user_config(config_data)
    if success:
        return JSONResponse(content={"status": "ok", "config": config_data})
    return JSONResponse(status_code=500, content={"error": "Failed to write config.json."})

@app.get("/api/demos/baking-status")
def get_baking_status():
    return JSONResponse(content=BAKING_STATE)

@app.get("/api/demos/baked")
def get_baked_demos_list():
    demos = []
    if os.path.exists(BAKED_BASE_DIR):
        for folder in os.listdir(BAKED_BASE_DIR):
            folder_path = os.path.join(BAKED_BASE_DIR, folder)
            if os.path.isdir(folder_path):
                meta = read_metadata_from_folder(folder_path)
                if meta:
                    demos.append({
                        "folder_id": folder,
                        "map_name": meta.get("map_name", "Unknown"),
                        "team_names": meta.get("team_names", {"team_2": "Team Alpha", "team_3": "Team Bravo"}),
                        "rounds_count": len(meta.get("rounds", []))
                    })
    return JSONResponse(content=demos)

# HTTP MULTIPART FILE UPLOAD
@app.post("/api/demos/upload")
async def upload_and_bake_demo(file: UploadFile = File(...)):
    save_path = os.path.join(TEMP_UPLOADS_DIR, file.filename)
    with open(save_path, "wb") as buffer:
        shutil.copyfileobj(file.file, buffer)

    threading.Thread(target=process_and_bake_archive_task, args=(save_path,)).start()
    return JSONResponse(content={"status": "started", "file": file.filename})

@app.post("/api/demos/select/{folder_id}")
def select_baked_demo(folder_id: str):
    global CURRENT_DEMO_FOLDER
    folder_path = os.path.join(BAKED_BASE_DIR, folder_id)
    if not os.path.exists(folder_path):
        return JSONResponse(status_code=404, content={"error": "Baked demo folder not found."})
    
    CURRENT_DEMO_FOLDER = folder_path
    meta = read_metadata_from_folder(CURRENT_DEMO_FOLDER)
    return JSONResponse(content={"folder_id": folder_id, "metadata": meta})

@app.get("/api/demo/metadata")
def get_metadata():
    if not CURRENT_DEMO_FOLDER:
        return JSONResponse(status_code=400, content={"error": "No demo currently active."})
    meta_path = os.path.join(CURRENT_DEMO_FOLDER, "metadata.json.zst")
    if os.path.exists(meta_path):
        return FileResponse(meta_path, media_type="application/json", headers={"Content-Encoding": "zstd"})
    return JSONResponse(status_code=404, content={"error": "Metadata not found."})

@app.get("/api/demo/round/{round_idx}")
def get_round_ticks(round_idx: int):
    if not CURRENT_DEMO_FOLDER:
        return JSONResponse(status_code=400, content={"error": "No demo currently active."})
    round_path = os.path.join(CURRENT_DEMO_FOLDER, f"round_{round_idx}.json.zst")
    if os.path.exists(round_path):
        return FileResponse(round_path, media_type="application/json", headers={"Content-Encoding": "zstd"})
    return JSONResponse(status_code=404, content={"error": f"Round {round_idx} not found."})

if __name__ == "__main__":
    print("Starting local Overline API server at http://127.0.0.1:8000")
    uvicorn.run(app, host="127.0.0.1", port=8000)