import { readFileSync } from "node:fs";

import { describe, expect, test } from "vitest";

import * as embeddingApi from "../src/embedding/index.js";
import * as sdk from "../src/index.js";
import { LocalLlamaCppProvider } from "../src/embedding/local.js";
import { LlamaCpp, pullModels } from "../src/llm.js";
import {
  COMMERCIAL_API_HOLD_CODE,
  CommercialApiHoldError,
} from "../src/model-policy.js";

function expectTypedHold(error: unknown): void {
  expect(error).toBeInstanceOf(CommercialApiHoldError);
  expect(error).toMatchObject({
    code: COMMERCIAL_API_HOLD_CODE,
    disposition: "HOLD",
  });
}

describe("commercial-only package policy", () => {
  test("the public SDK does not export local or fallback providers", () => {
    for (const api of [sdk, embeddingApi]) {
      expect(api).not.toHaveProperty("LocalLlamaCppProvider");
      expect(api).not.toHaveProperty("AutoFallbackEmbeddingProvider");
    }
  });

  test("package manifests contain no local model runtime or model artifact dependency", () => {
    const manifest = JSON.parse(
      readFileSync(new URL("../package.json", import.meta.url), "utf8"),
    ) as Record<string, Record<string, string> | undefined>;
    const dependencyNames = [
      ...Object.keys(manifest.dependencies ?? {}),
      ...Object.keys(manifest.optionalDependencies ?? {}),
      ...Object.keys(manifest.devDependencies ?? {}),
    ];

    expect(dependencyNames).not.toContain("node-llama-cpp");
    for (const lockFile of ["../pnpm-lock.yaml", "../bun.lock"]) {
      const lock = readFileSync(new URL(lockFile, import.meta.url), "utf8");
      expect(lock).not.toMatch(/node-llama-cpp|\.gguf\b|huggingface\.co/i);
    }
  });

  test("historical local construction and model pulls return typed HOLD", async () => {
    try {
      new LocalLlamaCppProvider();
      throw new Error("local provider construction unexpectedly succeeded");
    } catch (error) {
      expectTypedHold(error);
    }

    try {
      await pullModels(["forbidden-model-artifact"]);
      throw new Error("model pull unexpectedly succeeded");
    } catch (error) {
      expectTypedHold(error);
    }
  });

  test("learned compatibility operations fail closed without a commercial adapter", async () => {
    const llm = new LlamaCpp();
    const operations = [
      () => llm.embed("text"),
      () => llm.embedBatch(["text"]),
      () => llm.generate("prompt"),
      () => llm.expandQuery("query"),
      () => llm.rerank("query", [{ file: "doc", text: "body" }]),
    ];

    for (const operation of operations) {
      try {
        await operation();
        throw new Error("learned operation unexpectedly succeeded");
      } catch (error) {
        expectTypedHold(error);
      }
    }
  });
});