/// <reference types="node" />

import { afterEach, beforeEach, describe, expect, test } from "vitest";
import { mkdtempSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import path from "node:path";

import { handleSettingsCommand } from "../../../src/cli/commands/settings";
import { CommandError } from "../../../src/cli/commands/types";
import { createMockIO, createMockPaths } from "../mocks/command";

describe("settings command", () => {
  let tempDir: string;

  beforeEach(() => {
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-settings-command-test-"));
  });

  afterEach(() => {
    rmSync(tempDir, { recursive: true, force: true });
  });

  test("shows default settings when .wallet does not exist", async () => {
    const { io, capture } = createMockIO();
    const paths = createMockPaths(tempDir);

    const result = await handleSettingsCommand({ io, paths }, ["show"], {});

    expect(result).toEqual({ currency: "USD" });
    expect(capture.out.join("\n")).toContain("currency");
    expect(capture.out.join("\n")).toContain("USD");
  });

  test("sets and gets currency", async () => {
    const { io, capture } = createMockIO();
    const paths = createMockPaths(tempDir);

    await handleSettingsCommand({ io, paths }, ["set", "currency", "aud"], {});
    const getResult = await handleSettingsCommand(
      { io, paths },
      ["get", "currency"],
      {},
    );

    expect(getResult).toEqual({ key: "currency", value: "AUD" });
    expect(capture.out).toContain("Updated currency: AUD");
    expect(capture.out).toContain("AUD");
  });

  test("sets default-mnemonic and persists JSON .wallet", async () => {
    const { io } = createMockIO();
    const paths = createMockPaths(tempDir);

    await handleSettingsCommand(
      { io, paths },
      ["set", "default-mnemonic", "mnemonic-primary"],
      {},
    );

    const persisted = JSON.parse(
      readFileSync(paths.walletConfigPath, "utf8"),
    ) as {
      currency: string;
      "default-mnemonic"?: string;
    };

    expect(persisted).toEqual({
      currency: "USD",
      "default-mnemonic": "mnemonic-primary",
    });
  });

  test("throws command error for unknown subcommand", async () => {
    const { io } = createMockIO();
    const paths = createMockPaths(tempDir);

    try {
      await handleSettingsCommand({ io, paths }, ["unknown"], {});
      expect.fail("Expected settings command to throw");
    } catch (error) {
      expect(error).toBeInstanceOf(CommandError);
      expect((error as CommandError).event).toBe("settings.subcommand.unknown");
    }
  });
});