import { bindAnthropicRejectionPolicy } from "../../adapters/anthropic-rejection-memo";
import { getReasoningReplayOpaqueBlobRejection } from "../../responses/reasoning-replay-cache";
import type {
  OcxProviderContinuationOwner,
  OcxProviderContinuationState,
  OcxParsedRequest,
  OcxProviderConfig,
  OcxReasoningReplayIdentity,
  AdapterEvent,
} from "../../types";
import {
  isValidProviderContinuationOwner,
  sameProviderContinuationOwner,
  providerContinuationOwnerFromReplayIdentity,
  providerContinuationRouteScope,
} from "../../responses/provider-continuation";
import {
  reasoningReplayDestinationIdentity,
  reasoningReplayOAuthCredentialIdentity,
  durableReplayCredentialIdentity,
  reasoningReplayCodexCredentialIdentity,
  reasoningReplayKeyCredentialIdentity,
  durableReplayDestinationIdentity,
  nativeReasoningTag,
  nativeReasoningTagMatches,
  type NativeReasoningOwner,
  bindReasoningReplayScope,
  reasoningReplayServingIdentityChanged,
  reasoningReplayServingIdentityChange,
  reasoningReplayItemStoreChanged,
  reasoningReplayOpaqueBlobRejectionMemoized,
} from "../../responses/reasoning-replay-cache";
import type { OAuthAccessSnapshot } from "../../oauth";
import type { CodexAuthContext } from "../../codex/auth-context";
import { thoughtSignatureReplaySalt } from "../../responses/thought-signature-replay";
import { randomUUID } from "node:crypto";
import { requiresPlaintextReasoningReplay } from "../../adapters/openai-responses/passthrough";
import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";

/**
 * Adapters whose continuation state must survive Codex's store:false requests.
 */
export function adapterNeedsForcedContinuation(name: string): boolean {
  return name === "kiro" || name === "cursor";
}

/** Adapters opting into restricted store:false replay for pending client function calls. */
export function adapterNeedsToolCallContinuation(name: string): boolean {
  return name === "qoder";
}


export type ContinuationOwnerRead =
  | { kind: "missing" }
  | { kind: "invalid" }
  | { kind: "valid"; owner: OcxProviderContinuationOwner };


export function readProviderContinuationOwner(
  state: OcxProviderContinuationState | undefined,
): ContinuationOwnerRead {
  if (!state || state.__ocxOwner === undefined) return { kind: "missing" };
  const owner = state.__ocxOwner;
  if (!isValidProviderContinuationOwner(owner)) return { kind: "invalid" };
  return { kind: "valid", owner: { ...owner } };
}


export function providerContinuationPayload(
  state: OcxProviderContinuationState | undefined,
): OcxProviderContinuationState | undefined {
  if (!state) return undefined;
  const cloned = structuredClone(state);
  delete cloned.__ocxOwner;
  return Object.keys(cloned).length > 0 ? cloned : undefined;
}


export function bindProviderContinuationForRoute(
  parsed: OcxParsedRequest,
  currentOwner: OcxProviderContinuationOwner | undefined,
): void {
  const candidate = parsed._providerContinuationCandidate;
  const storedOwner = readProviderContinuationOwner(candidate);
  const mayRestore = storedOwner.kind === "valid"
    && !!currentOwner
    && sameProviderContinuationOwner(storedOwner.owner, currentOwner);
  const restored = mayRestore ? providerContinuationPayload(candidate) : undefined;
  if (restored) parsed._providerContinuation = restored;
  else delete parsed._providerContinuation;
  const cursorConversationId = restored?.cursor?.conversationId;
  if (cursorConversationId) parsed._cursorConversationId = cursorConversationId;
  else delete parsed._cursorConversationId;
  if (currentOwner) parsed._providerContinuationOwner = { ...currentOwner };
  else delete parsed._providerContinuationOwner;
}


export function providerContinuationDestinationIdentity(
  parsed: OcxParsedRequest,
  provider: OcxProviderConfig,
): string | undefined {
  const kiroContext = parsed._kiroAuthContext;
  return reasoningReplayDestinationIdentity(JSON.stringify([
    provider.baseUrl.trim().replace(/\/+$/, ""),
    provider.responsesPath ?? "",
    kiroContext?.profileArn ?? "",
    kiroContext?.apiRegion ?? "",
    kiroContext?.ssoRegion ?? "",
  ]));
}


