import { MemoryConfig } from '@mastra/core/memory';
import { DatasetType, MemoryConfigOptions } from './data/types';

// ============================================================================
// Run Variants - Define operational parameters
// ============================================================================

/**
 * A run variant defines operational parameters like concurrency and subset size.
 * These are separate from memory configs to allow mixing and matching.
 */
export interface RunVariant {
  /** Variant name */
  name: string;
  /** Description for help text */
  description: string;
  /** Dataset to use */
  dataset: DatasetType;
  /** Number of questions to process (undefined = all) */
  subset?: number;
  /** Number of questions per type for stratified sampling (overrides subset) */
  perTypeCount?: number;
  /** Comb sampling: number of questions to select per type */
  combSampleSize?: number;
  /** Comb sampling: stride between selected questions */
  combOffset?: number;
  /** Comb sampling: starting index (default 0) */
  combStartOffset?: number;
  /** Concurrency for prepare command */
  prepareConcurrency: number;
  /** Concurrency for bench command */
  benchConcurrency: number;
}

/**
 * All available run variants.
 */
export const RUN_VARIANTS: Record<string, RunVariant> = {
  quick: {
    name: 'quick',
    description: 'Quick test run with 10 questions',
    dataset: 'longmemeval_s',
    subset: 10,
    prepareConcurrency: 1,
    benchConcurrency: 5,
  },
  full: {
    name: 'full',
    description: 'Full benchmark run with all questions',
    dataset: 'longmemeval_s',
    subset: undefined,
    prepareConcurrency: 5,
    benchConcurrency: 10,
  },
  'full-fast': {
    name: 'full-fast',
    description: 'Full benchmark run with all questions',
    dataset: 'longmemeval_s',
    subset: undefined,
    prepareConcurrency: 10,
    benchConcurrency: 15,
  },
  'full-slow': {
    name: 'full',
    description: 'Full benchmark run with all questions but with low concurrency',
    dataset: 'longmemeval_s',
    subset: undefined,
    prepareConcurrency: 2,
    benchConcurrency: 4,
  },
  rip: {
    name: 'rip',
    description: 'Full benchmark run with all questions, high concurrency',
    dataset: 'longmemeval_s',
    subset: undefined,
    prepareConcurrency: 20,
    benchConcurrency: 20,
  },
  sample: {
    name: 'sample',
    description: 'Stratified sample: 10 questions per type (60 total)',
    dataset: 'longmemeval_s',
    perTypeCount: 10,
    prepareConcurrency: 20,
    benchConcurrency: 10,
  },
  'sample-comb': {
    name: 'sample-comb',
    description: 'Comb sample: 10 questions per type, spaced throughout (use --comb-offset, --start-offset)',
    dataset: 'longmemeval_s',
    combSampleSize: 10,
    combOffset: 10,
    combStartOffset: 0,
    prepareConcurrency: 2,
    benchConcurrency: 10,
  },
};

/**
 * Get a run variant by name.
 */
export function getRunVariant(name: string): RunVariant {
  const variant = RUN_VARIANTS[name];
  if (!variant) {
    throw new Error(`Unknown run variant: ${name}. Available: ${Object.keys(RUN_VARIANTS).join(', ')}`);
  }
  return variant;
}

/**
 * Get all available run variant names.
 */
export function getAvailableVariants(): string[] {
  return Object.keys(RUN_VARIANTS);
}

/**
 * Apply stratified sampling to a list of questions.
 * Sorts questions by ID (deterministic) and takes the first N of each type.
 */
export function applyStratifiedSampling<T extends { question_id: string; question_type: string }>(
  questions: T[],
  perTypeCount: number,
): T[] {
  // Sort by question_id for deterministic ordering
  const sorted = [...questions].sort((a, b) => a.question_id.localeCompare(b.question_id));

  // Group by question type
  const byType = new Map<string, T[]>();
  for (const q of sorted) {
    const existing = byType.get(q.question_type) || [];
    existing.push(q);
    byType.set(q.question_type, existing);
  }

  // Take first N of each type
  const result: T[] = [];
  for (const [type, typeQuestions] of byType) {
    const selected = typeQuestions.slice(0, perTypeCount);
    result.push(...selected);
    console.log(`  ${type}: ${selected.length}/${typeQuestions.length} questions`);
  }

  // Sort final result by question_id for consistent ordering
  return result.sort((a, b) => a.question_id.localeCompare(b.question_id));
}

