import type { OcxProviderConfig } from "../types";
import { MODEL_ADAPTER_OVERRIDE_ALLOWED } from "../types";
import type { InboundWire, ModelWireDefault, ProviderRegistryEntry } from "./registry/types";

export type StaticPolicySource =
  | "operator" | "operator-capability" | "captured-auth"
  | "registry" | "hard-pin" | "provider-default" | "unknown";

export function detachedClone<T>(value: T): T {
  if (Array.isArray(value)) return value.map(item => detachedClone(item)) as T;
  if (value && typeof value === "object") {
    return Object.fromEntries(Object.entries(value as Record<string, unknown>)
      .map(([key, nested]) => [key, detachedClone(nested)])) as T;
  }
  return value;
}

export function recursivelyFreeze<T>(value: T): T {
  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
  for (const nested of Object.values(value as Record<string, unknown>)) recursivelyFreeze(nested);
  return Object.freeze(value);
}

export function scalar<T>(operator: T | undefined, registry: T | undefined): [T | undefined, StaticPolicySource] {
  if (operator !== undefined) return [detachedClone(operator), "operator"];
  if (registry !== undefined) return [detachedClone(registry), "registry"];
  return [undefined, "unknown"];
}

export function mapFill<T>(
  registry: Readonly<Record<string, T>> | undefined,
  operator: Readonly<Record<string, T>> | undefined,
): [Record<string, T> | undefined, StaticPolicySource] {
  if (!registry && !operator) return [undefined, "unknown"];
  // Per-model lookups fold case (legacyModelValue), so a case-varied operator key must claim the
  // registry row here; leaving both keys lets the earlier registry entry shadow the override.
  const claimed = new Set(Object.keys(operator ?? {}).map(key => key.toLowerCase()));
  const merged: Record<string, T> = {};
  for (const [key, value] of Object.entries(registry ?? {})) {
    if (!claimed.has(key.toLowerCase())) merged[key] = value;
  }
  for (const [key, value] of Object.entries(operator ?? {})) merged[key] = value;
  return [detachedClone(merged), operator ? "operator" : "registry"];
}

export function nestedMapFill(
  registry: Readonly<Record<string, Record<string, string>>> | undefined,
  operator: Readonly<Record<string, Record<string, string>>> | undefined,
): [Record<string, Record<string, string>> | undefined, StaticPolicySource] {
  if (!registry && !operator) return [undefined, "unknown"];
  // The outer model key folds case like mapFill: a case-varied operator key claims the registry
  // row instead of shadowing behind it, while the claimed row's inner entries still fill
  // underneath the operator's inner map.
  const claimed = new Set(Object.keys(operator ?? {}).map(key => key.toLowerCase()));
  const merged: Record<string, Record<string, string>> = {};
  const claimedInner: Record<string, Record<string, string>> = {};
  for (const [key, value] of Object.entries(registry ?? {})) {
    const folded = key.toLowerCase();
    if (claimed.has(folded)) claimedInner[folded] = { ...(claimedInner[folded] ?? {}), ...value };
    else merged[key] = { ...value };
  }
  for (const [key, value] of Object.entries(operator ?? {})) {
    merged[key] = { ...(claimedInner[key.toLowerCase()] ?? merged[key] ?? {}), ...value };
  }
  return [merged, operator ? "operator" : "registry"];
}

export function positiveCapMap(
  registry: Readonly<Record<string, number>> | undefined,
  operator: Readonly<Record<string, number>> | undefined,
): [Record<string, number> | undefined, StaticPolicySource] {
  const [merged, source] = mapFill(registry, operator);
  if (!merged) return [undefined, source];
  // The operator owns a case-equal row, as in mapFill, but cannot widen its registry cap.
  const registryCaps = new Map<string, number>();
  for (const [key, value] of Object.entries(registry ?? {})) {
    const folded = key.toLowerCase();
    registryCaps.set(folded, Math.min(registryCaps.get(folded) ?? value, value));
  }
  for (const [key, value] of Object.entries(operator ?? {})) {
    const cap = registryCaps.get(key.toLowerCase());
    merged[key] = cap === undefined ? value : Math.min(cap, value);
  }
  return [merged, source];
}

export function stableUnion(
  registry: readonly string[] | undefined,
  operator: readonly string[] | undefined,
): [string[] | undefined, StaticPolicySource] {
  if (!registry && !operator) return [undefined, "unknown"];
  return [[...new Set([...(registry ?? []), ...(operator ?? [])])], operator ? "operator" : "registry"];
}

export function staticHeaders(
  registry: Readonly<Record<string, string>> | undefined,
  operator: Readonly<Record<string, string>> | undefined,
): [Record<string, string> | undefined, StaticPolicySource] {
  if (!registry && !operator) return [undefined, "unknown"];
  if (!registry) return [{ ...(operator ?? {}) }, "operator"];
  if (!operator) return [{ ...registry }, "registry"];
  const claimed = new Set(Object.keys(operator).map(name => name.toLowerCase()));
  const merged: Record<string, string> = { ...operator };
  for (const [name, value] of Object.entries(registry)) {
    if (!claimed.has(name.toLowerCase())) merged[name] = value;
  }
  return [merged, "operator"];
}