export function bindRouteReasoningReplayScope(args: {
  parsed: OcxParsedRequest;
  providerName: string;
  provider: OcxProviderConfig;
  adapterName: string;
  oauthCredentialSnapshot?: Pick<OAuthAccessSnapshot, "accountId" | "generation">;
  codexAuthContext?: CodexAuthContext;
  forwardHeaders?: Headers;
}): void {
  const { parsed, providerName, provider, adapterName } = args;
  const replayIdentity = routeReasoningReplayIdentity({
    ...args,
    modelId: parsed.modelId,
  });
  const owner = nativeReasoningOwnerForRoute(args);
  if (owner) parsed._nativeReasoningBoundOwner = owner;
  else delete parsed._nativeReasoningBoundOwner;
  if (parsed._nativeReasoningReplay?.size) {
    const rejected = new Set<string>();
    for (const [blob, tag] of parsed._nativeReasoningReplay) {
      if (!nativeReasoningTagMatches(nativeReasoningTag(owner, blob), tag)) {
        rejected.add(blob);
      }
    }
    if (rejected.size) stripNativeReasoningBlobs(parsed, rejected);
  }
  const continuationDestinationIdentity = providerContinuationDestinationIdentity(parsed, provider);
  const continuationOwner = providerContinuationOwnerFromReplayIdentity(
    replayIdentity && continuationDestinationIdentity
      ? { ...replayIdentity, providerDestinationIdentity: continuationDestinationIdentity }
      : undefined,
  );
  if (adapterName === "cursor") {
    // The final route owner is authoritative for Cursor and supersedes the account-derived
    // seed assigned before route binding. A Cursor conversation must be scoped to the exact
    // provider/destination/adapter/model/credential that serves it.
    if (continuationOwner) parsed._cursorIdentityScope = providerContinuationRouteScope(continuationOwner);
    else if (!parsed._cursorIdentityScope?.startsWith("cursor-unowned:")) {
      // Prevent the adapter's token-only fallback from recreating a provider-private id after the
      // route owner failed closed. The sentinel is per parsed request and contains no credential.
      parsed._cursorIdentityScope = `cursor-unowned:${randomUUID()}`;
    }
  }
  bindReasoningReplayScope(
    parsed._reasoningReplayScope,
    replayIdentity,
  );
  // Keep this sticky for the whole outbound request: a later auth/key rebind may compare equal
  // after the first mismatch, but it cannot make history minted by the prior route decodable.
  const identityChange = reasoningReplayServingIdentityChange(parsed._reasoningReplayScope);
  if (identityChange) {
    // Reasoning retention does not establish portability of native compacted history.
    parsed._stripNativeCompactionEncryptedContent = true;
    const retention = parsed._nativeReasoningRetention;
    const mayRetainReasoning = isCanonicalOpenAiForwardProvider(provider)
      && !identityChange.providerChanged
      && !identityChange.destinationChanged
      && !identityChange.adapterChanged
      && (!identityChange.modelChanged || retention?.modelSwitch === true)
      && (!identityChange.credentialChanged || retention?.accountSwitch === true);
    if (!mayRetainReasoning) parsed._stripReasoningEncryptedContent = true;
    else if (parsed._stripReasoningEncryptedContent !== true) parsed._nativeReasoningRetainedAcrossRoute = true;
    // Only a different destination or credential makes the replayed item ids unresolvable; a
    // model change on the same store keeps them.
    if (reasoningReplayItemStoreChanged(parsed._reasoningReplayScope)) {
      parsed._dropForeignReasoningItemIds = true;
    }
  }
  const rejectionMemo = getReasoningReplayOpaqueBlobRejection(parsed._reasoningReplayScope);
  bindAnthropicRejectionPolicy(parsed, adapterName === "anthropic" ? rejectionMemo : undefined);
  if (reasoningReplayOpaqueBlobRejectionMemoized(parsed._reasoningReplayScope)) {
    if (adapterName !== "anthropic" || rejectionMemo?.mode !== "selective") parsed._stripReasoningEncryptedContent = true;
    parsed._stripNativeCompactionEncryptedContent = true;
    parsed._dropForeignReasoningItemIds = true;
  }
  // Stripping is authoritative: nothing retained remains to be refused.
  if (parsed._stripReasoningEncryptedContent === true) delete parsed._nativeReasoningRetainedAcrossRoute;
  bindProviderContinuationForRoute(parsed, continuationOwner);
}

