// Settling conflicts with oxy's one-command answers (spec §5.7): keep one

// side of a binary file's or subrepo pin's replace conflict (oxygen#140),

// and keep every side of two changes adding lines at the same place

// (oxygen#121). The choices and the words live here, apart from VS Code,

// so they are tested.

import { ConflictInfo, KeptBoth } from "./oxy";

import { candidateBase } from "./markers";

/** One way to settle a conflict, as the quick pick offers it. */

export interface SettleChoice {

  label: string;

  description?: string;

  detail?: string;

  /** keep-side: write that side's version and settle; keep-current: settle with the working copy; open-subrepo: move the subrepo first. */

  action: "keep-side" | "keep-current" | "open-subrepo";

  /** The side's ChangeId, for keep-side. */

  change?: string;

}

/** Whether a conflict is a replace conflict: a binary file or subrepo pin changed two ways, with no markers to edit. */

export function isReplaceConflict(c: ConflictInfo): boolean {

  return c.kind === "replace" && !!c.path;

}

/**

 * The choices for a replace conflict. A file offers each side (the version

 * the side's change made); a subrepo pin offers the pin the nested

 * repository holds now, since oxy settles a pin with what the working copy

 * holds there, or opening it to move it first. `subjects` maps a side's

 * ChangeId to its subject line, where known.

 */

export function replaceChoices(c: ConflictInfo, subrepo: boolean, subjects: Map<string, string> = new Map()): SettleChoice[] {

  if (subrepo) {

    return [

      { label: "$(check) Keep the pin the subrepo holds now", description: c.path, detail: "Settles the pin conflict with the nested repository's current state (oxy resolve)", action: "keep-current" },

      { label: "$(folder-opened) Open the subrepo to move it first", detail: "Check out the side you want inside it, then come back and keep that pin", action: "open-subrepo" },

    ];

  }

  const sides: SettleChoice[] = (c.changes ?? []).map((id, i) => ({

    label: `$(check) Keep side ${i + 1}`,

    description: `${id.slice(0, 8)}${subjects.get(id) ? ` "${subjects.get(id)}"` : ""}`,

    detail: `The version change ${id.slice(0, 8)} made replaces every other`,

    action: "keep-side",

    change: id,

  }));

  return [

    ...sides,

    { label: "$(edit) Keep what the working copy holds now", description: c.path, detail: "Settles with the file as it is on disk; its .oxy-conflict-N candidates are removed (oxy resolve)", action: "keep-current" },

  ];

}

/** The `.oxy-conflict-N` candidates of `path` among a directory's entries (names, not paths). */

export function candidatesOf(name: string, entries: string[]): string[] {

  return entries.filter((e) => candidateBase(e) === name);

}

/** The modal question before withdrawing a tag. */

export function withdrawQuestion(tag: string): { message: string; detail: string } {

  return {

    message: `Withdraw tag ${tag}?`,

    detail:

      "The withdrawal is signed with your key and kept beside the tag's creation, and oxy push sends it to remotes that have the tag. It is logged, not erased, and the name can never be used again.",

  };

}

/** One line saying what `oxy resolve --both` did. */

export function keptBothSummary(r: KeptBoth): { message: string; settled: boolean; warn: boolean } {

  const kept = r.kept.reduce((n, k) => n + k.conflicts.length, 0);

  const files = new Set(r.kept.map((k) => k.path)).size;

  const parts: string[] = [];

  if (kept > 0) {

    parts.push(`kept every side of ${kept} conflict${kept === 1 ? "" : "s"} in ${files} file${files === 1 ? "" : "s"}`);

  }

  for (const l of r.left) {

    parts.push(`${l.path} conflict ${l.conflict} keeps its markers: ${l.why}`);

  }

  if (parts.length === 0) {

    return { message: "no conflict where two changes only add lines at the same place", settled: false, warn: true };

  }

  return { message: parts.join("; "), settled: kept > 0, warn: r.left.length > 0 };

}