// Exact system-owned default materializations. These are resolved through
// shipped call-site defaults rather than persisted as user overrides.
const SEEDED_CALL_SITES: Record<string, Record<string, unknown>> = {
  guardianQuestionCopy: latencySeed(),
  interactionClassifier: latencySeed(),
  skillCategoryInference: latencySeed(),
  inviteInstructionGenerator: latencySeed(),
  notificationDecision: latencySeed(),
  preferenceExtraction: latencySeed(),
  commitMessage: {
    model: "claude-haiku-4-5-20251001",
    maxTokens: 120,
    temperature: 0.2,
    effort: "low",
    thinking: { enabled: false },
  },
  conversationStarters: latencySeed(),
  conversationSummarization: {
    model: "claude-opus-4-7",
    effort: "low",
    thinking: { enabled: false },
  },
  recall: {
    profile: "cost-optimized",
    maxTokens: 4096,
    effort: "low",
    thinking: { enabled: false, streamThinking: false },
    temperature: 0,
    disableCache: true,
  },
  heartbeatAgent: {
    profile: "cost-optimized",
    maxTokens: 2048,
    effort: "low",
    temperature: 0,
    thinking: { enabled: false, streamThinking: false },
    contextWindow: { maxInputTokens: 16000 },
  },
  replySuggestion: {
    model: "claude-haiku-4-5-20251001",
    effort: "low",
    thinking: { enabled: false },
    disableCache: true,
  },
  memoryRouter: {
    profile: "cost-optimized",
    contextWindow: { maxInputTokens: 1_000_000 },
  },
};

export function pruneSeededCallsiteDefaultsFromConfig(
  config: Record<string, unknown>,
): boolean {
  const llm = readObject(config.llm);
  if (llm === null) {
    return false;
  }

  const callSites = readObject(llm.callSites);
  if (callSites === null) {
    return false;
  }

  let changed = false;
  for (const [callSite, seed] of Object.entries(SEEDED_CALL_SITES)) {
    if (deepEqual(callSites[callSite], seed)) {
      delete callSites[callSite];
      changed = true;
    }
  }
  if (!changed) {
    return false;
  }

  if (Object.keys(callSites).length === 0) {
    delete llm.callSites;
  } else {
    llm.callSites = callSites;
  }
  config.llm = llm;
  return true;
}

function latencySeed(): Record<string, unknown> {
  return {
    model: "claude-haiku-4-5-20251001",
    effort: "low",
    thinking: { enabled: false },
  };
}

function readObject(value: unknown): Record<string, unknown> | null {
  if (value === null || typeof value !== "object" || Array.isArray(value)) {
    return null;
  }
  return value as Record<string, unknown>;
}

function deepEqual(a: unknown, b: unknown): boolean {
  if (a === b) {
    return true;
  }
  if (a === null || b === null) {
    return false;
  }
  if (typeof a !== "object" || typeof b !== "object") {
    return false;
  }
  if (Array.isArray(a) || Array.isArray(b)) {
    return false;
  }

  const aRecord = a as Record<string, unknown>;
  const bRecord = b as Record<string, unknown>;
  const aKeys = Object.keys(aRecord);
  const bKeys = Object.keys(bRecord);
  if (aKeys.length !== bKeys.length) {
    return false;
  }

  for (const key of aKeys) {
    if (!Object.prototype.hasOwnProperty.call(bRecord, key)) {
      return false;
    }
    if (!deepEqual(aRecord[key], bRecord[key])) {
      return false;
    }
  }
  return true;
}