function stripNativeReasoningBlobs(parsed: OcxParsedRequest, rejected: ReadonlySet<string>): void {
  const input = (parsed._rawBody as { input?: unknown } | undefined)?.input;
  if (Array.isArray(input)) {
    for (const item of input) {
      if (item && typeof item === "object" && item.type === "reasoning" && rejected.has(item.encrypted_content)) {
        delete item.encrypted_content;
        delete item.id;
      }
    }
  }
  for (const message of parsed.context.messages) {
    if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
    for (const part of message.content) {
      if (part.type !== "thinking" || typeof part.signature !== "string") continue;
      try {
        const item: unknown = JSON.parse(part.signature);
        if (!item || typeof item !== "object" || Array.isArray(item)) continue;
        const reasoning = item as Record<string, unknown>;
        if (reasoning.type !== "reasoning" || typeof reasoning.encrypted_content !== "string"
          || !rejected.has(reasoning.encrypted_content)) continue;
        delete reasoning.encrypted_content;
        delete reasoning.id;
        part.signature = JSON.stringify(reasoning);
        delete part.itemId;
      } catch { /* A provider signature is not the parser's JSON carrier. */ }
    }
  }
}

export function nativeReasoningOwnerForRoute(args: {
  provider: OcxProviderConfig;
  oauthCredentialSnapshot?: Pick<OAuthAccessSnapshot, "accountId" | "generation">;
  codexAuthContext?: CodexAuthContext;
}): NativeReasoningOwner | undefined {
  const { provider } = args;
  const salt = thoughtSignatureReplaySalt();
  if (!salt || salt.length < 16) return undefined;
  const destination = durableReplayDestinationIdentity(JSON.stringify([
    provider.baseUrl.trim().replace(/\/+$/, ""), provider.responsesPath ?? "",
  ]));
  let credential: string | undefined;
  if (provider.authMode === "oauth") {
    const snapshot = args.oauthCredentialSnapshot;
    if (snapshot?.accountId && snapshot.generation !== undefined) credential = durableReplayCredentialIdentity(
      "oauth", `${snapshot.accountId}\0${snapshot.generation}`, provider.headers, salt,
    );
  } else if (provider.authMode === "forward") {
    const context = args.codexAuthContext;
    if (context && (context.kind === "pool" || context.kind === "main-pool")
      && context.accountId && context.writerGeneration !== undefined
      && (context.kind !== "pool" || context.generation !== undefined)) {
      credential = durableReplayCredentialIdentity("codex", JSON.stringify([
        context.accountId, context.kind === "pool" ? context.generation : null, context.writerGeneration,
      ]), provider.headers, salt);
    }
  } else if (provider.authMode !== "local") {
    credential = durableReplayCredentialIdentity("key", nonEmptyProviderApiKey(provider), provider.headers, salt);
  }
  return destination && credential ? { destination, credential } : undefined;
}


