function resolveBase(): string {

  const override = process.env.NEXT_PUBLIC_API_BASE;

  if (override && override !== "http://localhost:8000/api/v1") return override;

  if (typeof window !== "undefined") {

    return `${window.location.protocol}//${window.location.hostname}:8000/api/v1`;

  }

  return override || "http://localhost:8000/api/v1";

}

const BASE = resolveBase();

const TOKEN_KEY = "sightline_token";

export function getToken(): string | null {

  if (typeof window === "undefined") return null;

  return window.localStorage.getItem(TOKEN_KEY);

}

export function setToken(t: string) {

  window.localStorage.setItem(TOKEN_KEY, t);

}

export function clearToken() {

  window.localStorage.removeItem(TOKEN_KEY);

}

async function req<T>(path: string, init: RequestInit = {}): Promise<T> {

  const headers = new Headers(init.headers);

  const token = getToken();

  if (token) headers.set("Authorization", `Bearer ${token}`);

  if (!headers.has("Content-Type") && init.body && !(init.body instanceof FormData)) {

    headers.set("Content-Type", "application/json");

  }

  const res = await fetch(`${BASE}${path}`, { ...init, headers });

  if (res.status === 401) {

    clearToken();

    throw new ApiError(401, "unauthorized");

  }

  if (!res.ok) {

    const body = await res.text();

    throw new ApiError(res.status, body || res.statusText);

  }

  const ct = res.headers.get("content-type") || "";

  return (ct.includes("application/json") ? res.json() : res.text()) as Promise<T>;

}

export class ApiError extends Error {

  constructor(public status: number, message: string) {

    super(message);

  }

}

export interface Investigation {

  id: string; title: string; status: string; priority: string;

  summary: string | null; organization: string | null; created_at: string;

}

export interface PlateProfile {

  plate_norm: string; total_reads: number; first_seen: string | null;

  last_seen: string | null; distinct_cameras: number;

  by_camera: { camera_id: string; count: number }[];

  by_hour: Record<string, number>;

  reads: { read_ts: string; camera_id: string; confidence: number | null }[];

}

export interface CameraMapPoint {

  camera_id: string; name: string; lat: number; lon: number;

  direction_facing: string | null; read_count: number;

}

export interface MovementSummary {

  plate_norm: string; total_reads: number; distinct_cameras: number;

  first_seen: string | null; last_seen: string | null;

  route: { from: string; to: string; elapsed_s: number; distance_km: number | null;

           speed_kmh: number | null; implausible: boolean }[];

  dwell: { camera_id: string; start: string; end: string; duration_s: number; reads: number }[];

  anomalies: { from_camera: string; to_camera: string; speed_kmh: number; reason: string }[];

  by_hour: Record<string, number>;

}

export interface WatchlistHit {

  id: number; matched_on: string; at: string; plate_norm: string; camera_id: string;

}

export interface TimelineEntry {

  plate_norm: string; read_ts: string; camera_id: string;

  direction: string | null; confidence: number | null;

}

export interface ImportRow {

  id: string; filename: string; status: string; row_count: number; created_at: string;

}

export interface ImportResult {

  import_id: string; status?: string; inserted?: number; duplicates?: number;

  skipped?: number; watchlist_hits?: number; deduplicated?: boolean;

  row_count?: number; errors?: string[];

}

export interface Source { id: string; name: string; system_type: string | null; organization: string | null; }

export interface Watchlist { id: string; name: string; kind: string; active: boolean; }

export interface WatchlistEntry {

  id: string; plate_norm: string | null; partial_plate: string | null;

  vehicle_desc: Record<string, string> | null; reason: string | null; expires_at: string | null;

}

export interface CameraDetail {

  id: string; external_camera_id: string; name: string; direction_facing: string | null;

  lat: number | null; lon: number | null; address: string | null; read_count: number;

}

export interface CoTravel { plate_norm: string; shared_sightings: number; }

export interface AuditEntry {

  id: number; actor: string | null; action: string; entity_type: string | null;

  entity_id: string | null; metadata: any; at: string;

}

export interface GraphData {

  nodes: { id: string; type: string; label: string }[];

  edges: { source: string; target: string; relation: string }[];

}

export interface AdminSettings {

  default_retention_days: number; rate_limit_per_minute: number;

  dedup_window_seconds: number; impossible_speed_kmh: number;

  cotravel_window_seconds: number; environment: string;

}

export interface UserRow { id: string; email: string; full_name: string | null; role: string; is_active: boolean; }

export interface EvidenceItem {

  id: string; filename: string; content_type: string | null; size_bytes: number;

  sha256: string; source_id: string | null; description: string | null;

  uploaded_by: string | null; created_at: string;

}

export interface EvidenceDetail extends EvidenceItem {

  investigation_id: string;

