import { describe, expect, it } from "vite-plus/test";

import { ProviderDriverKind } from "@t3tools/contracts";

import {
  createHermesProviderInstanceId,
  isHermesInstanceRemovedError,
  isOwnedHermesEnrollmentRetry,
  resolveHermesWaitingState,
  resolveWizardNavigation,
  rollbackProviderInstances,
  validateProviderInstanceIdForWizard,
} from "./AddProviderInstanceDialog.logic";

describe("Hermes provider instance identity", () => {
  it("keeps the readable label prefix while adding a stable random suffix", () => {
    expect(
      createHermesProviderInstanceId("Research Team", () => "019f99cc-30d4-72c4-b3dd-2ee59cecb856"),
    ).toBe("hermes-research-team-019f99cc30d4");
  });

  it("never reuses an ID when a later dialog uses the same label", () => {
    expect(
      createHermesProviderInstanceId("Research", () => "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"),
    ).not.toBe(
      createHermesProviderInstanceId("Research", () => "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"),
    );
  });

  it("stays within the provider instance ID length limit for long labels", () => {
    const instanceId = createHermesProviderInstanceId(
      "A very long research Hermes display name that should be truncated before persistence",
      () => "019f99cc-30d4-72c4-b3dd-2ee59cecb856",
    );

    expect(instanceId.length).toBeLessThanOrEqual(64);
    expect(instanceId).toMatch(/^hermes-[a-z0-9-]+-[a-z0-9]{12}$/u);
  });

  it("recognizes a server tombstone rejection so the dialog can rotate its nonce", () => {
    expect(isHermesInstanceRemovedError({ code: "instance-removed" })).toBe(true);
    expect(isHermesInstanceRemovedError({ code: "nickname-conflict" })).toBe(false);
    expect(isHermesInstanceRemovedError(new Error("instance removed"))).toBe(false);
  });
});

describe("resolveWizardNavigation", () => {
  const invalidId = { instanceIdError: "Instance ID is required." };
  const validId = { instanceIdError: null };

  it("allows moving from Driver to Identity before the instance id is valid", () => {
    expect(resolveWizardNavigation(0, 1, 3, invalidId)).toEqual({ kind: "navigate", step: 1 });
  });

  it("blocks Next from Identity to Config while the instance id is invalid", () => {
    expect(resolveWizardNavigation(1, 2, 3, invalidId)).toEqual({
      kind: "blocked",
      step: 1,
      error: "Instance ID is required.",
    });
  });

  it("stops a direct Driver-to-Config skip at Identity and surfaces its error", () => {
    expect(resolveWizardNavigation(0, 2, 3, invalidId)).toEqual({
      kind: "blocked",
      step: 1,
      error: "Instance ID is required.",
    });
  });

  it("allows advancing and skipping forward once the instance id is valid", () => {
    expect(resolveWizardNavigation(1, 2, 3, validId)).toEqual({ kind: "navigate", step: 2 });
    expect(resolveWizardNavigation(0, 2, 3, validId)).toEqual({ kind: "navigate", step: 2 });
  });

  it("always preserves backward Driver and Identity navigation", () => {
    expect(resolveWizardNavigation(2, 1, 3, invalidId)).toEqual({ kind: "navigate", step: 1 });
    expect(resolveWizardNavigation(2, 0, 3, invalidId)).toEqual({ kind: "navigate", step: 0 });
    expect(resolveWizardNavigation(1, 0, 3, invalidId)).toEqual({ kind: "navigate", step: 0 });
  });

  it("clamps requested steps to the wizard bounds", () => {
    expect(resolveWizardNavigation(2, 8, 3, validId)).toEqual({ kind: "navigate", step: 2 });
    expect(resolveWizardNavigation(0, -1, 3, invalidId)).toEqual({ kind: "navigate", step: 0 });
  });
});