function routeReasoningReplayIdentity(args: {
  providerName: string;
  provider: OcxProviderConfig;
  adapterName: string;
  modelId: string;
  oauthCredentialSnapshot?: Pick<OAuthAccessSnapshot, "accountId" | "generation">;
  codexAuthContext?: CodexAuthContext;
  forwardHeaders?: Headers;
}): OcxReasoningReplayIdentity | undefined {
  const { providerName, provider, adapterName, modelId } = args;
  let credentialIdentity: string | undefined;
  let credentialDurableIdentity: string | undefined;
  const durableSalt = thoughtSignatureReplaySalt();
  if (provider.authMode === "oauth") {
    credentialIdentity = reasoningReplayOAuthCredentialIdentity(
      args.oauthCredentialSnapshot,
      provider.headers,
    );
    // The persisted account-slot id survives token refresh and restarts; the rotating
    // generation deliberately does NOT participate (#1926 design: rotation-safe).
    credentialDurableIdentity = durableReplayCredentialIdentity(
      "oauth",
      args.oauthCredentialSnapshot?.accountId,
      provider.headers,
      durableSalt,
    );
  } else if (provider.authMode === "forward") {
    const poolContext = args.codexAuthContext?.kind === "pool"
      || args.codexAuthContext?.kind === "main-pool"
      ? args.codexAuthContext
      : undefined;
    credentialIdentity = reasoningReplayCodexCredentialIdentity({
      authorization: poolContext
        ? `Bearer ${poolContext.accessToken}`
        : args.forwardHeaders?.get("authorization"),
      chatgptAccountId: poolContext?.chatgptAccountId
        ?? args.forwardHeaders?.get("chatgpt-account-id"),
      accountId: poolContext?.accountId,
      credentialGeneration: poolContext?.kind === "pool"
        ? poolContext.generation
        : undefined,
      writerGeneration: poolContext?.writerGeneration,
      headers: provider.headers,
    });
    // Durable identity requires a STABLE, TRUSTED account handle. Pool context comes from
    // our own account store; a client-supplied chatgpt-account-id header is attacker
    // -influenceable bucket selection and a bearer alone is rotating material — both are
    // refused, so direct-forward turns get no durable scope (fail closed; the in-process
    // cache still covers same-process replay).
    const codexDurableHandle = poolContext?.accountId
      ?? poolContext?.chatgptAccountId
      ?? undefined;
    credentialDurableIdentity = durableReplayCredentialIdentity(
      "codex",
      codexDurableHandle ?? undefined,
      provider.headers,
      durableSalt,
    );
  } else if (provider.authMode !== "local") {
    credentialIdentity = reasoningReplayKeyCredentialIdentity(provider);
    credentialDurableIdentity = durableReplayCredentialIdentity(
      "key",
      nonEmptyProviderApiKey(provider),
      provider.headers,
      durableSalt,
    );
  }
  const providerDestinationIdentity = reasoningReplayDestinationIdentity(provider.baseUrl);
  return credentialIdentity && providerDestinationIdentity
    ? {
        providerName,
        providerDestinationIdentity,
        providerDestinationDurableIdentity: durableReplayDestinationIdentity(provider.baseUrl),
        adapterName,
        modelId,
        credentialIdentity,
        ...(credentialDurableIdentity ? { credentialDurableIdentity } : {}),
      }
    : undefined;
}


/**
 * Whether this exact route cannot satisfy its documented plaintext reasoning replay contract.
 *
 * A generic plaintext-preserving gateway is not made ineligible. Unknown serving provenance also
 * stays eligible; only a proven route mismatch may suppress a combo candidate.
 */
export function mandatoryResponsesReasoningReplayUnavailable(args: {
  body: unknown;
  clientThreadId: string | undefined;
  clientPrincipalId?: string;
  providerName: string;
  provider: OcxProviderConfig;
  adapterName: string;
  modelId: string;
}): boolean {
  const { body, clientThreadId, provider, adapterName } = args;
  if (
    adapterName !== "openai-responses"
    || !requiresPlaintextReasoningReplay(provider)
    || !clientThreadId
    || !requestCarriesTools(body)
    || !hasOpaqueOnlyReasoningItem(body)
  ) return false;

  const current = routeReasoningReplayIdentity(args);
  return reasoningReplayServingIdentityChanged({ clientThreadId, clientPrincipalId: args.clientPrincipalId, current });
}


function requestCarriesTools(body: unknown): boolean {
  if (!body || typeof body !== "object" || Array.isArray(body)) return false;
  return Array.isArray((body as { tools?: unknown }).tools)
    && (body as { tools: unknown[] }).tools.length > 0;
}


function hasOpaqueOnlyReasoningItem(body: unknown): boolean {
  if (!body || typeof body !== "object" || Array.isArray(body)) return false;
  const input = (body as { input?: unknown }).input;
  if (!Array.isArray(input)) return false;
  return input.some(item => {
    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
    const reasoning = item as Record<string, unknown>;
    if (reasoning.type !== "reasoning" || typeof reasoning.encrypted_content !== "string") return false;
    const content = reasoning.content;
    const hasPlaintext = Array.isArray(content) && content.some(part =>
      !!part && typeof part === "object" && !Array.isArray(part)
      && (part as Record<string, unknown>).type === "reasoning_text"
      && typeof (part as Record<string, unknown>).text === "string"
      && ((part as Record<string, unknown>).text as string).length > 0
    );
    return !hasPlaintext;
  });
}


export function adapterResponseReachedServingTerminal(
  events: readonly AdapterEvent[],
  response: Readonly<Record<string, unknown>>,
): boolean {
  return (response.status === "completed" || response.status === "incomplete")
    && events.some(event => event.type === "done" || event.type === "incomplete");
}


export function nonEmptyProviderApiKey(provider: OcxProviderConfig): string | undefined {
  return typeof provider.apiKey === "string" && provider.apiKey.trim().length > 0
    ? provider.apiKey
    : undefined;
}