  chain_of_custody: { action: string; actor: string | null; at: string; metadata: any }[];

}

export interface ApiKeyRow {

  id: string; name: string; scopes: string[]; last_used_at: string | null;

  revoked_at: string | null; created_at: string;

}

export interface Connector { name: string; description: string; }

export interface RetentionResult {

  cutoff: string; retention_days: number; candidates: number; deleted: number; dry_run: boolean;

}

export interface StateRow { state: string; reads: number; vehicles: number; }

export interface Stats {

  total_reads: number; vehicles: number; cameras: number; states: number; hotlist_reads: number;

}

export interface RecentRead {

  plate_norm: string; read_ts: string; camera_id: string; confidence: number | null;

  hotlist_hit: boolean; state: string | null; camera_name: string | null;

}

export interface LiveCamera {

  id: string; name: string; operator: string | null; area: string | null; state: string | null;

  lat: number | null; lon: number | null; online: boolean; snapshot_url: string; live_source: string | null;

}

export interface MapCamera {

  camera_id: string; name: string; operator: string | null; state: string | null;

  zone: string | null; direction_facing: string | null; lat: number; lon: number;

}

export interface SatelliteCam {

  identifier: string; label: string | null; lat: number | null; lon: number | null;

  altitude_km: number | null; constellation: string | null; period_min: number | null; observed_at: string;

}

export interface CameraGridItem {

  id: string; name: string; operator: string | null; state: string | null; zone: string | null;

  direction_facing: string | null; lat: number | null; lon: number | null; reads: number;

  has_live_feed?: boolean; snapshot_url?: string | null;

}

export interface CameraStats {

  total: number; satellite_cameras: number;

  by_operator: { operator: string; count: number }[];

  by_state: { state: string; count: number }[];

}

export interface ProfileScope {

  mode: "consented" | "all"; consented_subjects: number; modes: string[]; description: string;

}

export interface ProfileSubject { id: string; full_name: string; consented: boolean; plates: string[]; }

export interface ProfileDossier {

  scope: string;

  subject: { id: string; full_name: string; consented: boolean; plates: string[];

    sex: string | null; build: string | null; hair: string | null; threat_level: string; notes: string | null };

  summary: { total_reads: number; first_seen: string | null; last_seen: string | null;

    states_visited: string[]; cities_visited: string[]; distinct_cameras: number };

  timeline: { plate_norm: string; read_ts: string; camera: string | null; operator: string | null;

    state: string | null; area: string | null; lat: number | null; lon: number | null }[];

  map_points: { lat: number; lon: number; read_ts: string; camera: string | null; state: string | null }[];

  detections: { read_ts: string; clothing_top: string | null; articles: string[] | null; description: string | null }[];

}

export interface PlateDetection {

  plate: string; plate_norm: string; detection_confidence: number;

  ocr_confidence: number; bbox: number[];

}

export interface VideoPlate {

  plate_norm: string; plate: string; ocr_confidence: number; detection_confidence: number;

  frames_seen: number; first_ts: number; last_ts: number; bbox: number[];

}

export interface VideoResult {

  frames_sampled: number; frames_with_detections: number; plates: VideoPlate[];

  ingest?: { inserted?: number };

}

export interface OmniResults {

  query: string;

  plates: { plate_norm: string; state: string | null; reads: number }[];

  persons: { id: string; full_name: string; threat_level: string; wanted: boolean; associated_plate: string | null }[];

  vehicles: { plate_norm: string | null; make: string | null; model: string | null; color: string | null; body_type: string | null }[];

  detections: { id: number; clothing_top: string | null; clothing_bottom: string | null; articles: string[] | null; description: string | null; plate_norm: string | null; read_ts: string }[];

  cameras: { id: string; name: string | null; operator: string | null; state: string | null }[];

}

