CausalGame/api/admin/endpoints.py

"""
Admin API Endpoints - Full visibility for frontend/admin.

These endpoints return COMPLETE data including:
- HP values
- Agility
- Detection probability
- SCM configuration
- All internal state

Used by:
- Frontend dashboard
- Admin tools
- Debugging
"""

from fastapi import APIRouter, HTTPException, Depends
from pydantic import BaseModel
from typing import Dict, Any, Optional, List
from pathlib import Path
import json
import os
import logging

logger = logging.getLogger(__name__)

from ..modules.agent.session import SessionManager
from ..modules.agent.endpoints import get_session_manager
from ..modules.agent.action_space import DeployAction
from ..modules.environment.scm_registry import list_experiments, get_scm_info
from ..utils.timezone import get_timezone_name, now_iso
from ..security import require_admin_token


# Router for admin endpoints. Every route on this prefix requires a valid
# X-Admin-Token header — see api/security.py.
router = APIRouter(
    prefix="/api/admin",
    tags=["admin"],
    dependencies=[Depends(require_admin_token)],
)


# ============================================================
# Response Models
# ============================================================

class AdminStatusResponse(BaseModel):
    """Full status response for admin."""
    api_version: str = "v2"
    experiment_name: str
    experiment_type: str

    # Resource status
    drones_remaining: int
    drones_used: int
    total_drones: int

    # Deployment budget (optional)
    deployments_used: int = 0
    deployments_remaining: Optional[int] = None
    stage1_deployment_budget: Optional[int] = None

    # Environment query budget
    env_queries_used: int = 0
    env_queries_remaining: int = 10
    env_query_budget: int = 10

    # Hidden values (visible to admin)
    hidden_hp_values: Optional[Dict[str, int]] = None
    agility_config: Optional[Dict[str, float]] = None

    # Session info
    stage: int
    game_over: bool
    history_count: int
    survivors: int

    # Scoring info
    victory_threshold: float
    stage2_fleet_size: int

    # Final evaluation result (for Stage 2)
    final_evaluation: Optional[Dict[str, Any]] = None


class ExperimentInfo(BaseModel):
    """Information about an experiment."""
    name: str
    display_name: str
    description: Optional[str] = None
    version: Optional[str] = None
    author: Optional[str] = None
    scm_class: Optional[str] = None
    path: Optional[str] = None
    is_default: bool = False
    tags: Optional[List[str]] = None


class VisibilityUpdateRequest(BaseModel):
    """Request to update field visibility."""
    field: str
    visibility: str  # "agent", "agent_readonly", "admin", "hidden"


class TestDeployRequest(BaseModel):
    """Request for admin test deployment."""
    design: Dict[str, int]
    count: int = 1
    equipment: Optional[Dict[str, str]] = None
    session_id: Optional[str] = None  # If not provided, uses default session


class ForceSubmitRequest(BaseModel):
    """Request for admin force-submit (auto-submit when agent fails to submit)."""
    design: Dict[str, int]
    equipment: Optional[Dict[str, str]] = None
    session_id: str  # Required - must specify which session to submit for


# ============================================================
# Admin Endpoints
# ============================================================

@router.get("/mission_status")
async def admin_mission_status(
    manager: SessionManager = Depends(get_session_manager)
) -> AdminStatusResponse:
    """
    Get full mission status (admin view).

    Returns ALL data including hidden values.
    """
    session = manager.get_or_create_default_session()
    action_space = manager.get_action_space(session.session_id)

    if action_space is None:
        raise HTTPException(status_code=500, detail="Not initialized")

    status = action_space._get_status()
    config = action_space.config

    # Get hidden values from config
    hidden_hp = config.get('drone', {}).get('components', {})
    hidden_hp_values = {k: v.get('hp', 50) for k, v in hidden_hp.items()} if hidden_hp else None

    # Deployment budget info
    deployment_budget = session.stage1_deployment_budget
    deployments_remaining = (deployment_budget - session.deployments_used) if deployment_budget else None

    return AdminStatusResponse(
        api_version="v2",
        experiment_name=session.experiment_name,
        experiment_type="def_based",
        drones_remaining=status['drones_remaining'],
        drones_used=session.drones_used,
        total_drones=status['total_drones'],
        deployments_used=session.deployments_used,
        deployments_remaining=deployments_remaining,
        stage1_deployment_budget=deployment_budget,
        env_queries_used=session.env_queries_used,
        env_queries_remaining=session.env_query_budget - session.env_queries_used,
        env_query_budget=session.env_query_budget,
        hidden_hp_values=hidden_hp_values,
        agility_config=config.get('agility_system'),
        stage=session.stage,
        game_over=session.game_over,
        history_count=status['history_count'],
        survivors=sum(1 for f in session.flight_history if f.get('status') == 'RETURNED'),
        victory_threshold=status['victory_threshold'],
        stage2_fleet_size=status['stage2_fleet_size'],
        final_evaluation=session.final_result,
    )


