// Typed client for the FastAPI server (mirrors server/schemas.py).

export type PipelineName = "traditional" | "learned" | "hybrid";
export const PIPELINES: PipelineName[] = ["traditional", "learned", "hybrid"];

export interface Metrics { psnr: number; ssim: number; delta_e: number }

export interface ModelInfo {
  name: string; kind: string; is_stub: boolean; file: string | null; input: string; output: string;
  params: number | null; size_mb: number | null; load_error: string | null;
}
export interface Health { status: string; version: string; model: ModelInfo; max_megapixels: number; samples: number }

export interface SimPreset { noise: number; exposure_ev: number; wb_shift: number }
export interface Sample {
  id: string; name: string; description: string; kind: "sidd" | "image"; has_gt: boolean;
  preset: SimPreset; source: Record<string, string | number>; thumb_url: string;
}

export interface StageOut { name: string; ms: number; note: string; image_url: string }
export interface PipelineOut {
  image_url: string; latency_ms: number; metrics: Metrics | null; stages: StageOut[]; info: Record<string, unknown>;
}
export interface InputInfo {
  name: string; kind: string; source: string; width: number; height: number; orig_width: number; orig_height: number;
  pattern: string; exposure: number; has_gt: boolean; notes: string[]; image_url: string; gt_url: string | null;
  metrics: Metrics | null;
}
export interface Analysis {
  sigma: number; ev: number; clipped: number; wb_conf: number; wb_angle: number | null; dynamic_range: number; mean_level: number;
}
export interface Route {
  path: "fast" | "learned" | "learned_chroma"; label: string; gain: number; wb_method: string; wb_gains: number[];
  local_tone: boolean; sharpen: number; chroma: number; sigma_eff: number; forced: boolean; reasons: string[];
}
export interface ProcessResponse {
  id: string; cached: boolean; input: InputInfo;
  simulate: SimPreset & { seed: number; iso: number };
  analysis: Analysis; route: Route; model: ModelInfo;
  outputs: Record<PipelineName, PipelineOut>;
  timings: Record<string, number>;
}

type Cell = { psnr: number; delta_e: number };

// results/benchmarks.json, written by eval/*.py (the Results tab renders whatever subset exists)
export interface Benchmarks {
  status: "final" | "provisional" | "pending";
  message?: string;
  updated?: string;
  model?: { name: string; params: number; variant: string };
  dataset?: { name: string; test_scenes: string[]; n_images: number; note?: string };
  quality?: { pipeline: string; psnr: number; ssim: number; delta_e: number; lpips?: number | null }[];
  efficiency?: { variant: string; params: number; size_mb: number; latency_ms_1mp: number; peak_mem_mb?: number | null; raw_psnr_db?: number | null }[];
  robustness?: { title: string; x_label: string; x: number[]; series: { pipeline: string; psnr: number[] }[] }[];
  ablation?: { variant: string; psnr: number; ssim: number; delta_e: number; note?: string }[];
  failures?: { title: string; description: string; image_url?: string }[];
  meta?: { subset_n: number; ablation_conditions: string[]; robustness_note: string };
  router?: {
    conditions: string[]; n_images: number;
    modes: { mode: string; psnr: number; delta_e: number; latency_ms: number; network_share: number }[];
    paths_by_iso_as_captured: Record<string, Record<string, number>>;
  };
  breakdown?: Record<"by_phone" | "by_iso", { group: string; n: number; input: Cell; traditional: Cell; learned: Cell; hybrid: Cell }[]>;
  efficiency_sweep?: Record<string, number | string>[];
  tiling?: { image: string; note?: string; variants: { variant: string; latency_ms: number; psnr_vs_single_pass: number; interior_max_abs_diff?: number; interior_psnr?: number }[] };
  phone_raw?: {
    file: string; preview?: string; passed: boolean;
    libraw?: { raw_type: string; cfa: string; black_level_per_channel: number[]; white_level: number };
    route?: { path: string; wb: string };
    checks?: { colour_vs_camera_wb_deg: number };
  }[];
}

export class ApiError extends Error {
  constructor(public code: string, message: string, public hint: string, public status: number) {
    super(message);
  }
}

async function parse<T>(res: Response): Promise<T> {
  let body: unknown = null;
  try {
    body = await res.json();
  } catch {
    /* non-JSON (proxy error page, network cut) */
  }
  if (!res.ok) {
    const err = (body as { error?: { code: string; message: string; hint: string } } | null)?.error;
    if (err) throw new ApiError(err.code, err.message, err.hint, res.status);
    throw new ApiError("http_" + res.status, "The server didn't answer properly.", "Try again in a moment.", res.status);
  }
  return body as T;
}

async function call<T>(url: string, init?: RequestInit): Promise<T> {
  let res: Response;
  try {
    res = await fetch(url, init);
  } catch (e) {
    if ((e as Error).name === "AbortError") throw e;
    throw new ApiError("offline", "Couldn't reach the server.", "Check your connection, then try again.", 0);
  }
  return parse<T>(res);
}

export const getHealth = () => call<Health>("/api/health");
export const getSamples = () => call<Sample[]>("/api/samples");
export const getBenchmarks = () => call<Benchmarks>("/api/benchmarks");

export type RouteMode = "auto" | "learned" | "fast";

export interface ProcessRequest {
  sampleId?: string;
  file?: File;
  sim: SimPreset;
  route: RouteMode;
  signal?: AbortSignal;
}

export function processImage(req: ProcessRequest): Promise<ProcessResponse> {
  const fd = new FormData();
  if (req.file) fd.append("file", req.file, req.file.name);
  else if (req.sampleId) fd.append("sample_id", req.sampleId);
  fd.append("noise", String(req.sim.noise));
  fd.append("exposure_ev", String(req.sim.exposure_ev));
  fd.append("wb_shift", String(req.sim.wb_shift));
  fd.append("force_path", req.route === "auto" ? "auto" : req.route);
  return call<ProcessResponse>("/api/process", { method: "POST", body: fd, signal: req.signal });
}

export const MAX_UPLOAD_MB = 60;
export const ACCEPT =
  ".dng,.cr2,.cr3,.nef,.nrw,.arw,.orf,.rw2,.raf,.pef,.srw,.jpg,.jpeg,.png,.webp,image/jpeg,image/png,image/webp";