// Minimal typed client for the AI War Gaming FastAPI backend.
const BASE = (import.meta as any).env?.VITE_API_BASE ?? '/api';

// Trial password gate: backend may require an X-Trial-Password header.
// We cache the password in localStorage and re-prompt on a 401.
// Local dev has no gate so this is a no-op there.
const PASSWORD_KEY = 'wargame_trial_password';

function getPassword(): string | null {
  try { return localStorage.getItem(PASSWORD_KEY); } catch { return null; }
}
function setPassword(value: string | null): void {
  try {
    if (value === null) localStorage.removeItem(PASSWORD_KEY);
    else localStorage.setItem(PASSWORD_KEY, value);
  } catch { /* private mode etc. — swallow */ }
}
function promptForPassword(): string | null {
  if (typeof window === 'undefined' || typeof window.prompt !== 'function') return null;
  const value = window.prompt('Enter trial access password');
  return value && value.length > 0 ? value : null;
}

async function doFetch(path: string, init: RequestInit | undefined, password: string | null): Promise<Response> {
  const headers: Record<string, string> = {
    'Content-Type': 'application/json',
    ...((init?.headers as Record<string, string> | undefined) || {}),
  };
  if (password) headers['X-Trial-Password'] = password;
  return fetch(`${BASE}${path}`, { ...init, headers });
}

async function req<T>(path: string, init?: RequestInit): Promise<T> {
  let res = await doFetch(path, init, getPassword());
  if (res.status === 401) {
    setPassword(null);
    const next = promptForPassword();
    if (next) {
      setPassword(next);
      res = await doFetch(path, init, next);
    }
  }
  if (!res.ok) {
    const body = await res.text().catch(() => '');
    throw Object.assign(new Error(`${res.status} ${res.statusText}: ${body}`), { status: res.status });
  }
  return res.status === 204 ? (undefined as any) : res.json();
}

