import test from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";

/**
 * #10225 — combo known-context-overflow must NOT hard-reject a compressible
 * request before OmniRoute's compression pipeline can run.
 *
 * Root cause: getKnownContextOverflow() estimates the RAW body (ceil(serializedChars/4)
 * over the whole Responses input[]) during combo target resolution, before any
 * compression. When every known target limit is below that raw estimate, both call
 * sites (round-robin + target-resolution) convert it into an immediate local 400
 * `context_length_exceeded` with attempted:0 — so chatCore's proactive compression
 * (which can shrink 294133→111529, 62% in the reporter's case) never runs. The only
 * existing bypass (clientManagedResponsesContext) is gated to VERIFIED native Codex
 * clients, so a generic Responses client (e.g. OpenCode) pointed at a codex model
 * still hits the hard gate.
 *
 * Fix: thread a request-scoped `deferContextOverflowWhenCompressible` flag (set when
 * the global compression switch is ON and not API-key opted-out). When set AND at
 * least one target can run compression, getKnownContextOverflow returns null so the
 * request reaches chatCore, whose post-compression enforceOutputTokenBudget becomes
 * the final context gate — a local 400 only if the compressed body still cannot fit.
 */

const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-combo-overflow-compress-"));
const ORIGINAL_DATA_DIR = process.env.DATA_DIR;
process.env.DATA_DIR = TEST_DATA_DIR;

const core = await import("../../src/lib/db/core.ts");
const { saveModelsDevCapabilities, clearModelsDevCapabilities } =
  await import("../../src/lib/modelsDevSync.ts");
const { getKnownContextOverflow, handleComboChat } = await import(
  "../../open-sse/services/combo.ts"
);
const { updateCompressionSettings } = await import("../../src/lib/db/compression.ts");
const { handleChatCore } = await import("../../open-sse/handlers/chatCore.ts");

test.after(() => {
  core.resetDbInstance();
  if (ORIGINAL_DATA_DIR === undefined) {
    delete process.env.DATA_DIR;
  } else {
    process.env.DATA_DIR = ORIGINAL_DATA_DIR;
  }
  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
});

test.beforeEach(() => {
  clearModelsDevCapabilities();
});

function capabilityEntry(limitContext: number | null) {
  return {
    tool_call: true,
    reasoning: false,
    attachment: false,
    structured_output: true,
    temperature: true,
    modalities_input: JSON.stringify(["text"]),
    modalities_output: JSON.stringify(["text"]),
    knowledge_cutoff: null,
    release_date: null,
    last_updated: null,
    status: null,
    family: null,
    open_weights: false,
    limit_context: limitContext,
    limit_input: limitContext,
    limit_output: 4096,
    interleaved_field: null,
  };
}

function target(modelStr: string) {
  return {
    kind: "model" as const,
    stepId: modelStr,
    executionKey: modelStr,
    modelStr,
    provider: modelStr.includes("/") ? modelStr.split("/")[0] : modelStr,
    providerId: null,
    connectionId: null,
    weight: 1,
    label: null,
  };
}

// A generic Responses-API body whose estimate lands near `tokens` tokens (4 chars/token).
// Uses `input:` (not `messages:`) to mirror the OpenCode/Codex Responses surface.
function bigResponsesBody(tokens: number) {
  return { input: [["user", "x".repeat(tokens * 4)]] };
}

const noopLog = { info() {}, warn() {}, error() {}, debug() {} };

test("#10225 getKnownContextOverflow defers the hard overflow when compression is available", () => {
  saveModelsDevCapabilities({ codex: { "gpt-5.6-terra": capabilityEntry(272_000) } });
  const body = bigResponsesBody(275_000);

  // Compression enabled + target can compress -> defer (null).
  assert.equal(
    getKnownContextOverflow([target("codex/gpt-5.6-terra")], body, {
      deferContextOverflowWhenCompressible: true,
    }),
    null,
    "compressible request must defer so chatCore compression can run (#10225)"
  );

  // Compression disabled -> the existing hard overflow is preserved (never lose #7177).
  const hard = getKnownContextOverflow([target("codex/gpt-5.6-terra")], body);
  assert.ok(hard);
  assert.ok(hard.requiredContextTokens > hard.maxKnownContextTokens);

  // Compression enabled but EVERY target is excluded from compression -> keep the hard gate.
  const excluded = getKnownContextOverflow([target("codex/gpt-5.6-terra")], body, {
    deferContextOverflowWhenCompressible: true,
    compressionExclusions: ["gpt-5.6-terra"],
  });
  assert.ok(excluded, "fully-excluded targets must retain the hard preflight");
});