describe("Hermes enrollment retry ownership", () => {
  const existingIds = new Set(["hermes-research", "hermes-existing"]);

  it("allows retrying enrollment for the exact Hermes instance created by this wizard", () => {
    expect(
      isOwnedHermesEnrollmentRetry({
        driver: ProviderDriverKind.make("hermes"),
        instanceId: "hermes-research",
        createdHermesInstanceId: "hermes-research",
      }),
    ).toBe(true);
    expect(
      validateProviderInstanceIdForWizard({
        driver: ProviderDriverKind.make("hermes"),
        instanceId: "hermes-research",
        existingIds,
        createdHermesInstanceId: "hermes-research",
      }),
    ).toBeNull();
  });

  it("still rejects arbitrary existing instances and non-Hermes reuse", () => {
    expect(
      validateProviderInstanceIdForWizard({
        driver: ProviderDriverKind.make("hermes"),
        instanceId: "hermes-existing",
        existingIds,
        createdHermesInstanceId: "hermes-research",
      }),
    ).toContain("already exists");
    expect(
      validateProviderInstanceIdForWizard({
        driver: ProviderDriverKind.make("codex"),
        instanceId: "hermes-research",
        existingIds,
        createdHermesInstanceId: "hermes-research",
      }),
    ).toContain("already exists");
    expect(
      validateProviderInstanceIdForWizard({
        driver: ProviderDriverKind.make("hermes"),
        instanceId: "hermes-research",
        existingIds,
        createdHermesInstanceId: null,
      }),
    ).toContain("already exists");
  });
});

describe("rollbackProviderInstances", () => {
  interface TestInstance {
    readonly driver: string;
    readonly enabled: boolean;
  }
  const written: TestInstance = { driver: "hermes", enabled: true };
  const other: TestInstance = { driver: "codex", enabled: true };

  it("removes only the instance this dialog wrote", () => {
    expect(
      rollbackProviderInstances({
        latest: { "hermes-a": written, codex_work: other },
        instanceId: "hermes-a",
        written,
      }),
    ).toEqual({ codex_work: other });
  });

  it("preserves instances another client added between the write and the rollback", () => {
    const concurrent: TestInstance = { driver: "claude", enabled: true };
    expect(
      rollbackProviderInstances({
        latest: { "hermes-a": written, "added-elsewhere": concurrent },
        instanceId: "hermes-a",
        written,
      }),
    ).toEqual({ "added-elsewhere": concurrent });
  });

  it("does nothing when the id is already gone or was replaced by a different config", () => {
    expect(
      rollbackProviderInstances({ latest: { codex_work: other }, instanceId: "hermes-a", written }),
    ).toBeNull();
    expect(
      rollbackProviderInstances({
        latest: { "hermes-a": { ...written } },
        instanceId: "hermes-a",
        written,
      }),
    ).toBeNull();
  });
});

describe("resolveHermesWaitingState", () => {
  it("treats a not-yet-dialled-in gateway as an expected pending wait, not an error", () => {
    expect(resolveHermesWaitingState({ connectionState: null, isExpired: false })).toEqual({
      phase: "waiting",
      statusLabelState: "offline",
      isPending: true,
      needsNewCommand: false,
    });
    expect(resolveHermesWaitingState({ connectionState: "offline", isExpired: false })).toEqual({
      phase: "waiting",
      statusLabelState: "offline",
      isPending: true,
      needsNewCommand: false,
    });
    expect(resolveHermesWaitingState({ connectionState: "connecting", isExpired: false })).toEqual({
      phase: "waiting",
      statusLabelState: "connecting",
      isPending: true,
      needsNewCommand: false,
    });
  });

  it("flips to connected and ignores expiry once the gateway has dialled in", () => {
    expect(resolveHermesWaitingState({ connectionState: "connected", isExpired: true })).toEqual({
      phase: "connected",
      statusLabelState: "connected",
      isPending: false,
      needsNewCommand: false,
    });
  });

  it("offers a fresh command when the one-time token expired unused", () => {
    expect(resolveHermesWaitingState({ connectionState: "offline", isExpired: true })).toEqual({
      phase: "expired",
      statusLabelState: "offline",
      isPending: false,
      needsNewCommand: true,
    });
  });

  it("surfaces upgrade-required and revoked ahead of waiting, since neither resolves by waiting", () => {
    expect(
      resolveHermesWaitingState({ connectionState: "upgrade-required", isExpired: false }),
    ).toEqual({
      phase: "blocked",
      statusLabelState: "upgrade-required",
      isPending: false,
      // A protocol upgrade needs a new plugin, not a new token.
      needsNewCommand: false,
    });
    expect(resolveHermesWaitingState({ connectionState: "revoked", isExpired: false })).toEqual({
      phase: "blocked",
      statusLabelState: "revoked",
      isPending: false,
      needsNewCommand: true,
    });
  });
});