import { describe, expect, it } from "vitest";
import { pluginConditionValueText, pluginFieldConditionMatches, pluginFieldConditionReferencedFields, pluginFieldIsRequired, pluginFieldIsVisible } from "./pluginFieldConditions";
import type { PluginFieldCondition, PluginFormField, PluginFormFieldValue } from "@/types/database";

function field(overrides: Partial<PluginFormField>): PluginFormField {
  return { key: "demo", label: "Demo", type: "text", ...overrides } as PluginFormField;
}

const readValue = (key: string): PluginFormFieldValue => (key === "mode" ? "custom" : undefined);
/** Reads a fixed map, so a condition can be evaluated against known values. */
function reader(values: Record<string, PluginFormFieldValue>): (key: string) => PluginFormFieldValue {
  return (key) => values[key];
}

describe("pluginFieldConditionMatches", () => {
  it("matches a missing condition and a listed value", () => {
    expect(pluginFieldConditionMatches(undefined, () => undefined)).toBe(true);
    expect(pluginFieldConditionMatches({ field: "mode", one_of: ["custom"] }, reader({ mode: "custom" }))).toBe(true);
  });

  it("rejects an unlisted or empty value", () => {
    expect(pluginFieldConditionMatches({ field: "mode", one_of: ["custom"] }, reader({ mode: "direct" }))).toBe(false);
    expect(pluginFieldConditionMatches({ field: "mode", one_of: ["custom"] }, reader({}))).toBe(false);
    expect(pluginFieldConditionMatches({ field: "mode", one_of: ["custom"] }, reader({ mode: "  " }))).toBe(false);
  });

  it("compares boolean and number literals by canonical string form", () => {
    // `read_only = false` is the composite-condition driver the SSH plugin needs.
    const readOnly = { field: "read_only", one_of: [false] } as PluginFieldCondition;
    expect(pluginFieldConditionMatches(readOnly, reader({ read_only: false }))).toBe(true);
    expect(pluginFieldConditionMatches(readOnly, reader({ read_only: true }))).toBe(false);
    expect(pluginFieldConditionMatches({ field: "read_only", one_of: ["false"] }, reader({ read_only: false }))).toBe(true);
    expect(pluginFieldConditionMatches({ field: "port", one_of: [2222] }, reader({ port: 2222 }))).toBe(true);
    expect(pluginFieldConditionMatches({ field: "port", one_of: [2222.0] }, reader({ port: 2222 }))).toBe(true);
    expect(pluginConditionValueText(false)).toBe("false");
    expect(pluginConditionValueText(22)).toBe("22");
  });

  it("composes clauses with all_of, any_of and not", () => {
    const allOf = {
      all_of: [
        { field: "sudo_source", one_of: ["custom"] },
        { field: "read_only", one_of: [false] },
      ],
    } as PluginFieldCondition;
    expect(pluginFieldConditionMatches(allOf, reader({ sudo_source: "custom", read_only: false }))).toBe(true);
    expect(pluginFieldConditionMatches(allOf, reader({ sudo_source: "custom", read_only: true }))).toBe(false);
    expect(pluginFieldConditionMatches(allOf, reader({ sudo_source: "default", read_only: false }))).toBe(false);

    const anyOf = {
      any_of: [
        { field: "authentication", one_of: ["password"] },
        { field: "authentication", one_of: ["keyboard-interactive"] },
      ],
    } as PluginFieldCondition;
    expect(pluginFieldConditionMatches(anyOf, reader({ authentication: "keyboard-interactive" }))).toBe(true);
    expect(pluginFieldConditionMatches(anyOf, reader({ authentication: "agent" }))).toBe(false);

    const not = { not: { field: "read_only", one_of: [true] } } as PluginFieldCondition;
    expect(pluginFieldConditionMatches(not, reader({ read_only: false }))).toBe(true);
    expect(pluginFieldConditionMatches(not, reader({ read_only: true }))).toBe(false);

    const nested = { all_of: [anyOf, not, { any_of: [{ all_of: [{ field: "read_only", one_of: [false] }] }] }] } as PluginFieldCondition;
    expect(pluginFieldConditionMatches(nested, reader({ authentication: "password", read_only: false }))).toBe(true);
    expect(pluginFieldConditionMatches(nested, reader({ authentication: "password", read_only: true }))).toBe(false);
  });

  it("lists every referenced field of a nested expression", () => {
    expect(
      pluginFieldConditionReferencedFields({
        all_of: [
          {
            any_of: [
              { field: "a", one_of: ["1"] },
              { field: "b", one_of: ["1"] },
            ],
          },
          { not: { field: "c", one_of: ["1"] } },
        ],
      }),
    ).toEqual(["a", "b", "c"]);
  });
});