test("#10225 combo does not early-400 a compressible over-limit request when deferral is on", async () => {
  saveModelsDevCapabilities({ codex: { "gpt-5.6-terra": capabilityEntry(272_000) } });
  let dispatches = 0;

  const response = await handleComboChat({
    body: bigResponsesBody(275_000),
    combo: {
      name: "codex-compress-overflow",
      strategy: "priority",
      models: ["codex/gpt-5.6-terra"],
    },
    deferContextOverflowWhenCompressible: true,
    clientManagedResponsesContext: false,
    isModelAvailable: async () => true,
    handleSingleModel: async () => {
      dispatches += 1;
      return new Response("ok", { status: 200 });
    },
    log: noopLog,
  });

  assert.notEqual(response.status, 400, "compression-enabled request must reach chatCore");
  assert.equal(dispatches, 1, "must dispatch so chatCore compaction runs first");
});

test("#10225 combo keeps the fast 400 when compression is disabled", async () => {
  saveModelsDevCapabilities({ codex: { "gpt-5.6-terra": capabilityEntry(272_000) } });
  let dispatches = 0;

  const response = await handleComboChat({
    body: bigResponsesBody(275_000),
    combo: {
      name: "codex-compress-disabled",
      strategy: "priority",
      models: ["codex/gpt-5.6-terra"],
    },
    deferContextOverflowWhenCompressible: false,
    clientManagedResponsesContext: false,
    isModelAvailable: async () => true,
    handleSingleModel: async () => {
      dispatches += 1;
      return new Response("ok", { status: 200 });
    },
    log: noopLog,
  });

  assert.equal(response.status, 400);
  assert.equal(dispatches, 0, "#7177 anti-exhaustion guard must survive when compression is off");
  const body = await response.json();
  assert.equal(body.error.code, "context_length_exceeded");
});

// #10501-sweep #10503 — the deferral above is NOT target-aware by default: it only
// checks operator-named compression exclusions, never whether chatCore will actually
// attempt compression for the resolved target. handleChatCore.ts unconditionally sets
// `compressionExcluded = nativeCodexPassthrough || ...` for a verified native Codex
// Responses passthrough target (open-sse/handlers/chatCore.ts) — deferring the
// preflight there means an oversized request sails past BOTH gates uncompressed. These
// tests pin the fix: a native-codex-passthrough target must never count toward "can
// compress", so the hard preflight stays active and no upstream dispatch happens.
// NOTE on `clientManagedResponsesContext: false` below: these tests deliberately do
// NOT set it, to isolate the fix from the PRE-EXISTING, unrelated early-return a few
// lines above in knownContextOverflow.ts ("Native Codex Responses clients compact
// their own item history") — that block ALSO returns null for an all-codex pool, but
// only when `clientManagedResponsesContext === true` (a VERIFIED native client). The
// bug this fix targets is broader: chatCore's `shouldUseNativeCodexPassthrough` short-
// circuits to true for `provider === "codex"` regardless of verification (see
// passthroughHelpers.ts), so an UNVERIFIED request that nonetheless targets a `codex`
// combo member over `/v1/responses` in openai-responses format still hits chatCore's
// compression bypass — exactly the gap `sourceFormat`/`endpointPath` (not the looser
// `clientManagedResponsesContext` flag) now closes.
test("#10503 getKnownContextOverflow REFUSES to defer when the only target is native Codex Responses passthrough", () => {
  saveModelsDevCapabilities({ codex: { "gpt-5.6-terra": capabilityEntry(272_000) } });
  const body = bigResponsesBody(275_000);

  const overflow = getKnownContextOverflow([target("codex/gpt-5.6-terra")], body, {
    deferContextOverflowWhenCompressible: true,
    sourceFormat: "openai-responses",
    endpointPath: "/v1/responses",
  });

  assert.ok(
    overflow,
    "a native-codex-passthrough target must never be treated as compressible — the " +
      "hard preflight must stay active (chatCore disables compression for it entirely)"
  );
});