export const api = {
  health: () => req<{ status: string }>('/healthz'),
  listScenarios: () => req<{ scenarios: Scenario[] }>('/scenarios'),
  listGames: () => req<{ games: GameSummary[] }>('/games'),
  listModels: () => req<ModelsResponse>('/models'),
  listAgents: (scenario_id: string) =>
    req<AgentsResponse>(`/scenarios/${scenario_id}/agents`),
  createGame: (
    scenario_id: string,
    model?: string,
    role_model_overrides?: Record<string, string>,
    language?: 'en' | 'de',
  ) => {
    const body: Record<string, unknown> = { scenario_id };
    if (model) body.model = model;
    if (role_model_overrides && Object.keys(role_model_overrides).length > 0) {
      body.role_model_overrides = role_model_overrides;
    }
    // ---- i18n (round 6) ----
    if (language) body.language = language;
    return req<{ game_id: string; turn: number; briefing: Briefing }>(`/games`, {
      method: 'POST',
      body: JSON.stringify(body),
    });
  },
  getState: (id: string) => req<StateResponse>(`/games/${id}/state`),
  getBriefing: (id: string) => req<BriefingResponse>(`/games/${id}/briefing`),
  recon: (id: string, agent_id: string, question: string) =>
    req<ReconResponseEnvelope>(`/games/${id}/recon`, {
      method: 'POST', body: JSON.stringify({ agent_id, question }),
    }),
  submitAction: (id: string, action: ActionRequest) =>
    req<ActionAcceptedResponse>(`/games/${id}/actions`, {
      method: 'POST', body: JSON.stringify(action),
    }),
  advance: (id: string) => req<AdvanceResponse>(`/games/${id}/advance`, { method: 'POST' }),
  debrief: (id: string) => req<DebriefResponse>(`/games/${id}/debrief`),
  metrics: (id: string) => req<MetricsTimelineResponse>(`/games/${id}/metrics/timeline`),

  setupStart: (scenario_id: string, initial_message: string) =>
    req<SetupSession>(`/scenarios/setup`, {
      method: 'POST', body: JSON.stringify({ scenario_id, initial_message }),
    }),
  setupGet: (session_id: string) => req<SetupSession>(`/scenarios/setup/${session_id}`),
  setupAnswer: (session_id: string, message: string) =>
    req<SetupSession>(`/scenarios/setup/${session_id}/answer`, {
      method: 'POST', body: JSON.stringify({ message }),
    }),
  setupCommit: (session_id: string, force = false) =>
    req<ScaffoldResponse>(`/scenarios/setup/${session_id}/commit`, {
      method: 'POST', body: JSON.stringify({ force }),
    }),

  fork: (game_id: string, from_turn: number) =>
    req<ForkResponse>(`/games/${game_id}/fork`, {
      method: 'POST', body: JSON.stringify({ from_turn }),
    }),

  orchestrate: (game_id: string, opts?: { branches?: number; turns?: number }) =>
    req<OrchestrateAccepted>(`/games/${game_id}/orchestrate`, {
      method: 'POST',
      body: JSON.stringify({ branches: opts?.branches ?? 3, turns: opts?.turns ?? 1 }),
    }),
  orchestrateStatus: (game_id: string) =>
    req<OrchestrateStatus>(`/games/${game_id}/orchestrate/status`),
  orchestrateResult: (game_id: string) =>
    req<ScenarioMap>(`/games/${game_id}/orchestrate/result`),

  // Action Coach — conversational action input that drafts a 3-anchor
  // ActionSubmission and submits it through the same engine path.
  actionCoachStart: (game_id: string, initial_prose: string) =>
    req<ActionCoachSession>(`/games/${game_id}/actions/coach`, {
      method: 'POST',
      body: JSON.stringify({ initial_prose }),
    }),
  actionCoachLoad: (game_id: string, session_id: string) =>
    req<ActionCoachSession>(`/games/${game_id}/actions/coach/${session_id}`),
  actionCoachAnswer: (game_id: string, session_id: string, message: string) =>
    req<ActionCoachSession>(`/games/${game_id}/actions/coach/${session_id}/answer`, {
      method: 'POST',
      body: JSON.stringify({ message }),
    }),
  actionCoachCommit: (game_id: string, session_id: string) =>
    req<ActionAcceptedResponse>(`/games/${game_id}/actions/coach/${session_id}/commit`, {
      method: 'POST',
    }),

  // ---- forms (5b) ----
  addConstraint: (game_id: string, body: HardConstraintInput) =>
    req<HardConstraintListResponse>(`/games/${game_id}/constraints`, {
      method: 'POST',
      body: JSON.stringify(body),
    }),
  checkAction: (game_id: string, action: ActionRequest) =>
    req<ConstraintCheckResponse>(`/games/${game_id}/check_action`, {
      method: 'POST',
      body: JSON.stringify(action),
    }),
  deleteConstraint: (game_id: string, constraint_id: string, force = false) =>
    req<HardConstraintListResponse>(
      `/games/${game_id}/constraints/${encodeURIComponent(constraint_id)}${force ? '?force=true' : ''}`,
      { method: 'DELETE' },
    ),
  deleteDocument: (session_id: string, filename: string) =>
    req<void>(
      `/scenarios/setup/${session_id}/documents/${encodeURIComponent(filename)}`,
      { method: 'DELETE' },
    ),
  listConstraints: (game_id: string) =>
    req<HardConstraintListResponse>(`/games/${game_id}/constraints`),
  listDocuments: (session_id: string) =>
    req<DocumentListResponse>(`/scenarios/setup/${session_id}/documents`),
  uploadDocument: (session_id: string, file: File) => {
    const fd = new FormData();
    fd.append('file', file);
    // NOTE: don't set Content-Type — the browser fills in the multipart
    // boundary. `req()` defaults to JSON, so we call fetch directly here.
    return fetch(`${BASE}/scenarios/setup/${session_id}/documents`, {
      method: 'POST',
      body: fd,
    }).then(async (res) => {
      if (!res.ok) {
        const body = await res.text().catch(() => '');
        throw Object.assign(
          new Error(`${res.status} ${res.statusText}: ${body}`),
          { status: res.status },
        );
      }
      return res.json() as Promise<UploadedDocument>;
    });
  },

  // ---- live (5b) ----
  pauseGame: (id: string) =>
    req<StateResponse>(`/games/${id}/pause`, { method: 'POST' }),
  resumeGame: (id: string) =>
    req<AdvanceResponse>(`/games/${id}/resume`, { method: 'POST' }),
  // EventSource can't attach custom headers, so the trial password rides in
  // a `?token=` query param instead. The backend middleware accepts either.
  streamUrl: (id: string) => {
    const pw = getPassword();
    const qs = pw ? `?token=${encodeURIComponent(pw)}` : '';
    return `${BASE}/games/${id}/stream${qs}`;
  },
};

