import fs from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { describe, expect, it, vi } from "vitest";
import { saveAuthProfileStore } from "../agents/auth-profiles.js";
import { clearConfigCache } from "../config/config.js";
import { withEnvAsync } from "../test-utils/env.js";
import { modelsListCommand } from "./models/list.list-command.js";

async function pathExists(pathname: string): Promise<boolean> {
  try {
    await fs.stat(pathname);
    return true;
  } catch {
    return false;
  }
}

describe("models list auth-profile sync", () => {
  it("marks models available when auth exists only in auth-profiles.json", async () => {
    const root = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-models-list-auth-sync-"));

    try {
      const stateDir = path.join(root, "state");
      const agentDir = path.join(stateDir, "agents", "main", "agent");
      const configPath = path.join(stateDir, "openclaw.json");
      await fs.mkdir(agentDir, { recursive: true });
      await fs.writeFile(configPath, "{}\n", "utf8");

      await withEnvAsync(
        {
          OPENCLAW_STATE_DIR: stateDir,
          OPENCLAW_AGENT_DIR: agentDir,
          PI_CODING_AGENT_DIR: agentDir,
          OPENCLAW_CONFIG_PATH: configPath,
          OPENROUTER_API_KEY: undefined,
        },
        async () => {
          saveAuthProfileStore(
            {
              version: 1,
              profiles: {
                "openrouter:default": {
                  type: "api_key",
                  provider: "openrouter",
                  key: "sk-or-v1-regression-test",
                },
              },
            },
            agentDir,
          );

          const authPath = path.join(agentDir, "auth.json");
          expect(await pathExists(authPath)).toBe(false);

          clearConfigCache();
          const runtime = {
            log: vi.fn(),
            error: vi.fn(),
          };

          await modelsListCommand({ all: true, json: true }, runtime as never);

          expect(runtime.error).not.toHaveBeenCalled();
          expect(runtime.log).toHaveBeenCalledTimes(1);
          const payload = JSON.parse(String(runtime.log.mock.calls[0]?.[0])) as {
            models?: Array<{ key?: string; available?: boolean }>;
          };
          const openrouter = payload.models?.find((model) =>
            String(model.key ?? "").startsWith("openrouter/"),
          );
          expect(openrouter).toBeDefined();
          expect(openrouter?.available).toBe(true);
          expect(await pathExists(authPath)).toBe(true);
        },
      );
    } finally {
      clearConfigCache();
      await fs.rm(root, { recursive: true, force: true });
    }
  });
});