test("#10503 getKnownContextOverflow still defers when a genuinely compressible sibling target is present", () => {
  saveModelsDevCapabilities({
    codex: { "gpt-5.6-terra": capabilityEntry(272_000) },
    openai: { "gpt-5.6-terra": capabilityEntry(272_000) },
  });
  const body = bigResponsesBody(275_000);

  // A heterogeneous pool where at least ONE target (openai) genuinely runs
  // compression must still defer — deferral is a per-request decision, and other
  // targets in the pool are unaffected by the codex-specific compression bypass.
  const overflow = getKnownContextOverflow(
    [target("codex/gpt-5.6-terra"), target("openai/gpt-5.6-terra")],
    body,
    {
      deferContextOverflowWhenCompressible: true,
      sourceFormat: "openai-responses",
      endpointPath: "/v1/responses",
    }
  );

  assert.equal(overflow, null, "a genuinely compressible sibling target must still defer");
});

test("#10503 handleComboChat: native-codex-passthrough pool fails FAST locally, zero upstream dispatches", async () => {
  saveModelsDevCapabilities({ codex: { "gpt-5.6-terra": capabilityEntry(272_000) } });
  let dispatches = 0;

  const response = await handleComboChat({
    body: bigResponsesBody(275_000),
    combo: {
      name: "codex-native-passthrough-overflow",
      strategy: "priority",
      models: ["codex/gpt-5.6-terra"],
    },
    deferContextOverflowWhenCompressible: true,
    sourceFormat: "openai-responses",
    endpointPath: "/v1/responses",
    isModelAvailable: async () => true,
    handleSingleModel: async () => {
      dispatches += 1;
      return new Response("ok", { status: 200 });
    },
    log: noopLog,
  });

  assert.equal(
    response.status,
    400,
    "must fail fast locally instead of dispatching an oversized, uncompressible request"
  );
  assert.equal(dispatches, 0, "no wasted upstream call for a target that can never compress");
  const responseBody = await response.json();
  assert.equal(responseBody.error.code, "context_length_exceeded");
});

// #10503 item 2 — drive the REAL chatCore compression pipeline end-to-end (not just the
// pure getKnownContextOverflow helper): a genuinely compressible multi-turn request must
// have chatCore's proactive/last-resort compression actually run and dispatch the
// COMPRESSED body upstream; a request that is STILL too large after compression must be
// rejected locally with zero upstream dispatch (fail-fast, matching the codex-passthrough
// case above in outcome, but via the "compression tried and wasn't enough" path instead
// of "compression was never eligible").
//
// Uses an unregistered synthetic provider + CONTEXT_LENGTH_<PROVIDER> env override
// (same technique as tests/unit/chatcore-combo-context-limit-8378.test.ts) so the
// context limit is small and deterministic without depending on any real catalog entry.
// Compression targets conversation HISTORY (older turns), not the current terminal
// message — this is why the fixtures below build many small history turns plus one
// short final turn (compressible case) vs one large, irreducible final turn
// (still-too-large case).
const CHATCORE_PROBE_PROVIDER = "combo10503probe";
const CHATCORE_PROBE_MODEL = "combo10503probemodel";
const CHATCORE_LIMIT_ENV = "CONTEXT_LENGTH_COMBO10503PROBE";

function buildHistoryBody(turns: number, finalMessageChars: number) {
  const messages: Array<{ role: string; content: string }> = [
    { role: "system", content: "You are a helpful assistant." },
  ];
  for (let i = 0; i < turns; i++) {
    messages.push({
      role: "user",
      content: `Message number ${i}: Alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mno pqr stu.`,
    });
    messages.push({
      role: "assistant",
      content: `Reply number ${i}: verbose filler answer with extra padding text for realism.`,
    });
  }
  messages.push({ role: "user", content: "FINAL: " + "z".repeat(finalMessageChars) });
  return { model: CHATCORE_PROBE_MODEL, messages, stream: false };
}