@router.get("/experiments")
async def list_available_experiments() -> List[ExperimentInfo]:
    """
    List all available experiments with full metadata from game.json.
    """
    experiments = []
    experiments_dir = Path(__file__).parent.parent.parent / "experiments"
    default_experiment = os.environ.get("CAUSALGAME_EXPERIMENT", "antenna_trap")

    # Get registered SCMs
    scm_list = list_experiments()

    # Build experiments list from experiments directory
    if experiments_dir.exists():
        for exp_dir in experiments_dir.iterdir():
            if exp_dir.is_dir() and (exp_dir / "game.json").exists():
                name = exp_dir.name
                config_path = exp_dir / "game.json"

                # Load metadata from game.json
                display_name = name.replace('_', ' ').title()
                description = None
                version = None
                author = None
                tags = None

                try:
                    with open(config_path) as f:
                        config = json.load(f)
                        exp_info = config.get('experiment', {})
                        display_name = exp_info.get('display_name', display_name)
                        description = exp_info.get('description')
                        version = exp_info.get('version')
                        author = exp_info.get('author')
                        tags = exp_info.get('tags')
                except Exception:
                    pass

                # Get SCM class name
                scm_class = scm_list.get(name, 'Unknown')

                experiments.append(ExperimentInfo(
                    name=name,
                    display_name=display_name,
                    description=description,
                    version=version,
                    author=author,
                    scm_class=scm_class,
                    path=str(config_path),
                    is_default=(name == default_experiment),
                    tags=tags
                ))

    # Add any registered SCMs that don't have a config directory
    for name, class_name in scm_list.items():
        if not any(e.name == name for e in experiments):
            experiments.append(ExperimentInfo(
                name=name,
                display_name=name.replace('_', ' ').title(),
                scm_class=class_name,
                is_default=(name == default_experiment)
            ))

    return experiments