export function resolvedBaseUrl(
  entry: Readonly<ProviderRegistryEntry> | undefined,
  provider: Readonly<OcxProviderConfig>,
): [string, StaticPolicySource] {
  if (!entry) return [provider.baseUrl, "operator"];
  const configured = typeof provider.baseUrl === "string" ? provider.baseUrl.trim() : "";
  const configuredIsResolved = configured.length > 0 && !/\{[^}]*\}/.test(configured);
  if (entry.allowBaseUrlOverride && !configuredIsResolved) {
    throw new Error(`Invalid baseUrl for provider "${entry.id}": expected a nonblank URL without unresolved placeholders`);
  }
  return (/\{[^}]*\}/.test(entry.baseUrl) || entry.allowBaseUrlOverride) && configuredIsResolved
    ? [configured, "operator"]
    : [entry.baseUrl, "registry"];
}

export function sameStringArray(left: readonly string[] | undefined, right: readonly string[]): boolean {
  return left?.length === right.length && left.every((value, index) => value === right[index]);
}

/** Legacy config-map lookup: exact id, colon family, then case-folded exact id. */
export function legacyModelValue<T>(record: Readonly<Record<string, T>> | undefined, modelId: string): T | undefined {
  if (!record) return undefined;
  if (Object.hasOwn(record, modelId)) return record[modelId];
  const colon = modelId.indexOf(":");
  if (colon > 0 && Object.hasOwn(record, modelId.slice(0, colon))) return record[modelId.slice(0, colon)];
  const folded = modelId.toLowerCase();
  return Object.entries(record).find(([key]) => key.toLowerCase() === folded)?.[1];
}

/** Provenance from the same merged-key walk as legacyModelValue. */
export function legacyModelSource<T>(
  operator: Readonly<Record<string, T>> | undefined,
  registry: Readonly<Record<string, T>> | undefined,
  modelId: string,
): StaticPolicySource {
  if (!registry) {
    if (!operator) return "unknown";
    if (Object.hasOwn(operator, modelId)) return "operator";
    const colon = modelId.indexOf(":");
    if (colon > 0 && Object.hasOwn(operator, modelId.slice(0, colon))) return "operator";
    const folded = modelId.toLowerCase();
    return Object.keys(operator).some(key => key.toLowerCase() === folded) ? "operator" : "unknown";
  }
  // Match mapFill's case-folded ownership so provenance follows the value lookup.
  const claimed = new Set(Object.keys(operator ?? {}).map(key => key.toLowerCase()));
  const merged: Record<string, T> = {};
  for (const [key, value] of Object.entries(registry ?? {})) {
    if (!claimed.has(key.toLowerCase())) merged[key] = value;
  }
  for (const [key, value] of Object.entries(operator ?? {})) merged[key] = value;
  let winningKey: string | undefined;
  if (Object.hasOwn(merged, modelId)) winningKey = modelId;
  const colon = modelId.indexOf(":");
  if (winningKey === undefined && colon > 0 && Object.hasOwn(merged, modelId.slice(0, colon))) {
    winningKey = modelId.slice(0, colon);
  }
  if (winningKey === undefined) {
    const folded = modelId.toLowerCase();
    winningKey = Object.keys(merged).find(key => key.toLowerCase() === folded);
  }
  if (winningKey === undefined) return "unknown";
  return Object.hasOwn(operator ?? {}, winningKey) ? "operator" : "registry";
}

export function anthropicFamilyContextWindow(
  record: Readonly<Record<string, number>> | undefined,
  id: string,
): number | undefined {
  if (!record || !id.toLowerCase().startsWith("claude-")) return undefined;
  let candidate = id;
  while (true) {
    const cut = candidate.lastIndexOf("-");
    if (cut <= 0 || !/^\d+$/.test(candidate.slice(cut + 1))) return undefined;
    candidate = candidate.slice(0, cut);
    const value = record[candidate]
      ?? Object.entries(record).find(([key]) => key.toLowerCase() === candidate.toLowerCase())?.[1];
    if (typeof value === "number" && value > 0) return value;
  }
}

export function wireDefault(
  declared: ModelWireDefault | undefined,
  provider: Readonly<OcxProviderConfig>,
  entry: Readonly<ProviderRegistryEntry> | undefined,
  inbound: InboundWire,
  effectiveAuthMode: OcxProviderConfig["authMode"] | undefined,
): string | undefined {
  if (declared === undefined || !MODEL_ADAPTER_OVERRIDE_ALLOWED.has(provider.adapter)) return undefined;
  if (typeof declared !== "string") {
    if (!declared.inbound.includes(inbound)) return undefined;
    const authMode = effectiveAuthMode ?? provider.authMode ?? entry?.authKind;
    if (declared.authModes && authMode && !declared.authModes.includes(authMode)) return undefined;
  }
  const wire = typeof declared === "string" ? declared : declared.wire;
  return MODEL_ADAPTER_OVERRIDE_ALLOWED.has(wire) ? wire : undefined;
}