async function invokeChatCoreCapturingUpstream(body: Record<string, unknown>) {
  const originalFetch = globalThis.fetch;
  let dispatched = false;
  let sentBodyJson: string | null = null;
  globalThis.fetch = async (_url: RequestInfo | URL, init: RequestInit = {}) => {
    dispatched = true;
    sentBodyJson = init.body ? String(init.body) : null;
    return new Response(
      JSON.stringify({
        id: "chatcmpl-10503",
        object: "chat.completion",
        model: CHATCORE_PROBE_MODEL,
        choices: [
          { index: 0, message: { role: "assistant", content: "ok" }, finish_reason: "stop" },
        ],
        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
      }),
      { status: 200, headers: { "content-type": "application/json" } }
    );
  };
  try {
    const result = await handleChatCore({
      body,
      modelInfo: {
        provider: CHATCORE_PROBE_PROVIDER,
        model: CHATCORE_PROBE_MODEL,
        extendedContext: false,
      },
      credentials: { apiKey: "sk-test", providerSpecificData: {} },
      log: { debug() {}, info() {}, warn() {}, error() {} },
      clientRawRequest: {
        endpoint: "/v1/chat/completions",
        body,
        headers: new Headers({ accept: "application/json" }),
      },
      userAgent: "unit-test",
    } as never);
    return { result, dispatched, sentBodyJson };
  } finally {
    globalThis.fetch = originalFetch;
  }
}

test("#10503 real chatCore path: a compressible request dispatches the COMPRESSED (not raw) body upstream", async () => {
  const originalEnv = process.env[CHATCORE_LIMIT_ENV];
  process.env[CHATCORE_LIMIT_ENV] = "500";
  await updateCompressionSettings({
    enabled: true,
    defaultMode: "standard",
    autoTriggerTokens: 1,
    autoTriggerMode: "standard",
    engines: { rtk: { enabled: true }, caveman: { enabled: true } },
  } as never);
  try {
    const body = buildHistoryBody(150, 50);
    const rawLen = JSON.stringify(body.messages).length;

    const { dispatched, sentBodyJson } = await invokeChatCoreCapturingUpstream(body);

    assert.ok(dispatched, "compression must let a genuinely compressible request reach chatCore's dispatch");
    assert.ok(sentBodyJson, "the dispatched request must carry a body");
    assert.ok(
      sentBodyJson!.length < rawLen * 0.5,
      `expected the DISPATCHED body (${sentBodyJson!.length} chars) to be substantially ` +
        `smaller than the raw request (${rawLen} chars) — proves compression actually ran ` +
        `and its output (not the raw body) is what reached upstream`
    );
  } finally {
    if (originalEnv === undefined) delete process.env[CHATCORE_LIMIT_ENV];
    else process.env[CHATCORE_LIMIT_ENV] = originalEnv;
  }
});

test("#10503 real chatCore path: STILL too large after compression → local rejection, ZERO upstream dispatch", async () => {
  const originalEnv = process.env[CHATCORE_LIMIT_ENV];
  process.env[CHATCORE_LIMIT_ENV] = "50";
  await updateCompressionSettings({
    enabled: true,
    defaultMode: "standard",
    autoTriggerTokens: 1,
    autoTriggerMode: "standard",
    engines: { rtk: { enabled: true }, caveman: { enabled: true } },
  } as never);
  try {
    // The final turn alone (1000 chars, irreducible — compression trims HISTORY, not
    // the current terminal message) already exceeds the 50-token limit, so no amount
    // of history compaction can make this fit.
    const body = buildHistoryBody(150, 1000);

    const { result, dispatched } = await invokeChatCoreCapturingUpstream(body);

    assert.equal(
      dispatched,
      false,
      "fail-fast: a request that cannot fit even after compression must never reach fetch()"
    );
    assert.equal((result as { success: boolean }).success, false);
    const failure = result as { success: false; error?: string; rawMessage?: string };
    const message = failure.rawMessage ?? failure.error ?? "";
    assert.match(message, /exceeds/i);
  } finally {
    if (originalEnv === undefined) delete process.env[CHATCORE_LIMIT_ENV];
    else process.env[CHATCORE_LIMIT_ENV] = originalEnv;
  }
});