@router.get("/experiment/current")
async def get_current_experiment(
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get currently active experiment info.

    Returns experiment name, display name, SCM class, and architecture info.
    """
    session = manager.get_or_create_default_session()
    experiment_name = session.experiment_name

    # Get SCM info
    info = get_scm_info(experiment_name)
    scm_class = info.get('class_name', 'Unknown') if info else 'Unknown'

    # Load experiment config for display name
    config_path = Path(__file__).parent.parent.parent / "experiments" / experiment_name / "game.json"
    display_name = experiment_name.replace('_', ' ').title()

    if config_path.exists():
        try:
            with open(config_path) as f:
                config = json.load(f)
                exp_info = config.get('experiment', {})
                display_name = exp_info.get('display_name', display_name)
        except Exception:
            pass

    # Detect architecture (layered vs flat)
    is_layered = scm_class.startswith('Layered') if scm_class else False

    return {
        "name": experiment_name,
        "display_name": display_name,
        "scm_class": scm_class,
        "architecture": {
            "mode": "layered" if is_layered else "flat",
            "is_layered": is_layered
        }
    }


@router.post("/experiment/switch")
async def switch_experiment(
    experiment_name: str,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, str]:
    """
    Switch to a different experiment.

    This resets the current session with new experiment config.
    """
    # Verify experiment exists
    info = get_scm_info(experiment_name)

    # Check config file exists
    config_path = Path(__file__).parent.parent.parent / "experiments" / experiment_name / "game.json"

    if info is None and not config_path.exists():
        raise HTTPException(
            status_code=404,
            detail=f"Experiment '{experiment_name}' not found"
        )

    # Update environment variable for next restart
    os.environ["CAUSALGAME_EXPERIMENT"] = experiment_name

    # Load new experiment config
    new_config = {}
    if config_path.exists():
        try:
            with open(config_path) as f:
                new_config = json.load(f)
        except Exception as e:
            logger.warning(f"Failed to load config for {experiment_name}: {e}")

    # Switch experiment with new config (creates new SCM and action_space)
    manager.switch_experiment(experiment_name, new_config)

    return {
        "status": "switched",
        "experiment": experiment_name,
        "message": f"Switched to {experiment_name}. Session reset."
    }


@router.get("/scm_model")
async def get_scm_model(
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get SCM structure for frontend visualization.

    Returns data in the format expected by GameMechanics.tsx:
    - variables: List of causal variables with is_exogenous, description, parents
    - equations: List of structural equations with description and source_code
    - game_parameters: Game configuration parameters
    - causal_graph_text: Human-readable description of the SCM
    """
    session = manager.get_or_create_default_session()
    experiment = session.experiment_name

    info = get_scm_info(experiment)
    if info is None:
        return {"error": f"No SCM found for {experiment}"}

    # Load game config
    config_path = Path(__file__).parent.parent.parent / "experiments" / experiment / "game.json"
    config: Dict[str, Any] = {}
    if config_path.exists():
        try:
            with open(config_path) as f:
                config = json.load(f)
        except Exception:
            pass

    try:
        from ..modules.environment.scm_registry import get_scm_for_experiment
        import inspect

        scm = get_scm_for_experiment(experiment, config)

        # Build variables list in frontend-expected format
        variables = []
        for var in scm._causal_variables.values():
            # Exogenous = no parents in the causal graph (not caused by other variables)
            # Note: 'latent' means hidden from agent, not exogenous
            is_exogenous = not var.parents
            variables.append({
                "name": var.name,
                "is_exogenous": is_exogenous,
                "description": var.description,
                "parents": var.parents,
            })

        # Build equations list with source code
        equations = []
        for eq in scm._equations.values():
            # Try to get source code for the equation function
            source_code = None
            try:
                source_code = inspect.getsource(eq.function)
            except Exception:
                pass

            equations.append({
                "target": eq.target,
                "description": eq.description,
                "source_code": source_code,
            })

        # Build game_parameters from config
        drone_config = config.get('drone', {})
        components = drone_config.get('components', {})
        scm_params = config.get('scm', {}).get('parameters', {})

        # Extract critical components
        critical_components = [
            name for name, comp in components.items()
            if comp.get('is_critical', False)
        ]

        # Build standard design
        standard_design = drone_config.get('standard_design', {})

        # Calculate total HP budget (sum of all component HPs)
        total_hp_budget = sum(comp.get('hp', 0) for comp in components.values())

        # Build detection mechanism info from SCM params
        detection_mechanism = {
            "description": "Antenna signal affects detection probability",
            "formula": f"detection = base + antenna_boost * signal_strength",
            "signal_strength": f"signal = min(1, antenna_hp / 50)",
            "high_wind_threshold": f"{scm_params.get('wind_threshold_high', 35)} km/h",
        }

        # Build damage sources
        damage_sources = {
            "environmental": {
                "high_wind": f"Wind > {scm_params.get('wind_threshold_high', 35)} km/h causes antenna damage",
                "medium_wind": f"Wind > {scm_params.get('wind_threshold_low', 20)} km/h causes moderate damage",
                "storm": "Storm weather damages critical components",
            },
            "combat": {
                "precision_strike": "When detected, targeted attacks on components",
                "scattered_fire": "Random damage distribution when detected",
            }
        }

        game_parameters = {
            "standard_design": standard_design,
            "total_drone_budget": config.get('resources', {}).get('total_drone_budget', 200),
            "total_hp_budget": total_hp_budget,
            "min_hp_per_part": 0,
            "critical_components": critical_components,
            "detection_mechanism": detection_mechanism,
            "damage_sources": damage_sources,
        }

        return {
            "variables": variables,
            "equations": equations,
            "game_parameters": game_parameters,
            "causal_graph_text": scm.describe(),
        }

    except Exception as e:
        import traceback
        return {
            "error": str(e),
            "traceback": traceback.format_exc(),
            "experiment": experiment,
            "scm_class": info.get('class_name'),
        }


@router.get("/config")
async def get_experiment_config(
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get current experiment configuration.
    """
    session = manager.get_or_create_default_session()
    action_space = manager.get_action_space(session.session_id)

    if action_space is None:
        return {"error": "Not initialized"}

    return {
        "experiment": session.experiment_name,
        "config": action_space.config
    }


@router.get("/config/game")
async def get_game_config(
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get game.json configuration for current experiment.

    Used by GameManagement settings page.
    """
    session = manager.get_or_create_default_session()
    experiment_name = session.experiment_name

    config_path = Path(__file__).parent.parent.parent / "experiments" / experiment_name / "game.json"

    if not config_path.exists():
        raise HTTPException(status_code=404, detail=f"game.json not found for experiment '{experiment_name}'")

    try:
        with open(config_path) as f:
            return json.load(f)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to load game.json: {str(e)}")


@router.put("/config/game")
async def update_game_config(
    config: Dict[str, Any],
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, str]:
    """
    Update game.json configuration for current experiment.

    Note: Changes won't take effect until game reset.
    """
    session = manager.get_or_create_default_session()
    experiment_name = session.experiment_name

    config_path = Path(__file__).parent.parent.parent / "experiments" / experiment_name / "game.json"

    if not config_path.exists():
        raise HTTPException(status_code=404, detail=f"game.json not found for experiment '{experiment_name}'")

    try:
        with open(config_path, 'w') as f:
            json.dump(config, f, indent=2)
        return {"status": "saved", "message": "game.json updated. Reset game to apply changes."}
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to save game.json: {str(e)}")


@router.get("/config/environment_variables")
async def get_environment_variables_config(
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get environment_variables.json configuration for current experiment.

    Used by GameManagement environment variables editor.
    """
    session = manager.get_or_create_default_session()
    experiment_name = session.experiment_name

    config_path = Path(__file__).parent.parent.parent / "experiments" / experiment_name / "environment_variables.json"

    if not config_path.exists():
        raise HTTPException(status_code=404, detail=f"environment_variables.json not found for experiment '{experiment_name}'")

    try:
        with open(config_path) as f:
            return json.load(f)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to load environment_variables.json: {str(e)}")


@router.put("/config/environment_variables")
async def update_environment_variables_config(
    config: Dict[str, Any],
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, str]:
    """
    Update environment_variables.json configuration for current experiment.

    Note: Changes won't take effect until game reset.
    """
    session = manager.get_or_create_default_session()
    experiment_name = session.experiment_name

    config_path = Path(__file__).parent.parent.parent / "experiments" / experiment_name / "environment_variables.json"

    if not config_path.exists():
        raise HTTPException(status_code=404, detail=f"environment_variables.json not found for experiment '{experiment_name}'")

    try:
        with open(config_path, 'w') as f:
            json.dump(config, f, indent=2)
        return {"status": "saved", "message": "environment_variables.json updated. Reset game to apply changes."}
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to save environment_variables.json: {str(e)}")


@router.get("/config/status")
async def get_config_status(
    session_id: Optional[str] = None,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get whether config can be modified.

    Args:
        session_id: Optional session ID. If provided, checks that specific session.
                   Otherwise checks the default session.

    Config can be modified when:
    - Game is over (game_over = true), OR
    - No flights have been made yet (history_count = 0)
    """
    if session_id:
        session = manager.get_session(session_id)
        if session is None:
            raise HTTPException(status_code=404, detail=f"Session '{session_id}' not found")
    else:
        session = manager.get_or_create_default_session()

    # Can modify if game is over or no activity yet
    can_modify = session.game_over or len(session.flight_history) == 0

    return {
        "can_modify": can_modify,
        "game_over": session.game_over,
        "history_count": len(session.flight_history),
        "session_id": session.session_id,
        "reason": "Game is over" if session.game_over else ("No flights yet" if len(session.flight_history) == 0 else "Agent is active")
    }


@router.get("/sessions")
async def list_sessions(
    manager: SessionManager = Depends(get_session_manager)
) -> List[Dict[str, Any]]:
    """
    List all active sessions.
    """
    return manager.list_sessions()


@router.get("/sessions/{session_id}")
async def get_session_detail(
    session_id: str,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get detailed information about a specific session.
    """
    session = manager.get_session(session_id)
    if session is None:
        raise HTTPException(status_code=404, detail=f"Session '{session_id}' not found")

    action_space = manager.get_action_space(session_id)
    status = action_space._get_status() if action_space else {}

    # Add session-level fields to status for frontend compatibility
    status['game_over'] = session.game_over
    status['final_evaluation'] = session.final_result
    status['env_queries_used'] = session.env_queries_used
    status['env_queries_remaining'] = session.env_query_budget - session.env_queries_used
    status['env_query_budget'] = session.env_query_budget

    return {
        **session.to_dict(),
        "status": status,
        "logs": session.logs,  # All logs (frontend handles scrolling)
        "recent_flights": session.flight_history[-10:],  # Last 10 flights
    }


@router.delete("/sessions/{session_id}")
async def delete_session(
    session_id: str,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, str]:
    """
    Delete a specific session.
    """
    if session_id == "default":
        raise HTTPException(status_code=400, detail="Cannot delete default session")

    if not manager.delete_session(session_id):
        raise HTTPException(status_code=404, detail=f"Session '{session_id}' not found")

    return {"status": "deleted", "session_id": session_id}


@router.delete("/sessions/{session_id}/test-data")
async def delete_test_data(
    session_id: str,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Delete all test flights from a session.

    Test flights are deployments made with is_test=true flag.
    This allows cleaning up test data without affecting real agent data.
    """
    session = manager.get_session(session_id)
    if session is None:
        raise HTTPException(status_code=404, detail=f"Session '{session_id}' not found")

    deleted_count = manager.delete_test_flights(session_id)

    return {
        "status": "deleted",
        "session_id": session_id,
        "deleted_flights": deleted_count,
        "remaining_flights": len(session.flight_history),
        "message": f"Deleted {deleted_count} test flights"
    }


@router.get("/sessions/{session_id}/test-data/count")
async def get_test_data_count(
    session_id: str,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get the count of test flights in a session.
    """
    session = manager.get_session(session_id)
    if session is None:
        raise HTTPException(status_code=404, detail=f"Session '{session_id}' not found")

    return {
        "session_id": session_id,
        "test_flights": session.get_test_flight_count()
    }


@router.post("/sessions/{session_id}/clear-error")
async def clear_session_error(
    session_id: str,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Clear error state from a session to allow resuming.

    This resets game_over to False and clears the error message,
    allowing the session to continue from where it left off.
    """
    session = manager.get_session(session_id)
    if session is None:
        raise HTTPException(status_code=404, detail=f"Session '{session_id}' not found")

    if not session.error:
        return {
            "status": "no_change",
            "session_id": session_id,
            "message": "Session has no error to clear"
        }

    old_error = session.error
    session.error = None
    session.game_over = False
    manager._save_session(session_id)

    return {
        "status": "cleared",
        "session_id": session_id,
        "previous_error": old_error,
        "message": "Error cleared, session can be resumed"
    }


@router.post("/test-deploy")
async def admin_test_deploy(
    request: TestDeployRequest,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Admin-only test deployment endpoint.

    Deploys drones marked as test data, which can be deleted later
    without affecting real agent data. Used for testing game mechanics.

    This endpoint does NOT consume drone budget or deployment budget.
    """
    # Get session
    if request.session_id:
        session = manager.get_session(request.session_id)
        if session is None:
            raise HTTPException(status_code=404, detail=f"Session '{request.session_id}' not found")
    else:
        session = manager.get_or_create_default_session()

    action_space = manager.get_action_space(session.session_id)
    if action_space is None:
        raise HTTPException(status_code=500, detail="Action space not found")

    # Execute deployment (but don't consume budget)
    action = DeployAction(
        design=request.design,
        count=request.count,
        equipment=request.equipment or {}
    )

    # Directly call internal method with is_test=True to bypass budget checks
    result = action_space._execute_deploy(action, is_test=True)

    if not result.success:
        raise HTTPException(status_code=400, detail=result.error)

    # Add to history with is_test flag (don't update drone counts)
    for r in result.full_results:
        r['is_test'] = True
        session.add_flight(r)

    # Add test deployment log
    session.add_log(
        log_type="TEST_DEPLOYMENT",
        content=f"[ADMIN TEST] Deployed {result.deployed} test drones",
        metadata={
            "design": request.design,
            "count": request.count,
            "deployed": result.deployed,
            "survived": result.survived,
            "destroyed": result.destroyed,
            "is_test": True,
        }
    )

    # Save session
    manager._save_session(session.session_id)

    return {
        "status": "TEST_COMPLETE",
        "deployed": result.deployed,
        "survived": result.survived,
        "destroyed": result.destroyed,
        "survival_rate": f"{(result.survived / result.deployed * 100):.1f}%" if result.deployed > 0 else "0%",
        "average_hit_count": result.average_hit_count,
        "results": result.results,
        "environment": result.environment,
        "is_test": True,
        "note": "Test deployment - does not consume budget, can be deleted"
    }


@router.post("/force-submit")
async def admin_force_submit(
    request: ForceSubmitRequest,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Admin-only force submission endpoint.

    This allows submitting a final design even when game_over=True (e.g., when
    drones are exhausted). Used by run_agent.py for auto-submit when the agent
    fails to submit on its own.

    Unlike the agent endpoint, this bypasses the game_over check but still
    requires that no final_result exists yet.
    """
    session = manager.get_session(request.session_id)
    if session is None:
        raise HTTPException(status_code=404, detail=f"Session '{request.session_id}' not found")

    # Check if already has final result
    if session.final_result is not None:
        raise HTTPException(
            status_code=400,
            detail="Session already has final result. Cannot submit again."
        )

    action_space = manager.get_action_space(request.session_id)
    if action_space is None:
        raise HTTPException(status_code=500, detail="Action space not found")

    # Import SubmitAction here to avoid circular imports
    from ..modules.agent.action_space import SubmitAction

    # Execute submission
    action = SubmitAction(
        design=request.design,
        equipment=request.equipment or {}
    )
    result = action_space.execute(action)

    if not result.success:
        raise HTTPException(status_code=400, detail=result.error)

    # Update session
    session.stage = 2
    session.game_over = True

    # Calculate DEF efficiency
    total_def = sum(request.design.values())
    def_efficiency = 1.0 - min(1.0, total_def / 300)

    session.final_result = {
        'status': 'EVALUATION_COMPLETE',
        'design_tested': request.design.copy(),
        'fleet_size': result.fleet_size,
        'total_drones': result.fleet_size,
        'survived': result.survived,
        'survival_rate': f"{result.survival_rate * 100:.1f}%",
        'final_score': f"{result.final_score * 100:.1f}%",
        'def_efficiency': f"{def_efficiency * 100:.1f}%",
        'total_def': total_def,
        'victory': result.victory,
        'victory_threshold': result.victory_threshold,
    }

    # Add log entry for force-submit
    session.add_log(
        log_type="ADMIN_FORCE_SUBMIT",
        content=f"[ADMIN] Force-submitted design: survival_rate={result.survival_rate*100:.1f}%",
        metadata={
            "design": request.design,
            "survived": result.survived,
            "fleet_size": result.fleet_size,
            "victory": result.victory,
        }
    )

    # Save session
    manager._save_session(request.session_id)

    return {
        "status": "FORCE_SUBMIT_COMPLETE",
        "session_id": request.session_id,
        "design_tested": request.design,
        "fleet_size": result.fleet_size,
        "survived": result.survived,
        "survival_rate": f"{result.survival_rate * 100:.1f}%",
        "victory": result.victory,
        "victory_threshold": result.victory_threshold,
    }


@router.delete("/sessions")
async def delete_all_sessions(
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Delete all sessions (except the internal default session).

    This permanently removes all session data from persistence storage.
    """
    deleted_count = manager.delete_all_sessions()
    return {
        "status": "deleted",
        "deleted_count": deleted_count,
        "message": f"Deleted {deleted_count} sessions"
    }


@router.post("/sessions/cleanup")
async def cleanup_sessions(
    max_age_seconds: int = 3600,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Clean up inactive sessions.

    Args:
        max_age_seconds: Sessions inactive for longer than this will be removed (default 1 hour)
    """
    removed = manager.cleanup_inactive(max_age_seconds)
    return {
        "status": "cleaned",
        "removed_count": removed,
        "remaining_sessions": len(manager.list_sessions())
    }


@router.get("/statistics")
async def get_statistics(
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, Any]:
    """
    Get global statistics across all sessions.
    """
    return manager.get_statistics()


@router.get("/agent/logs")
async def get_agent_logs(
    session_id: Optional[str] = None,
    manager: SessionManager = Depends(get_session_manager)
) -> List[Dict[str, Any]]:
    """
    Get agent logs.

    If session_id is provided, returns logs for that session.
    Otherwise, returns logs from the most recently active non-default session,
    or default session if no other sessions exist.
    """
    if session_id:
        session = manager.get_session(session_id)
        if session:
            return session.logs
        raise HTTPException(status_code=404, detail=f"Session '{session_id}' not found")

    # Get all sessions and find the most recently active non-default one
    all_sessions = list(manager._sessions.values())
    non_default_sessions = [s for s in all_sessions if s.session_id != "default"]

    if non_default_sessions:
        # Sort by last_activity descending and return logs from most recent
        most_recent = max(non_default_sessions, key=lambda s: s.last_activity)
        return most_recent.logs

    # Fallback to default session
    session = manager.get_or_create_default_session()
    return session.logs


@router.get("/flight_history")
async def get_full_flight_history(
    manager: SessionManager = Depends(get_session_manager)
) -> List[Dict[str, Any]]:
    """
    Get complete flight history with all details.

    Unlike agent endpoint, this includes HP and other hidden data.
    """
    session = manager.get_or_create_default_session()

    # For admin, we might want to enhance the history with more details
    # For now, return the same data
    return session.flight_history


@router.put("/visibility")
async def update_visibility(
    request: VisibilityUpdateRequest,
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, str]:
    """
    Update visibility for a field.

    Allows admin to change what agent can see.
    """
    from ..middleware.visibility import Visibility

    # Validate visibility value
    try:
        vis = Visibility(request.visibility)
    except ValueError:
        raise HTTPException(
            status_code=400,
            detail=f"Invalid visibility: {request.visibility}. "
                   f"Must be one of: agent, agent_readonly, admin, hidden"
        )

    # This would need to be propagated to DroneSheet instances
    # For now, just acknowledge
    return {
        "status": "updated",
        "field": request.field,
        "visibility": request.visibility,
        "note": "Visibility changes apply to new drones only"
    }


@router.post("/reset")
async def admin_reset(
    manager: SessionManager = Depends(get_session_manager)
) -> Dict[str, str]:
    """
    Admin reset - clears all sessions.
    """
    session = manager.get_or_create_default_session()
    manager.reset_session(session.session_id)

    return {"status": "reset", "message": "All sessions cleared"}


@router.get("/server_config")
async def get_server_config() -> Dict[str, Any]:
    """
    Get server configuration including timezone.

    Frontend should use this to display times consistently.
    """
    return {
        "timezone": get_timezone_name(),
        "server_time": now_iso(),
    }