export type AnchorKind = 'prior_analogue' | 'stated_capability' | 'resource_committed';
export interface Anchor { kind: AnchorKind; detail: string }
export interface ActionRequest { intent: string; justification: string; anchors: Anchor[] }
export interface ActionAcceptedResponse { game_id: string; turn: number; action: any }
export interface Scenario { scenario_id: string; company_name: string; rival_name: string; industry: string; player_role: string; agent_count: number }
export interface GameSummary { id: string; scenario_id: string; turn: number; max_turns: number; status: 'active' | 'complete'; updated_at: string; llm_model?: string | null }
export interface ModelInfo { id: string; display_name: string; provider: string }
export interface ModelsResponse { models: ModelInfo[]; default: string; roles?: string[] }
export interface AgentInfo { id: string; label: string; kind: string; posture: string }
export interface AgentsResponse { scenario_id: string; agents: AgentInfo[] }
export interface BriefingSection { heading: string; body: string; fog_of_war?: string | null }
export interface DecisionPoint { title: string; context: string; example_actions: string[] }
export interface Briefing { turn: number; headline: string; exec_summary: string; sections: BriefingSection[]; decision_points: DecisionPoint[] }
export interface BriefingResponse { game_id: string; turn: number; briefing: Briefing; recon_budget_remaining: number }
export interface ReconResponseEnvelope { game_id: string; recon_budget_remaining: number; response: { answered_by: string; question: string; answer: string; reveals_to_rival: boolean } }
export interface AdvanceResponse { game_id: string; status: string; turn_resolved: number; next_turn?: number; briefing?: Briefing }
export interface DebriefResponse { game_id: string; status: string; markdown: string }
export interface MetricsTimelineResponse { game_id: string; points: { turn: number; metrics: { key: string; label: string; unit: string; value: number; delta: number }[] }[] }
export interface StateResponse { id: string; scenario_id: string; status: string; world: any; recon_budget_remaining: number; current_phase: string; turns: any[]; language?: 'en' | 'de' }
export interface SetupMessage { role: 'user' | 'setup_agent'; content: string; at: string }
export interface SetupSession {
  session_id: string;
  scenario_id: string;
  status: 'gathering' | 'ready' | 'committed';
  last_agent_message: string;
  synthesized_brief: string | null;
  committed_scenario_id: string | null;
  messages: SetupMessage[];
  doc_filenames?: string[];
}
export interface ScaffoldResponse {
  scenario_id: string;
  target_dir: string;
  mode: 'blank' | 'generated';
  summary: Scenario | null;
}
export interface ForkResponse {
  game_id: string;
  forked_from: string;
  forked_at_turn: number;
  turn: number;
  briefing: Briefing;
}
export type OrchestratorStatus = 'pending' | 'running' | 'complete' | 'failed';
export interface StrategyVector {
  id: string;
  label: string;
  description: string;
  play_style_note: string;
  likely_stumbles: string[];
  priority_metrics: string[];
}
export interface OrchestrateAccepted { map_id: string; status: string }
export interface OrchestrateStatus {
  map_id: string;
  status: OrchestratorStatus;
  branches_complete: number;
  branches_total: number;
  error: string | null;
}
export interface ScenarioMap {
  id: string;
  source_game_id: string;
  scenario_id: string;
  created_at: string;
  updated_at: string;
  vectors: StrategyVector[];
  branches: Array<{
    vector_id: string;
    branch_game_id: string;
    proxy_temperature: number;
    narrative_after?: string;
    skipped?: boolean;
    skip_reason?: string | null;
    turns_played?: number;
  }>;
  synthesis_markdown: string;
  branches_requested: number;
  turns_requested: number;
  status: OrchestratorStatus;
  branches_complete: number;
  error: string | null;
}