/**
 * Apply comb sampling to a list of questions.
 * Selects questions at regular intervals (combOffset) starting from startOffset,
 * wrapping around to the beginning if needed.
 */
export function applyCombSampling<T extends { question_id: string; question_type: string }>(
  questions: T[],
  sampleSize: number,
  combOffset: number,
  startOffset: number = 0,
): T[] {
  // Sort by question_id for deterministic ordering
  const sorted = [...questions].sort((a, b) => a.question_id.localeCompare(b.question_id));

  // Group by question type
  const byType = new Map<string, T[]>();
  for (const q of sorted) {
    const existing = byType.get(q.question_type) || [];
    existing.push(q);
    byType.set(q.question_type, existing);
  }

  // Comb through each type
  const result: T[] = [];
  for (const [type, typeQuestions] of byType) {
    const total = typeQuestions.length;
    const selected: T[] = [];
    const selectedIndices: number[] = [];

    let currentIndex = startOffset % total;
    for (let i = 0; i < sampleSize && i < total; i++) {
      selected.push(typeQuestions[currentIndex]);
      selectedIndices.push(currentIndex);
      currentIndex = (currentIndex + combOffset) % total;
    }

    result.push(...selected);
    console.log(`  ${type}: ${selected.length}/${total} questions (indices: ${selectedIndices.join(', ')})`);
  }

  // Sort final result by question_id for consistent ordering
  return result.sort((a, b) => a.question_id.localeCompare(b.question_id));
}

// ============================================================================
// Memory Configuration Definitions
// ============================================================================

/**
 * Static definition of a memory configuration's properties.
 * All derived flags are computed once here, not scattered across prepare/run.
 */
export interface MemoryConfigDefinition {
  /** The config type identifier */
  type: string;

  /** Human-readable description of this config */
  description: string;

  /** Memory options passed to Mastra Memory */
  memoryOptions: MemoryConfig;

  // --- Derived flags ---

  /** Requires a real LLM model (not mock) */
  needsRealModel: boolean;

  /** Uses semantic recall for embeddings */
  usesSemanticRecall: boolean;

  /** Uses working memory */
  usesWorkingMemory: boolean;

  /** Uses tailored (per-question) templates */
  usesTailored: boolean;

  /** Uses observational memory */
  usesObservationalMemory: boolean;

  /** Uses shortcut OM (finalize at end) */
  usesShortcutOM: boolean;

  /** Uses Cerebras GLM model for OM */
  usesGlmModel: boolean;

  /** Model to use for OM Observer/Reflector (null = use default) */
  omModel: string | null;

  /** Max input tokens for finalize (null = no limit) */
  omMaxInputTokens: number | null;

  /** Requires sequential processing (no concurrency) */
  requiresSequential: boolean;

  /** Model to use for the main agent (defaults to openai/gpt-4o) */
  agentModel?: string;

  /** Model to use for the eval agent (defaults to openai/gpt-4o) */
  evalModel?: string;

  /** Base config to inherit prepared data from (for derived configs) */
  baseConfig?: string;

  /** If true, read directly from baseConfig's data at runtime (no copy/modification) */
  readOnlyConfig?: boolean;

  /** Enable the recall tool at runtime */
  recallToolEnabled?: boolean;

  /** Enable pattern recognition during observation */
  recognizePatterns?: boolean;

  /** Enable observation RAG filtering at runtime */
  usesObservationRag?: boolean;

  /** TopK for RAG retrieval (default: 50) */
  ragTopK?: number;

  /** Enable preference boost queries for RAG (default: false) */
  ragPreferenceBoost?: boolean;

  /** Max tokens per batch for Observer (default: 5000) */
  observerMaxTokensPerBatch?: number;

  /** Use legacy (Jan 7) Observer prompt for A/B testing (default: false) */
  observerUseLegacyPrompt?: boolean;

