faction_war_dispatch_bot/routers/factions.py

#Faction data population and status management endpoints.
import json
from pathlib import Path
from fastapi import APIRouter, Request, HTTPException

from models import FactionRequest
from services.server_state import STATE
from services.torn_api import (
    populate_friendly,
    populate_enemy,
    start_friendly_status_loop,
    start_enemy_status_loop,
    stop_friendly_status_loop,
    stop_enemy_status_loop
)
from services.activity_log import activity_logger
from utils import load_json_list
from utils.auth import get_current_user

router = APIRouter(prefix="/api", tags=["factions"])


@router.post("/populate_friendly")
async def api_populate_friendly(request: Request, data: FactionRequest):
    # Get username for logging
    try:
        user_info = get_current_user(request)
        username = user_info.get("username", "Unknown")
    except:
        username = "Unknown"

    try:
        await activity_logger.log_action(
            username,
            "Populate Friendly",
            f"Starting population for faction {data.faction_id}"
        )

        result = await populate_friendly(data.faction_id)

        if not result:
            await activity_logger.log_action(
                username,
                "Populate Friendly Failed",
                f"Failed to populate faction {data.faction_id} - API returned False (check API key, faction ID, or network)"
            )
            raise HTTPException(status_code=500, detail="Failed to populate friendly faction - check logs")

        # Return members list for frontend (already in STATE from populate_friendly)
        members = [m.model_dump() for m in STATE.friendly.values()]

        await activity_logger.log_action(
            username,
            "Populate Friendly Success",
            f"Populated {len(members)} members from faction {data.faction_id}"
        )

        return {"status": "friendly populated", "id": data.faction_id, "members": members}

    except HTTPException:
        raise
    except Exception as e:
        error_msg = f"Error populating friendly faction {data.faction_id}: {type(e).__name__}: {str(e)}"
        await activity_logger.log_action(username, "Populate Friendly Error", error_msg)
        raise HTTPException(status_code=500, detail=error_msg)


@router.post("/populate_enemy")
async def api_populate_enemy(request: Request, data: FactionRequest):
    # Get username for logging
    try:
        user_info = get_current_user(request)
        username = user_info.get("username", "Unknown")
    except:
        username = "Unknown"

    try:
        await activity_logger.log_action(
            username,
            "Populate Enemy",
            f"Starting population for faction {data.faction_id}"
        )

        result = await populate_enemy(data.faction_id)

        if not result:
            await activity_logger.log_action(
                username,
                "Populate Enemy Failed",
                f"Failed to populate faction {data.faction_id} - API returned False (check API key, faction ID, or network)"
            )
            raise HTTPException(status_code=500, detail="Failed to populate enemy faction - check logs")

        # Return members list for frontend (already in STATE from populate_enemy)
        members = [m.model_dump() for m in STATE.enemy.values()]

        await activity_logger.log_action(
            username,
            "Populate Enemy Success",
            f"Populated {len(members)} members from faction {data.faction_id}"
        )

        return {"status": "enemy populated", "id": data.faction_id, "members": members}

    except HTTPException:
        raise
    except Exception as e:
        error_msg = f"Error populating enemy faction {data.faction_id}: {type(e).__name__}: {str(e)}"
        await activity_logger.log_action(username, "Populate Enemy Error", error_msg)
        raise HTTPException(status_code=500, detail=error_msg)


@router.post("/start_friendly_status")
async def api_start_friendly_status(data: FactionRequest):
    await start_friendly_status_loop(data.faction_id, data.interval)
    return {"status": "friendly status loop started", "id": data.faction_id, "interval": data.interval}


@router.post("/start_enemy_status")
async def api_start_enemy_status(data: FactionRequest):
    await start_enemy_status_loop(data.faction_id, data.interval)
    return {"status": "enemy status loop started", "id": data.faction_id, "interval": data.interval}


@router.get("/friendly_members")
async def get_friendly_members():
    # Return list, but prefer STATE if populated
    if STATE.friendly:
        return [m.model_dump() for m in STATE.friendly.values()]
    # fallback to file
    path = Path("data/friendly_members.json")
    return load_json_list(path)


@router.get("/enemy_members")
async def get_enemy_members():
    if STATE.enemy:
        return [m.model_dump() for m in STATE.enemy.values()]
    path = Path("data/enemy_members.json")
    return load_json_list(path)


@router.get("/friendly_status")
async def api_friendly_status():
    path = Path("data/friendly_status.json")
    if not path.exists():
        return {}
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)


@router.get("/enemy_status")
async def api_enemy_status():
    path = Path("data/enemy_status.json")
    if not path.exists():
        return {}
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)


@router.post("/stop_friendly_status")
async def api_stop_friendly_status():
    await stop_friendly_status_loop()
    return {"status": "friendly status loop stopped"}


@router.post("/stop_enemy_status")
async def api_stop_enemy_status():
    await stop_enemy_status_loop()
    return {"status": "enemy status loop stopped"}


@router.get("/dashboard_state")
async def get_dashboard_state():
    """Get current dashboard state for restoring UI on page load"""
    return {
        "friendly_faction_id": STATE.friendly_faction_id,
        "enemy_faction_id": STATE.enemy_faction_id,
        "friendly_members": [m.model_dump() for m in STATE.friendly.values()],
        "enemy_members": [m.model_dump() for m in STATE.enemy.values()],
        "friendly_status_interval": STATE.friendly_status_interval,
        "enemy_status_interval": STATE.enemy_status_interval,
        "friendly_status_running": STATE.friendly_status_running,
        "enemy_status_running": STATE.enemy_status_running
    }