describe("pluginFieldIsRequired", () => {
  it("honors static required", () => {
    expect(pluginFieldIsRequired(field({ required: true }), readValue)).toBe(true);
  });

  it("treats a field without required_when as optional", () => {
    expect(pluginFieldIsRequired(field({}), readValue)).toBe(false);
  });

  it("requires a field only while its required_when matches", () => {
    const conditional = field({ required_when: { field: "mode", one_of: ["custom"] } });
    expect(pluginFieldIsRequired(conditional, readValue)).toBe(true);
    expect(pluginFieldIsRequired(conditional, () => "direct")).toBe(false);
    expect(pluginFieldIsRequired(conditional, () => undefined)).toBe(false);
  });

  it("requires a field only while every clause of an all_of required_when matches", () => {
    const conditional = field({
      required_when: {
        all_of: [
          { field: "sudo_source", one_of: ["custom"] },
          { field: "read_only", one_of: [false] },
        ],
      },
    });
    expect(pluginFieldIsRequired(conditional, reader({ sudo_source: "custom", read_only: false }))).toBe(true);
    expect(pluginFieldIsRequired(conditional, reader({ sudo_source: "custom", read_only: true }))).toBe(false);
  });
});

describe("pluginFieldIsVisible", () => {
  it("renders fields without visible_when and gates conditional ones", () => {
    expect(pluginFieldIsVisible(field({}), readValue)).toBe(true);
    const conditional = field({ visible_when: { field: "mode", one_of: ["custom"] } });
    expect(pluginFieldIsVisible(conditional, readValue)).toBe(true);
    expect(pluginFieldIsVisible(conditional, () => "direct")).toBe(false);
  });

  it("renders a field only while every clause of an all_of visible_when matches", () => {
    const conditional = field({
      visible_when: {
        all_of: [
          { field: "sudo_source", one_of: ["custom"] },
          { field: "read_only", one_of: [false] },
        ],
      },
    });
    expect(pluginFieldIsVisible(conditional, reader({ sudo_source: "custom", read_only: false }))).toBe(true);
    expect(pluginFieldIsVisible(conditional, reader({ sudo_source: "custom", read_only: true }))).toBe(false);
    expect(pluginFieldIsVisible(conditional, reader({ read_only: false }))).toBe(false);
  });

  it("keeps an unused any_of branch from hiding a matching field", () => {
    // `visible_when.any_of` matches through the first clause; the second clause
    // references a sibling that is itself hidden, and that must not matter.
    const fields: Record<string, PluginFormField> = {
      source: field({ key: "source", default: "custom" }),
      hidden_controller: field({ key: "hidden_controller", default: "on", visible_when: { field: "source", one_of: ["remote"] } }),
      target: field({
        key: "target",
        visible_when: {
          any_of: [
            { field: "source", one_of: ["custom"] },
            { field: "hidden_controller", one_of: ["on"] },
          ],
        },
      }),
    };
    const read: (key: string) => PluginFormFieldValue = (key) => fields[key]?.default ?? undefined;
    const resolve: (key: string) => PluginFormField | undefined = (key) => fields[key];

    expect(pluginFieldIsVisible(fields.target, read, resolve)).toBe(true);
    // ...while a match that *depends* on the hidden controller stays dormant.
    const onlyHidden = field({
      key: "only_hidden",
      visible_when: { any_of: [{ field: "hidden_controller", one_of: ["on"] }] },
    });
    expect(pluginFieldIsVisible(onlyHidden, read, resolve)).toBe(false);
  });

  it("treats a hidden operand of `not` as dormant instead of lighting the field up", () => {
    const fields: Record<string, PluginFormField> = {
      mode: field({ key: "mode", default: "remote" }),
      read_only: field({ key: "read_only", default: false, visible_when: { field: "mode", one_of: ["local"] } }),
      writable_options: field({ key: "writable_options", visible_when: { not: { field: "read_only", one_of: [true] } } }),
    };
    const read: (key: string) => PluginFormFieldValue = (key) => fields[key]?.default ?? undefined;
    const resolve: (key: string) => PluginFormField | undefined = (key) => fields[key];

    expect(pluginFieldIsVisible(fields.writable_options, read, resolve)).toBe(false);
    const localRead = reader({ mode: "local", read_only: false });
    expect(pluginFieldIsVisible(fields.writable_options, localRead, resolve)).toBe(true);
  });

  it("keeps a condition dormant while its referenced sibling is hidden, even when the sibling default would match", () => {
    // kafka-shaped chain: sasl_mechanism (default PLAIN, hidden) →
    // oauth_token_source (visible only for OAUTHBEARER, defaults msk_iam) →
    // msk_region. The msk_iam default must not surface msk_region while SASL
    // is off, otherwise the dialog footer dead-locks on an unfillable field.
    const fields: Record<string, PluginFormField> = {
      security_protocol: field({ key: "security_protocol", default: "PLAINTEXT" }),
      sasl_mechanism: field({ key: "sasl_mechanism", default: "PLAIN", visible_when: { field: "security_protocol", one_of: ["SASL_PLAINTEXT", "SASL_SSL"] } }),
      oauth_token_source: field({ key: "oauth_token_source", default: "msk_iam", visible_when: { field: "sasl_mechanism", one_of: ["OAUTHBEARER"] } }),
      msk_region: field({ key: "msk_region", visible_when: { field: "oauth_token_source", one_of: ["msk_iam"] } }),
    };
    const read: (key: string) => PluginFormFieldValue = (key) => fields[key]?.default ?? undefined;
    const resolve: (key: string) => PluginFormField | undefined = (key) => fields[key];

    expect(pluginFieldIsVisible(fields.msk_region, read, resolve)).toBe(false);
    // Turning OAUTHBEARER on makes the whole chain visible again.
    const readOauth: (key: string) => PluginFormFieldValue = (key) => (key === "sasl_mechanism" ? "OAUTHBEARER" : key === "security_protocol" ? "SASL_SSL" : (fields[key]?.default ?? undefined));
    expect(pluginFieldIsVisible(fields.oauth_token_source, readOauth, resolve)).toBe(true);
    expect(pluginFieldIsVisible(fields.msk_region, readOauth, resolve)).toBe(true);
  });

  it.each([false, true])("keeps sibling branches path-local with reverse order %s", (reverse) => {
    const fields: Record<string, PluginFormField> = {
      mode: field({ key: "mode" }),
      auth: field({ key: "auth", visible_when: { field: "mode", one_of: ["enabled"] } }),
    };
    const clause: PluginFieldCondition = { field: "auth", one_of: ["password"] };
    const branches: PluginFieldCondition[] = [{ all_of: [clause, { field: "flag", one_of: [true] }] }, { all_of: [{ field: "flag", one_of: [false] }, clause] }];
    if (reverse) branches.reverse();
    const resolve = (key: string) => fields[key];
    for (const flag of [false, true]) {
      const hidden = reader({ mode: "disabled", auth: "password", flag });
      const visible = reader({ mode: "enabled", auth: "password", flag });
      for (const condition of [clause, { any_of: [clause, clause] }, { any_of: branches }, { all_of: [clause, clause] }] satisfies PluginFieldCondition[]) {
        const target = field({ key: "target", visible_when: condition });
        expect(pluginFieldIsVisible(target, hidden, resolve)).toBe(false);
        expect(pluginFieldIsVisible(target, visible, resolve)).toBe(true);
      }
      const negated = field({ visible_when: { not: { any_of: [clause, clause] } } });
      expect(pluginFieldIsVisible(negated, hidden, resolve)).toBe(false);
      expect(pluginFieldIsVisible(negated, reader({ mode: "enabled", auth: "token", flag }), resolve)).toBe(true);
    }
  });

  it("preserves true mutual-cycle compatibility without bypassing value checks", () => {
    const fields: Record<string, PluginFormField> = {
      first: field({ key: "first", visible_when: { field: "second", one_of: ["on"] } }),
      second: field({ key: "second", visible_when: { field: "first", one_of: ["on"] } }),
    };
    const resolve = (key: string) => fields[key];
    expect(pluginFieldIsVisible(fields.first, reader({ first: "on", second: "on" }), resolve)).toBe(true);
    expect(pluginFieldIsVisible(fields.first, reader({ first: "off", second: "on" }), resolve)).toBe(false);
  });

  it("ignores unknown condition fields and survives self-referencing cycles", () => {
    const unknown = field({ visible_when: { field: "missing", one_of: ["x"] } });
    expect(
      pluginFieldIsVisible(
        unknown,
        () => "x",
        () => undefined,
      ),
    ).toBe(true);
    const selfRef = field({ key: "loop", visible_when: { field: "loop", one_of: ["x"] } });
    expect(
      pluginFieldIsVisible(
        selfRef,
        () => "x",
        (key) => (key === "loop" ? selfRef : undefined),
      ),
    ).toBe(true);
  });
});