  /** Use condensed V3 Observer prompt for A/B testing (default: false) */
  observerUseCondensedPrompt?: boolean;
}

// --- Shared config values ---

const semanticRecall = {
  topK: 10,
  messageRange: 2,
  scope: 'resource',
} as const;

const lastMessages = 10;

// Cerebras GLM model config
export const CEREBRAS_GLM_MODEL = 'cerebras/zai-glm-4.6';
export const CEREBRAS_GLM_MAX_TOKENS = 200000;

// ============================================================================
// Config Aliases - Short names for memory configs
// ============================================================================

/**
 * Short aliases for memory config types.
 * Allows using 'om' instead of 'observational-memory', etc.
 */
export const CONFIG_ALIASES: Record<string, MemoryConfigType> = {
  // Short aliases
  semantic: 'semantic-recall',
  working: 'working-memory',
  'working-tailored': 'working-memory-tailored',
  combined: 'combined',
  'combined-tailored': 'combined-tailored',
  om: 'observational-memory',
  'om-shortcut': 'observational-memory-shortcut',
  'om-shortcut-glm': 'observational-memory-shortcut-glm',
  'om-patterns-observed': 'om-patterns-observed',
  'om-patterns-tool': 'om-patterns-tool',
  'om-glm': 'om-glm',
  'om-glm-patterns-observed': 'om-glm-patterns-observed',
  'om-glm-patterns-tool': 'om-glm-patterns-tool',
  'om-rag': 'om-rag',
  'om-glm-rag': 'om-glm-rag',
  'om-glm-rag-topk100': 'om-glm-rag-topk100',
  'om-glm-rag-prefboost': 'om-glm-rag-prefboost',
  'om-gemini-3-pro': 'om-gemini-3-pro',
  'om-gemini-3-flash': 'om-gemini-3-flash',
  'om-gpt5': 'om-gpt5',
  'om-gpt5-mini': 'om-gpt5-mini',
  // om2 variants
  om2: 'om2',
  'om2-gpt5': 'om2-gpt5',
  'om2-gpt5-mini': 'om2-gpt5-mini',
  'om2-glm': 'om2-glm',
  'om2-gemini-3-pro': 'om2-gemini-3-pro',
  'om2-gemini-3-flash': 'om2-gemini-3-flash',

  // Full names (for completeness)
  'semantic-recall': 'semantic-recall',
  'working-memory': 'working-memory',
  'working-memory-tailored': 'working-memory-tailored',
  'observational-memory': 'observational-memory',
  'om-batch-10k': 'om-batch-10k',
  'om-legacy-prompt': 'om-legacy-prompt',
  'om-legacy-prompt-gpt5-mini': 'om-legacy-prompt-gpt5-mini',
  'om-batch-10k-gpt5-mini': 'om-batch-10k-gpt5-mini',
  'om-batch-10k-sequential': 'om-batch-10k-sequential',
  'om-batch-10k-sequential-gpt5-mini': 'om-batch-10k-sequential-gpt5-mini',
  'om-condensed-prompt': 'om-condensed-prompt',
  'om-condensed-prompt-gpt5-mini': 'om-condensed-prompt-gpt5-mini',
  'observational-memory-shortcut': 'observational-memory-shortcut',
  'observational-memory-shortcut-glm': 'observational-memory-shortcut-glm',
};

/**
 * Resolve a config name (alias or full) to the canonical MemoryConfigType.
 */
export function resolveConfigAlias(nameOrAlias: string): MemoryConfigType {
  const resolved = CONFIG_ALIASES[nameOrAlias];
  if (!resolved) {
    throw new Error(`Unknown memory config: ${nameOrAlias}. Available: ${Object.keys(CONFIG_ALIASES).join(', ')}`);
  }
  return resolved;
}

/**
 * Get all available config aliases (short names only).
 */
export function getConfigAliases(): string[] {
  // Return all config keys from MEMORY_CONFIGS
  return Object.keys(MEMORY_CONFIGS);
}

// ============================================================================
// Config Definitions Map
// ============================================================================