// Action Coach — conversational action input.
export interface ActionDraft {
  intent: string;
  justification: string;
  anchors: Anchor[];
}
export interface CoachMessage {
  role: 'user' | 'coach';
  content: string;
  at: string;
}
export type ActionCoachStatus = 'gathering' | 'ready' | 'committed';
export interface ActionCoachSession {
  session_id: string;
  game_id: string;
  turn: number;
  status: ActionCoachStatus;
  rounds_used: number;
  last_coach_message: string;
  synthesized_draft: ActionDraft | null;
  committed: boolean;
  messages: CoachMessage[];
}

// ---- forms (5b) ----
// Hard constraints + uploaded documents + check-action shapes (Round 4 backend).
export type ConstraintSeverity = 'hard' | 'soft';
export type ConstraintSource = 'scenario' | 'document' | 'manual';
export interface HardConstraint {
  id: string;
  description: string;
  rationale: string;
  test_question: string;
  severity: ConstraintSeverity;
  source: ConstraintSource;
  source_ref?: string | null;
}
export interface HardConstraintInput {
  description: string;
  rationale: string;
  test_question: string;
  severity?: ConstraintSeverity;
  source_ref?: string | null;
}
export interface HardConstraintListResponse {
  game_id: string;
  constraints: HardConstraint[];
}
export interface ConstraintViolation {
  constraint_id: string;
  constraint_description: string;
  reason: string;
}
export interface ConstraintCheckResult {
  passes: boolean;
  violations: ConstraintViolation[];
}
export interface ConstraintCheckResponse {
  game_id: string;
  result: ConstraintCheckResult;
}
export interface UploadedDocument {
  filename: string;
  bytes_stored: number;
}
export interface DocumentListResponse {
  session_id: string;
  documents: UploadedDocument[];
}

// ---- live (5b) ----
// PhaseEvent — server-sent events that fire on the engine bus during an
// advance. Discriminated by `kind`. Wire format documented in CONTRACT.md.
export type PhaseEventKind =
  | 'phase_started'
  | 'phase_completed'
  | 'deliberation_complete'
  | 'critic_complete'
  | 'premortem_complete'
  | 'verdict_complete'
  | 'evaluator_complete'
  | 'world_updated'
  | 'briefing_ready'
  | 'usage_tick'
  | 'paused'
  | 'resumed'
  | 'error';

export type VerdictOutcome =
  | 'effect_major'
  | 'effect_minor'
  | 'no_effect'
  | 'backfires';

interface PhaseEventBase {
  game_id: string;
  turn: number;
  label: string;
  at: string;
  payload: Record<string, unknown> & { dropped?: number };
}

export type PhaseEvent =
  | (PhaseEventBase & { kind: 'phase_started'; payload: { dropped?: number } })
  | (PhaseEventBase & { kind: 'phase_completed'; payload: { dropped?: number } })
  | (PhaseEventBase & {
      kind: 'deliberation_complete';
      payload: { agent_id: string; expects: string; fears: string; dropped?: number };
    })
  | (PhaseEventBase & {
      kind: 'critic_complete';
      payload: { count: number; issue_count: number; dropped?: number };
    })
  | (PhaseEventBase & {
      kind: 'premortem_complete';
      payload: { count: number; dropped?: number };
    })
  | (PhaseEventBase & {
      kind: 'verdict_complete';
      payload: {
        actor: string;
        plausibility: number;
        outcome: VerdictOutcome;
        dropped?: number;
      };
    })
  | (PhaseEventBase & {
      kind: 'evaluator_complete';
      payload: { scored: number; dropped?: number };
    })
  | (PhaseEventBase & {
      kind: 'world_updated';
      payload: { media_tone: string; public_narrative: string; dropped?: number };
    })
  | (PhaseEventBase & {
      kind: 'briefing_ready';
      payload: { turn: number; dropped?: number };
    })
  | (PhaseEventBase & {
      kind: 'usage_tick';
      payload: {
        cost_usd_so_far: number;
        input_tokens_so_far: number;
        output_tokens_so_far: number;
        dropped?: number;
      };
    })
  | (PhaseEventBase & {
      kind: 'paused';
      payload: { turn: number; dropped?: number };
    })
  | (PhaseEventBase & {
      kind: 'resumed';
      payload: { dropped?: number };
    })
  | (PhaseEventBase & {
      kind: 'error';
      payload: Record<string, unknown> & { dropped?: number };
    });