import { apiGet, apiPost, apiPatch, apiDelete } from "@/api/client";

/** One canonical location of a reusable thing. A snippet that unifies several
 *  one-offs carries several — one per call site. */
export interface SnippetLocation {
  repo: string;
  path: string;
  symbol: string;
}

/** Structured fields parsed out of a snippet note (mirrors the backend
 *  `parse_snippet_fields` — see services/snippets.py). `repo`/`path`/`symbol`
 *  mirror the first location for back-compat; `locations` is the full list. */
export interface SnippetFields {
  name: string;
  when_to_use: string;
  signature: string;
  language: string;
  repo: string;
  path: string;
  symbol: string;
  locations: SnippetLocation[];
  /** Ids of the snippets folded into this one by merge, oldest first. Read-only:
   *  merge is the only thing that adds to it, and an edit carries it forward. */
  merged_from: number[];
  code: string;
}

/** A full snippet record: the note dict plus the parsed `snippet` sub-object,
 *  as returned by the backend `snippet_to_dict`. */
export interface Snippet {
  id: number;
  title: string;
  body: string;
  tags: string[];
  note_type: string;
  project_id: number | null;
  permission?: string;
  created_at: string;
  updated_at: string;
  snippet: SnippetFields;
  systems?: { id: number; name: string }[];
  /** Set when another user owns this record; `owner` is their username and
   *  `permission` your access level on it. */
  shared?: boolean;
  owner?: string | null;
}

/** How often a record was put in front of an agent versus actually opened.
 *  A high `surfaced_count` with `pull_count: 0` is dead weight — it occupies a
 *  slot in every future auto-inject menu while never being used. */
export interface SnippetUsage {
  surfaced_count: number;
  pull_count: number;
  last_surfaced_at: string | null;
  last_pulled_at: string | null;
}

/** Lightweight list item from the knowledge preview feed. Note: the `snippet`
 *  field here is a truncated *body preview* (the knowledge feed's naming), not
 *  the parsed fields above. */
export interface SnippetListItem {
  id: number;
  title: string;
  tags: string[];
  note_type: string;
  snippet: string;
  created_at: string;
  updated_at: string;
  /** Present only when the record belongs to someone else — a suggestion from
   *  them, not one of your own. Absent means it's yours. */
  shared?: boolean;
  owner?: string | null;
  /** Always present from the backend, zero-filled for records with no events. */
  usage?: SnippetUsage;
}

/** Create/update payload — discrete fields the backend serializes into the
 *  note (title/body/tags). Empty strings are applied; omitted keys are left
 *  unchanged on update. */
export interface SnippetInput {
  name: string;
  code: string;
  language?: string;
  signature?: string;
  when_to_use?: string;
  locations?: SnippetLocation[];
  tags?: string[];
  project_id?: number | null;
  system_ids?: number[];
  /** Create only: record it even though a near-duplicate already exists. */
  force?: boolean;
}

/** `repo`/`path`/`symbol` are the reverse lookup — "what already lives here?"
 *  They must all match the same recorded location; `path` also matches anything
 *  beneath it. Combinable with `q`. */
export async function listSnippets(
  params: {
    q?: string;
    tag?: string;
    projectId?: number | null;
    repo?: string;
    path?: string;
    symbol?: string;
  } = {},
): Promise<{ snippets: SnippetListItem[]; total: number }> {
  const qs = new URLSearchParams();
  if (params.q) qs.set("q", params.q);
  if (params.tag) qs.set("tag", params.tag);
  if (params.projectId) qs.set("project_id", String(params.projectId));
  if (params.repo) qs.set("repo", params.repo);
  if (params.path) qs.set("path", params.path);
  if (params.symbol) qs.set("symbol", params.symbol);
  const query = qs.toString();
  return apiGet(`/api/snippets${query ? `?${query}` : ""}`);
}

export async function getSnippet(id: number): Promise<Snippet> {
  return apiGet(`/api/snippets/${id}`);
}

export async function createSnippet(data: SnippetInput): Promise<Snippet> {
  return apiPost("/api/snippets", data);
}

export async function updateSnippet(
  id: number,
  data: Partial<SnippetInput>,
): Promise<Snippet> {
  return apiPatch(`/api/snippets/${id}`, data);
}

export async function deleteSnippet(id: number): Promise<void> {
  return apiDelete(`/api/snippets/${id}`);
}

/** Unify `sourceIds` into the canonical snippet `targetId`. Returns the merged
 *  survivor plus `merged_ids` — the sources actually folded in and trashed. */
export async function mergeSnippets(
  targetId: number,
  sourceIds: number[],
): Promise<Snippet & { merged_ids: number[] }> {
  return apiPost(`/api/snippets/${targetId}/merge`, { source_ids: sourceIds });
}