const MEMORY_CONFIGS = {
  'semantic-recall': {
    type: 'semantic-recall',
    description: 'Vector similarity search over message history',
    memoryOptions: {
      lastMessages,
      semanticRecall,
      workingMemory: { enabled: false },
    },
    needsRealModel: false,
    usesSemanticRecall: true,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: false,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: false,
  },

  'working-memory': {
    type: 'working-memory',
    description: 'LLM-maintained working memory (markdown scratchpad)',
    memoryOptions: {
      lastMessages,
      semanticRecall: false,
      workingMemory: {
        enabled: true,
        scope: 'resource',
        version: 'vnext',
      },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: true,
    usesTailored: false,
    usesObservationalMemory: false,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
  },

  'working-memory-tailored': {
    type: 'working-memory-tailored',
    description: 'Working memory with per-question tailored templates',
    memoryOptions: {
      lastMessages,
      semanticRecall: false,
      workingMemory: {
        enabled: true,
        scope: 'resource',
        version: 'vnext',
      },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: true,
    usesTailored: true,
    usesObservationalMemory: false,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'gpt-4o',
  },

  combined: {
    type: 'combined',
    description: 'Semantic recall + working memory combined',
    memoryOptions: {
      lastMessages,
      semanticRecall,
      workingMemory: {
        enabled: true,
        scope: 'resource',
      },
    },
    needsRealModel: true,
    usesSemanticRecall: true,
    usesWorkingMemory: true,
    usesTailored: false,
    usesObservationalMemory: false,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
  },

  'combined-tailored': {
    type: 'combined-tailored',
    description: 'Semantic recall + working memory with tailored templates',
    memoryOptions: {
      lastMessages,
      semanticRecall,
      workingMemory: {
        enabled: true,
        scope: 'resource',
        version: 'vnext',
      },
    },
    needsRealModel: true,
    usesSemanticRecall: true,
    usesWorkingMemory: true,
    usesTailored: true,
    usesObservationalMemory: false,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
  },

  'observational-memory': {
    type: 'observational-memory',
    description: 'Observational Memory with GPT-4o (baseline OM config)',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
  },

  'om-batch-10k': {
    type: 'om-batch-10k',
    description: 'OM with 10k tokens per batch (vs default 5k) for comparison',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
    observerMaxTokensPerBatch: 10000,
  },

  'om-batch-10k-sequential': {
    type: 'om-batch-10k-sequential',
    description: 'OM with 10k tokens per batch processed SEQUENTIALLY (batches see previous batch observations)',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
    observerMaxTokensPerBatch: 10000,
  },

  // ============================================================================
  // Legacy Prompt Testing - A/B test to isolate prompt size impact
  // ============================================================================

  'om-legacy-prompt': {
    type: 'om-legacy-prompt',
    description: 'OM with Jan 7 legacy Observer prompt (smaller, ~574 lines vs ~873 lines)',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
    observerUseLegacyPrompt: true,
  },

  'om-legacy-prompt-gpt5-mini': {
    type: 'om-legacy-prompt-gpt5-mini',
    description: 'OM with legacy Observer prompt + GPT-5 Mini agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-5-mini',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om-legacy-prompt',
    readOnlyConfig: true,
  },

  'om-condensed-prompt': {
    type: 'om-condensed-prompt',
    description: 'OM with condensed V3 Observer prompt - principle-based, shorter',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
    observerUseCondensedPrompt: true,
  },

  'om-condensed-prompt-gpt5-mini': {
    type: 'om-condensed-prompt-gpt5-mini',
    description: 'OM with condensed V3 Observer prompt + GPT-5 Mini agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-5-mini',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om-condensed-prompt',
    readOnlyConfig: true,
  },

  'observational-memory-shortcut': {
    type: 'observational-memory-shortcut',
    description: 'OM shortcut mode - single finalize() pass at end',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: true,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'gpt-4o',
  },

  'observational-memory-shortcut-glm': {
    type: 'observational-memory-shortcut-glm',
    description: 'OM shortcut mode using Cerebras GLM for Observer/Reflector',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: true,
    usesGlmModel: true,
    omModel: CEREBRAS_GLM_MODEL,
    omMaxInputTokens: CEREBRAS_GLM_MAX_TOKENS,
    requiresSequential: true,
    agentModel: 'gpt-4o',
  },

  'om-patterns-observed': {
    type: 'om-patterns-observed',
    description: 'OM with pattern recognition during observation',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'observational-memory',
    recognizePatterns: true,
  },

  'om-patterns-tool': {
    type: 'om-patterns-tool',
    description: 'OM with recall tool for on-demand pattern recognition',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'observational-memory',
    readOnlyConfig: true, // Just enables recall tool, doesn't modify data
    recallToolEnabled: true,
  },

  // GLM-4.7 variants - use Cerebras GLM for the main agent
  'om-glm': {
    type: 'om-glm',
    description: 'OM with Cerebras GLM as main agent',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false, // This is for Observer/Reflector, not the main agent
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: CEREBRAS_GLM_MODEL, // Main agent uses GLM-4.7
    evalModel: 'openai/gpt-4o', // Eval stays on GPT-4o
    baseConfig: 'observational-memory',
    readOnlyConfig: true, // Uses same prepared data as observational-memory
  },

  'om-glm-patterns-observed': {
    type: 'om-glm-patterns-observed',
    description: 'OM + GLM agent + pattern recognition during observation',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: CEREBRAS_GLM_MODEL,
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om-patterns-observed', // Inherits from patterns-observed
    readOnlyConfig: true,
    recognizePatterns: true,
  },

  'om-glm-patterns-tool': {
    type: 'om-glm-patterns-tool',
    description: 'OM + GLM agent + recall tool for pattern recognition',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: CEREBRAS_GLM_MODEL,
    evalModel: 'openai/gpt-4o',
    baseConfig: 'observational-memory', // Uses base OM data
    readOnlyConfig: true,
    recallToolEnabled: true,
  },

  // RAG variants - use semantic filtering on observations
  'om-rag': {
    type: 'om-rag',
    description: 'OM with RAG filtering on observations at runtime',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'observational-memory',
    readOnlyConfig: true, // Uses same prepared data, just filters at runtime
    usesObservationRag: true, // Enable the ObservationSemanticFilter processor
  },

  'om-glm-rag': {
    type: 'om-glm-rag',
    description: 'OM + GLM agent + RAG filtering',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: CEREBRAS_GLM_MODEL,
    // evalModel: CEREBRAS_GLM_MODEL,
    baseConfig: 'observational-memory',
    readOnlyConfig: true,
    usesObservationRag: true,
  },

  'om-glm-rag-topk100': {
    type: 'om-glm-rag-topk100',
    description: 'OM + GLM + RAG with topK=100 (experimental)',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: CEREBRAS_GLM_MODEL,
    evalModel: CEREBRAS_GLM_MODEL,
    baseConfig: 'observational-memory',
    readOnlyConfig: true,
    usesObservationRag: true,
    ragTopK: 100, // Override default topK of 50
  },
  'om-glm-rag-prefboost': {
    type: 'om-glm-rag-prefboost',
    description: 'OM + GLM + RAG with preference boost queries (experimental)',
    memoryOptions: {
      lastMessages: 5,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: CEREBRAS_GLM_MODEL,
    evalModel: CEREBRAS_GLM_MODEL,
    baseConfig: 'observational-memory',
    readOnlyConfig: true,
    usesObservationRag: true,
    ragPreferenceBoost: true, // Enable preference boost queries
  },

  'om-gemini-3-pro': {
    type: 'om-gemini-3-pro',
    description: 'OM with Gemini 3 Pro as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'google/gemini-3-pro-preview',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'observational-memory',
    readOnlyConfig: true,
  },

  'om-gemini-3-flash': {
    type: 'om-gemini-3-flash',
    description: 'OM with Gemini 3 Flash as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'google/gemini-3-flash-preview',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'observational-memory',
    readOnlyConfig: true,
  },

  // ============================================================================
  // om2 - Fresh preparation with latest Observer/Reflector improvements
  // ============================================================================

  om2: {
    type: 'om2',
    description: 'OM v2 - fresh data with latest Observer/Reflector improvements',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-4o',
    evalModel: 'openai/gpt-4o',
  },

  'om2-gpt5': {
    type: 'om2-gpt5',
    description: 'OM v2 with GPT-5 as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-5',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om2',
    readOnlyConfig: true,
  },

  'om2-gpt5-mini': {
    type: 'om2-gpt5-mini',
    description: 'OM v2 with GPT-5 Mini as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-5-mini',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om2',
    readOnlyConfig: true,
  },

  'om2-glm': {
    type: 'om2-glm',
    description: 'OM v2 with Cerebras GLM as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: CEREBRAS_GLM_MODEL,
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om2',
    readOnlyConfig: true,
  },

  'om2-gemini-3-pro': {
    type: 'om2-gemini-3-pro',
    description: 'OM v2 with Gemini 3 Pro as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'google/gemini-3-pro-preview',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om2',
    readOnlyConfig: true,
  },

  'om2-gemini-3-flash': {
    type: 'om2-gemini-3-flash',
    description: 'OM v2 with Gemini 3 Flash as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'google/gemini-3-flash-preview',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om2',
    readOnlyConfig: true,
  },

  // GPT-5 variants
  'om-gpt5': {
    type: 'om-gpt5',
    description: 'OM with GPT-5 as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-5',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'observational-memory',
    readOnlyConfig: true,
  },

  'om-gpt5-mini': {
    type: 'om-gpt5-mini',
    description: 'OM with GPT-5 Mini as main agent',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-5-mini',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'observational-memory',
    readOnlyConfig: true,
  },

  // Batch size comparison variant
  'om-batch-10k-gpt5-mini': {
    type: 'om-batch-10k-gpt5-mini',
    description: 'OM with 10k tokens per batch, GPT-5 Mini agent (for batch size comparison)',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-5-mini',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om-batch-10k',
    readOnlyConfig: true,
  },

  // Sequential batch processing variants (batches see previous batch observations)
  'om-batch-10k-sequential-gpt5-mini': {
    type: 'om-batch-10k-sequential-gpt5-mini',
    description: 'OM with 10k sequential batches, GPT-5 Mini agent (batches see previous observations)',
    memoryOptions: {
      lastMessages: 0,
      semanticRecall: false,
      workingMemory: { enabled: false },
    },
    needsRealModel: true,
    usesSemanticRecall: false,
    usesWorkingMemory: false,
    usesTailored: false,
    usesObservationalMemory: true,
    usesShortcutOM: false,
    usesGlmModel: false,
    omModel: null,
    omMaxInputTokens: null,
    requiresSequential: true,
    agentModel: 'openai/gpt-5-mini',
    evalModel: 'openai/gpt-4o',
    baseConfig: 'om-batch-10k-sequential',
    readOnlyConfig: true,
  },
} satisfies Record<string, MemoryConfigDefinition>;

// Derive MemoryConfigType from the keys of MEMORY_CONFIGS
export type MemoryConfigType = keyof typeof MEMORY_CONFIGS;

// ============================================================================
// Public API
// ============================================================================

/**
 * Get the full config definition for a memory config type.
 */
export function getMemoryConfig(memoryConfig: MemoryConfigType): MemoryConfigDefinition {
  const config = MEMORY_CONFIGS[memoryConfig];
  if (!config) {
    throw new Error(`Unknown memory config: ${memoryConfig}`);
  }
  return config;
}

/**
 * Get memory options in the legacy format (for backwards compatibility).
 */
export function getMemoryOptions(memoryConfig: string): MemoryConfigOptions {
  const config = getMemoryConfig(memoryConfig as MemoryConfigType);
  return {
    type: config.type,
    options: config.memoryOptions,
  };
}

/**
 * Check if a string is a valid memory config type.
 */
export function isValidMemoryConfig(memoryConfig: string): memoryConfig is MemoryConfigType {
  return memoryConfig in MEMORY_CONFIGS;
}

/**
 * Get all available memory config types.
 */
export function getAvailableConfigs(): MemoryConfigType[] {
  return Object.keys(MEMORY_CONFIGS) as MemoryConfigType[];
}