// IMP-41 u3 — Vitest coverage for application_mode helper (issue #70).
//
// Scope (Stage 2 unit u3 contract):
//   1) buildBadgeTitle: composite output for each known mode + legacy fallback
//      (undefined applicationMode) + unknown fallback (string not in
//      APPLICATION_MODE_TOOLTIP_KR).
//   2) mergeApplicationCandidates: array → Map<template_id, candidate>
//      semantics, including skip-missing-key and empty-input.
//
// Pure helper unit test — no React, no DOM, no fetch. Aligns with the
// AI-isolation contract: assertions key by backend application_mode VALUE,
// never by V4 label.

import { describe, it, expect } from "vitest";
import {
  buildBadgeTitle,
  mergeApplicationCandidates,
  APPLICATION_MODE_TOOLTIP_KR,
} from "../src/services/applicationMode";

describe("buildBadgeTitle (IMP-41 u3)", () => {
  it("returns composite '<consequence> (<mode>)' for direct_insert", () => {
    expect(buildBadgeTitle("use_as_is", "direct_insert")).toBe(
      `${APPLICATION_MODE_TOOLTIP_KR.direct_insert} (direct_insert)`,
    );
  });

  it("returns composite output for same_frame_with_adjustment", () => {
    expect(
      buildBadgeTitle("light_edit", "same_frame_with_adjustment"),
    ).toBe(
      `${APPLICATION_MODE_TOOLTIP_KR.same_frame_with_adjustment} (same_frame_with_adjustment)`,
    );
  });

  it("returns composite output for layout_or_region_change", () => {
    expect(
      buildBadgeTitle("restructure", "layout_or_region_change"),
    ).toBe(
      `${APPLICATION_MODE_TOOLTIP_KR.layout_or_region_change} (layout_or_region_change)`,
    );
  });

  it("returns composite output for exclude", () => {
    expect(buildBadgeTitle("reject", "exclude")).toBe(
      `${APPLICATION_MODE_TOOLTIP_KR.exclude} (exclude)`,
    );
  });

  it("falls back to 'V4 label: <label>' when applicationMode is undefined (legacy fixtures pre-IMP-32)", () => {
    expect(buildBadgeTitle("use_as_is", undefined)).toBe("V4 label: use_as_is");
  });

  it("falls back to 'V4 label: <label>' when applicationMode is an unknown string", () => {
    expect(buildBadgeTitle("light_edit", "some_future_mode")).toBe(
      "V4 label: light_edit",
    );
  });
});

describe("mergeApplicationCandidates (IMP-41 u3)", () => {
  it("returns empty Map when input is undefined", () => {
    const result = mergeApplicationCandidates(undefined);
    expect(result).toBeInstanceOf(Map);
    expect(result.size).toBe(0);
  });

  it("returns empty Map when input is null", () => {
    const result = mergeApplicationCandidates(null);
    expect(result.size).toBe(0);
  });

  it("returns empty Map when input is not an array", () => {
    expect(mergeApplicationCandidates({ template_id: "f01" }).size).toBe(0);
    expect(mergeApplicationCandidates("f01").size).toBe(0);
    expect(mergeApplicationCandidates(42).size).toBe(0);
  });

  it("returns empty Map when input is an empty array", () => {
    expect(mergeApplicationCandidates([]).size).toBe(0);
  });

  it("keys entries by template_id and preserves the candidate payload", () => {
    const ac1 = {
      template_id: "f01",
      label: "use_as_is",
      application_mode: "direct_insert",
      auto_applicable: true,
      delegated_to: null,
    };
    const ac2 = {
      template_id: "f17",
      label: "light_edit",
      application_mode: "same_frame_with_adjustment",
      auto_applicable: false,
      delegated_to: "step10_contract_check",
    };
    const result = mergeApplicationCandidates([ac1, ac2]);
    expect(result.size).toBe(2);
    expect(result.get("f01")).toBe(ac1);
    expect(result.get("f17")).toBe(ac2);
  });

  it("skips entries with missing or non-string template_id", () => {
    const result = mergeApplicationCandidates([
      { label: "use_as_is" }, // missing template_id
      { template_id: "", label: "light_edit" }, // empty string
      { template_id: 17, label: "restructure" }, // non-string
      { template_id: "f29", label: "reject" }, // valid
    ]);
    expect(result.size).toBe(1);
    expect(result.has("f29")).toBe(true);
    expect(result.has("")).toBe(false);
  });

  it("keeps the first occurrence on duplicate template_id keys (deterministic)", () => {
    const first = { template_id: "f01", label: "use_as_is" };
    const second = { template_id: "f01", label: "reject" };
    const result = mergeApplicationCandidates([first, second]);
    expect(result.size).toBe(1);
    expect(result.get("f01")).toBe(first);
  });
});