export const api = {

  async login(email: string, password: string): Promise<string> {

    const body = new URLSearchParams({ username: email, password });

    const res = await fetch(`${BASE}/auth/login`, {

      method: "POST",

      headers: { "Content-Type": "application/x-www-form-urlencoded" },

      body,

    });

    if (!res.ok) throw new ApiError(res.status, "invalid credentials");

    const data = (await res.json()) as { access_token: string };

    setToken(data.access_token);

    return data.access_token;

  },

  me: () => req<{ id: string; email: string; role: string }>("/auth/me"),

  investigations: () => req<Investigation[]>("/investigations"),

  investigation: (id: string) => req<Investigation>(`/investigations/${id}`),

  timeline: (id: string) => req<TimelineEntry[]>(`/investigations/${id}/timeline`),

  graph: (id: string) => req<{ nodes: any[]; edges: any[] }>(`/investigations/${id}/graph`),

  plateSearch: (q: string, partial = false) =>

    req<{ plate_norm: string; state: string; plate_raw: string }[]>(

      `/plates/search?q=${encodeURIComponent(q)}&partial=${partial}`),

  plateProfile: (plate: string) => req<PlateProfile>(`/plates/${plate}`),

  movement: (plate: string) => req<MovementSummary>(`/vehicles/${plate}/movement`),

  cameraMap: (params: { state?: string; operator?: string } = {}) => {

    const qs = new URLSearchParams(Object.entries(params).filter(([, v]) => v) as any);

    return req<{ count: number; cameras: MapCamera[] }>(`/cameras/map?${qs}`);

  },

  cameraStats: () => req<CameraStats>("/cameras/stats"),

  liveCameras: (params: { state?: string; q?: string; limit?: number; offset?: number } = {}) => {

    const qs = new URLSearchParams(Object.entries(params).filter(([, v]) => v != null) as any);

    return req<{ total: number; cameras: LiveCamera[] }>(`/cameras/live?${qs}`);

  },

  snapshotUrl: (id: string) => `${BASE}/cameras/${id}/snapshot`,

  cameraGrid: (params: { state?: string; operator?: string; q?: string; limit?: number; offset?: number } = {}) => {

    const qs = new URLSearchParams(Object.entries(params).filter(([, v]) => v != null) as any);

    return req<{ total: number; cameras: CameraGridItem[] }>(`/cameras/grid?${qs}`);

  },

  cameraOperators: () => req<{ operator: string; count: number }[]>("/cameras/operators"),

  satellites: () => req<{ count: number; satellites: SatelliteCam[] }>("/satellites"),

  entityTrack: (id: string) => req<{ identifier: string; label: string | null; track: { lat: number; lon: number; observed_at: string }[] }>(`/entities/${id}/track`),

  omniSearch: (q: string) => req<OmniResults>(`/search/omni?q=${encodeURIComponent(q)}`),

  profileScope: () => req<ProfileScope>("/profiles/scope"),

  setProfileScope: (mode: "consented" | "all") =>

    req<{ mode: string }>("/profiles/scope", { method: "PUT", body: JSON.stringify({ mode }) }),

  profileSearch: (q: string) => req<{ scope: string; results: ProfileSubject[] }>(`/profiles/search?q=${encodeURIComponent(q)}`),

  buildProfile: (id: string) => req<ProfileDossier>(`/profiles/${id}`),

  createSubject: (full_name: string, plates: string[], consented = true) =>

    req<{ id: string }>("/profiles/subjects", { method: "POST", body: JSON.stringify({ full_name, plates, consented }) }),

  alprRecognize: (file: File, minConf = 0.4) => {

    const fd = new FormData();

    fd.append("file", file);

    fd.append("min_conf", String(minConf));

    return req<{ count: number; plates: PlateDetection[] }>("/alpr/recognize", { method: "POST", body: fd });

  },

  alprRecognizeUrl: (url: string, minConf = 0.4) =>

    req<{ url: string; count: number; plates: PlateDetection[] }>("/alpr/recognize-url", {

      method: "POST", body: JSON.stringify({ url, min_conf: minConf }),

    }),

  alprIngest: (file: File, opts: { camera_external_id?: string; state?: string; min_conf?: number } = {}) => {

    const fd = new FormData();

    fd.append("file", file);

    if (opts.camera_external_id) fd.append("camera_external_id", opts.camera_external_id);

    if (opts.state) fd.append("state", opts.state);

    fd.append("min_conf", String(opts.min_conf ?? 0.4));

    return req<{ recognized: number; inserted?: number; plates: PlateDetection[] }>("/alpr/ingest", { method: "POST", body: fd });

  },

  alprVideo: (file: File, opts: { sample_fps?: number; min_conf?: number; ingest?: boolean; camera_external_id?: string; state?: string } = {}) => {

    const fd = new FormData();

    fd.append("file", file);

    fd.append("sample_fps", String(opts.sample_fps ?? 2));

    fd.append("min_conf", String(opts.min_conf ?? 0.4));

    fd.append("ingest", String(opts.ingest ?? false));

    if (opts.camera_external_id) fd.append("camera_external_id", opts.camera_external_id);

    if (opts.state) fd.append("state", opts.state);

    return req<VideoResult>("/alpr/video", { method: "POST", body: fd });

  },

  rtspProbe: (url: string) => req<{ reachable: boolean; decoded: boolean; width?: number; height?: number }>("/alpr/rtsp/probe", { method: "POST", body: JSON.stringify({ url }) }),

  rtspCapture: (body: { url: string; seconds?: number; sample_fps?: number; min_conf?: number; ingest?: boolean; camera_external_id?: string; state?: string }) =>

    req<VideoResult>("/alpr/rtsp/capture", { method: "POST", body: JSON.stringify(body) }),

  states: () => req<StateRow[]>("/states"),

  statePlates: (state: string) =>

    req<{ state: string; plates: { plate_norm: string; reads: number }[] }>(`/states/${state}/plates`),

  stats: () => req<Stats>("/stats"),

  recentReads: (limit = 25) => req<RecentRead[]>(`/ingest/recent?limit=${limit}`),

  watchlistHits: () => req<WatchlistHit[]>("/watchlist-hits"),

  enrichers: () => req<{ name: string; kind: string }[]>("/enrichers"),

  runEnrichment: (enricher: string, target: string) =>

    req<{ job_id: string; status: string; result: any }>("/enrichment/run", {

      method: "POST", body: JSON.stringify({ enricher, target }),

    }),

  createReport: (id: string, format = "markdown") =>

    req<{ report_id: string; report: any }>(`/investigations/${id}/reports`, {

      method: "POST", body: JSON.stringify({ format }),

    }),

  imports: () => req<ImportRow[]>("/imports"),

  uploadImport: (file: File, sourceId?: string) => {

    const fd = new FormData();

    fd.append("file", file);

    if (sourceId) fd.append("source_id", sourceId);

    return req<ImportResult>("/imports", { method: "POST", body: fd });

  },

  sources: () => req<Source[]>("/sources"),

  createSource: (name: string, system_type = "flock") =>

    req<Source>("/sources", { method: "POST", body: JSON.stringify({ name, system_type }) }),

  watchlists: () => req<Watchlist[]>("/watchlists"),

  createWatchlist: (name: string, kind = "plate") =>

    req<Watchlist>("/watchlists", { method: "POST", body: JSON.stringify({ name, kind }) }),

  watchlistEntries: (id: string) => req<WatchlistEntry[]>(`/watchlists/${id}/entries`),

  addWatchlistEntry: (id: string, body: { plate_norm?: string; partial_plate?: string; reason?: string }) =>

    req<{ id: string; backfill_hits: number }>(`/watchlists/${id}/entries`, {

      method: "POST", body: JSON.stringify(body),

    }),

  cameraDetail: (id: string) => req<CameraDetail>(`/cameras/${id}`),

  cameraTransits: (id: string) =>

    req<{ camera_id: string; transitions: { from: string; to: string; weight: number }[] }>(`/cameras/${id}/transits`),

  cotravel: (plate: string) =>

    req<{ plate_norm: string; window_seconds: number; candidates: CoTravel[] }>(`/vehicles/${plate}/cotravel`),

  audit: (params: { entity_type?: string; actor?: string; limit?: number } = {}) => {

    const qs = new URLSearchParams(Object.entries(params).filter(([, v]) => v != null) as any);

    return req<AuditEntry[]>(`/audit?${qs.toString()}`);

  },

  adminSettings: () => req<AdminSettings>("/admin/settings"),

  users: () => req<UserRow[]>("/users"),

  runRetention: (dryRun = true) =>

    req<RetentionResult>(`/admin/retention/run?dry_run=${dryRun}`, { method: "POST" }),

  evidenceList: (invId: string) => req<EvidenceItem[]>(`/investigations/${invId}/evidence`),

  evidenceDetail: (id: string) => req<EvidenceDetail>(`/evidence/${id}`),

  uploadEvidence: (invId: string, file: File, description?: string) => {

    const fd = new FormData();

    fd.append("file", file);

    if (description) fd.append("description", description);

    return req<{ id: string; sha256: string }>(`/investigations/${invId}/evidence`, { method: "POST", body: fd });

  },

  evidenceDownloadUrl: (id: string) => `${BASE}/evidence/${id}/download`,

  apiKeys: () => req<ApiKeyRow[]>("/api-keys"),

  createApiKey: (name: string) =>

    req<{ id: string; name: string; api_key: string; note: string }>("/api-keys", {

      method: "POST", body: JSON.stringify({ name, scopes: [] }),

    }),

  revokeApiKey: (id: string) => req<{ id: string; revoked: boolean }>(`/api-keys/${id}`, { method: "DELETE" }),

  connectors: () => req<Connector[]>("/connectors"),

  runConnector: (connector: string, config: any, sourceId?: string) =>

    req<{ fetched: number; inserted?: number; note?: string }>("/connectors/run", {

      method: "POST", body: JSON.stringify({ connector, config, source_id: sourceId }),

    }),

};

export const API_BASE = BASE;

export async function downloadAuthed(path: string, filename: string): Promise<void> {

  const token = getToken();

  const res = await fetch(`${BASE}${path}`, {

    headers: token ? { Authorization: `Bearer ${token}` } : {},

  });

  if (!res.ok) throw new ApiError(res.status, "download failed");

  const blob = await res.blob();

  const url = URL.createObjectURL(blob);

  const a = document.createElement("a");

  a.href = url;

  a.download = filename;

  document.body.appendChild(a);

  a.click();

  a.remove();

  URL.revokeObjectURL(url);

}