import { describe, it, expect } from "vitest";
import {
  collectMesSchedulableErpResourceIds,
  mapMesMachineSettingsToMappedErpResourceRows,
} from "./mes-machine-settings.js";
import type { MesMachineSettingRow } from "./mes-machine-settings.js";

describe("mapMesMachineSettingsToMappedErpResourceRows", () => {
  it("maps rows with machineRef and laborResourceId", () => {
    const rows: MesMachineSettingRow[] = [
      {
        machineRef: 10,
        laborResourceId: "RES-A",
        name: "Cell 1",
        type: "manual",
        machineGroupId: "grp-1",
        isResourceGroup: false,
      },
    ];
    expect(mapMesMachineSettingsToMappedErpResourceRows(rows)).toEqual([
      {
        machineRef: 10,
        resourceId: "RES-A",
        name: "Cell 1",
        type: "manual",
        machineGroupId: "grp-1",
        isResourceGroup: false,
      },
    ]);
  });

  it("parses numeric string machineRef", () => {
    expect(
      mapMesMachineSettingsToMappedErpResourceRows([
        { machineRef: "42", laborResourceId: "x" },
      ])
    ).toEqual([
      {
        machineRef: 42,
        resourceId: "x",
        name: null,
        type: null,
        machineGroupId: null,
        isResourceGroup: false,
      },
    ]);
  });

  it("trims laborResourceId and rejects blank", () => {
    expect(
      mapMesMachineSettingsToMappedErpResourceRows([
        { machineRef: 1, laborResourceId: "  id  " },
      ])
    ).toEqual([
      expect.objectContaining({ resourceId: "id", machineRef: 1 }),
    ]);

    expect(
      mapMesMachineSettingsToMappedErpResourceRows([
        { machineRef: 1, laborResourceId: "" },
      ])
    ).toHaveLength(0);

    expect(
      mapMesMachineSettingsToMappedErpResourceRows([
        { machineRef: 1, laborResourceId: "   " },
      ])
    ).toHaveLength(0);
  });

  it("excludes rows without finite machineRef", () => {
    expect(
      mapMesMachineSettingsToMappedErpResourceRows([
        { laborResourceId: "a" },
        { machineRef: NaN, laborResourceId: "a" },
        { machineRef: null, laborResourceId: "a" },
      ])
    ).toHaveLength(0);
  });

  it("excludes rows without laborResourceId", () => {
    expect(
      mapMesMachineSettingsToMappedErpResourceRows([
        { machineRef: 1 },
        { machineRef: 1, laborResourceId: null },
      ])
    ).toHaveLength(0);
  });

  it("defaults optional group and name when absent", () => {
    expect(
      mapMesMachineSettingsToMappedErpResourceRows([
        { machineRef: 2, laborResourceId: "Z" },
      ])
    ).toEqual([
      {
        machineRef: 2,
        resourceId: "Z",
        isResourceGroup: false,
        machineGroupId: null,
        name: null,
        type: null,
      },
    ]);
  });

  it("supports isResourceGroup true", () => {
    expect(
      mapMesMachineSettingsToMappedErpResourceRows([
        { machineRef: 1, laborResourceId: "G", isResourceGroup: true },
      ])
    ).toEqual([
      expect.objectContaining({ isResourceGroup: true, resourceId: "G" }),
    ]);
  });
});

describe("collectMesSchedulableErpResourceIds", () => {
  it("includes laborResourceId only when set", () => {
    expect(
      collectMesSchedulableErpResourceIds([
        { laborResourceId: "LAB-1" },
        { laborResourceId: null },
      ])
    ).toEqual(["LAB-1"]);
  });

  it("includes scheduledAs entries", () => {
    expect(
      collectMesSchedulableErpResourceIds([
        {
          scheduledAs: [" S1 ", "S2", null, 99],
        },
      ])
    ).toEqual(["S1", "S2", "99"]);
  });

  it("merges laborResourceId and scheduledAs across rows", () => {
    expect(
      collectMesSchedulableErpResourceIds([
        { laborResourceId: "A", scheduledAs: ["B"] },
        { scheduledAs: ["C"] },
        { laborResourceId: "D" },
      ])
    ).toEqual(["A", "B", "C", "D"]);
  });

  it("dedupes case-insensitively and keeps first-seen casing", () => {
    expect(
      collectMesSchedulableErpResourceIds([
        { laborResourceId: "Res1", scheduledAs: ["res1", "RES1"] },
        { laborResourceId: "rEs1" },
      ])
    ).toEqual(["Res1"]);
  });

  it("ignores null, empty scheduledAs, and non-array scheduledAs", () => {
    expect(
      collectMesSchedulableErpResourceIds([
        { laborResourceId: "", scheduledAs: null },
        { scheduledAs: undefined as unknown as null },
        { scheduledAs: "not-an-array" as unknown as string[] },
      ])
    ).toEqual([]);
  });

  it("skips blank scheduledAs elements", () => {
    expect(
      collectMesSchedulableErpResourceIds([
        { scheduledAs: ["x", "  ", ""] },
      ])
    ).toEqual(["x"]);
  });
});