/**
 * Agentic QE v3 - QE ReasoningBank
 * ADR-021: QE ReasoningBank for Pattern Learning
 *
 * QE-specific pattern learning system that extends the concept from
 * claude-flow's ReasoningBank with quality engineering domains.
 *
 * Features:
 * - 8 QE domains for pattern classification
 * - HNSW vector indexing (150x faster search)
 * - Pattern quality scoring with outcome tracking
 * - Short-term to long-term promotion (3+ successful uses)
 * - Domain-specific guidance generation
 * - Agent routing via pattern similarity
 */

import { v4 as uuidv4 } from 'uuid';
import type { MemoryBackend, EventBus } from '../kernel/interfaces.js';
import type { Result, DomainName } from '../shared/types/index.js';
import { ok, err } from '../shared/types/index.js';
import {
  QEPattern,
  QEPatternContext,
  QEPatternType,
  QEDomain,
  ProgrammingLanguage,
  TestFramework,
  CreateQEPatternOptions,
  detectQEDomain,
  detectQEDomains,
  mapQEDomainToAQE,
  applyPatternTemplate,
  QE_DOMAIN_LIST,
} from './qe-patterns.js';
import {
  QEGuidance,
  getGuidance,
  getCombinedGuidance,
  generateGuidanceContext,
  checkAntiPatterns,
} from './qe-guidance.js';
import {
  PatternStore,
  PatternSearchOptions,
  PatternSearchResult,
  createPatternStore,
} from './pattern-store.js';

// ============================================================================
// QEReasoningBank Configuration
// ============================================================================

/**
 * QEReasoningBank configuration
 */
export interface QEReasoningBankConfig {
  /** Enable pattern learning */
  enableLearning: boolean;

  /** Enable guidance generation */
  enableGuidance: boolean;

  /** Enable task routing */
  enableRouting: boolean;

  /** Embedding dimension (must match HNSW config) */
  embeddingDimension: number;

  /** Use ONNX embeddings (when available) */
  useONNXEmbeddings: boolean;

  /** Maximum patterns to consider for routing */
  maxRoutingCandidates: number;

  /** Weights for routing score calculation */
  routingWeights: {
    similarity: number;
    performance: number;
    capabilities: number;
  };

  /** Pattern store configuration */
  patternStore?: Partial<import('./pattern-store.js').PatternStoreConfig>;
}

/**
 * Default configuration
 */
export const DEFAULT_QE_REASONING_BANK_CONFIG: QEReasoningBankConfig = {
  enableLearning: true,
  enableGuidance: true,
  enableRouting: true,
  embeddingDimension: 128,
  useONNXEmbeddings: false,
  maxRoutingCandidates: 10,
  routingWeights: {
    similarity: 0.3,
    performance: 0.4,
    capabilities: 0.3,
  },
};

// ============================================================================
// Routing Types
// ============================================================================

/**
 * Task routing request
 */
export interface QERoutingRequest {
  /** Task description */
  task: string;

  /** Task type hint */
  taskType?: 'test-generation' | 'analysis' | 'debugging' | 'optimization';

  /** Target domain hint */
  domain?: QEDomain;

  /** Required capabilities */
  capabilities?: string[];

  /** Context for matching */
  context?: Partial<QEPatternContext>;
}

/**
 * Task routing result
 */
export interface QERoutingResult {
  /** Recommended agent type */
  recommendedAgent: string;

  /** Confidence in recommendation (0-1) */
  confidence: number;

  /** Alternative agent recommendations */
  alternatives: Array<{ agent: string; score: number }>;

  /** Detected QE domains */
  domains: QEDomain[];

  /** Relevant patterns found */
  patterns: QEPattern[];

  /** Generated guidance */
  guidance: string[];

  /** Reasoning for the recommendation */
  reasoning: string;
}

/**
 * Pattern learning outcome
 */
export interface LearningOutcome {
  /** Pattern ID that was used */
  patternId: string;

  /** Whether the application was successful */
  success: boolean;

  /** Quality metrics from the outcome */
  metrics?: {
    testsPassed?: number;
    testsFailed?: number;
    coverageImprovement?: number;
    executionTimeMs?: number;
  };

  /** Feedback from the agent or user */
  feedback?: string;
}

// ============================================================================
// QEReasoningBank Interface
// ============================================================================

/**
 * QEReasoningBank interface
 */
export interface IQEReasoningBank {
  /** Initialize the reasoning bank */
  initialize(): Promise<void>;

  /** Store a new pattern */
  storePattern(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;

  /** Search for patterns */
  searchPatterns(
    query: string | number[],
    options?: PatternSearchOptions
  ): Promise<Result<PatternSearchResult[]>>;

  /** Get pattern by ID */
  getPattern(id: string): Promise<QEPattern | null>;

  /** Record pattern usage outcome */
  recordOutcome(outcome: LearningOutcome): Promise<Result<void>>;

  /** Route a task to optimal agent */
  routeTask(request: QERoutingRequest): Promise<Result<QERoutingResult>>;

  /** Get guidance for a domain */
  getGuidance(domain: QEDomain, context?: Partial<QEPatternContext>): QEGuidance;

  /** Generate guidance context for Claude */
  generateContext(
    domain: QEDomain,
    context?: { framework?: TestFramework; language?: ProgrammingLanguage }
  ): string;

  /** Check for anti-patterns in content */
  checkAntiPatterns(domain: QEDomain, content: string): ReturnType<typeof checkAntiPatterns>;

  /** Get embedding for text */
  embed(text: string): Promise<number[]>;

  /** Get statistics */
  getStats(): Promise<QEReasoningBankStats>;

  /** Dispose the reasoning bank */
  dispose(): Promise<void>;
}

/**
 * QEReasoningBank statistics
 */
export interface QEReasoningBankStats {
  /** Total patterns */
  totalPatterns: number;

  /** Patterns by domain */
  byDomain: Record<QEDomain, number>;

  /** Routing requests served */
  routingRequests: number;

  /** Average routing confidence */
  avgRoutingConfidence: number;

  /** Learning outcomes recorded */
  learningOutcomes: number;

  /** Pattern success rate */
  patternSuccessRate: number;

  /** Pattern store stats */
  patternStoreStats: import('./pattern-store.js').PatternStoreStats;
}

// ============================================================================
// QEReasoningBank Implementation
// ============================================================================

/**
 * QE ReasoningBank - Pattern learning for quality engineering
 *
 * @example
 * ```typescript
 * const bank = new QEReasoningBank(memory);
 * await bank.initialize();
 *
 * // Store a pattern
 * await bank.storePattern({
 *   patternType: 'test-template',
 *   name: 'AAA Unit Test',
 *   description: 'Arrange-Act-Assert pattern for unit tests',
 *   template: { type: 'code', content: '...', variables: [] },
 * });
 *
 * // Route a task
 * const routing = await bank.routeTask({
 *   task: 'Generate unit tests for UserService',
 *   context: { language: 'typescript', framework: 'vitest' },
 * });
 * ```
 */
export class QEReasoningBank implements IQEReasoningBank {
  private readonly config: QEReasoningBankConfig;
  private patternStore: PatternStore;
  private initialized = false;

  // Statistics
  private stats = {
    routingRequests: 0,
    totalRoutingConfidence: 0,
    learningOutcomes: 0,
    successfulOutcomes: 0,
  };

  // Agent capability mapping (QE agents)
  private readonly agentCapabilities: Record<string, {
    domains: QEDomain[];
    capabilities: string[];
    performanceScore: number;
  }> = {
    'qe-test-generator': {
      domains: ['test-generation'],
      capabilities: ['test-generation', 'tdd', 'bdd', 'unit-test', 'integration-test'],
      performanceScore: 0.85,
    },
    'qe-coverage-analyzer': {
      domains: ['coverage-analysis'],
      capabilities: ['coverage-analysis', 'gap-detection', 'risk-scoring'],
      performanceScore: 0.92,
    },
    'qe-coverage-specialist': {
      domains: ['coverage-analysis'],
      capabilities: ['sublinear-analysis', 'branch-coverage', 'mutation-testing'],
      performanceScore: 0.88,
    },
    'qe-test-architect': {
      domains: ['test-generation', 'coverage-analysis'],
      capabilities: ['test-strategy', 'test-pyramid', 'architecture'],
      performanceScore: 0.9,
    },
    'qe-api-contract-validator': {
      domains: ['contract-testing'],
      capabilities: ['contract-testing', 'openapi', 'graphql', 'pact'],
      performanceScore: 0.87,
    },
    'qe-security-auditor': {
      domains: ['security-compliance'],
      capabilities: ['sast', 'dast', 'vulnerability', 'owasp'],
      performanceScore: 0.82,
    },
    'qe-visual-tester': {
      domains: ['visual-accessibility'],
      capabilities: ['screenshot', 'visual-regression', 'percy', 'chromatic'],
      performanceScore: 0.8,
    },
    'qe-a11y-ally': {
      domains: ['visual-accessibility'],
      capabilities: ['wcag', 'aria', 'screen-reader', 'contrast'],
      performanceScore: 0.85,
    },
    'qe-performance-tester': {
      domains: ['chaos-resilience'],
      capabilities: ['load-testing', 'stress-testing', 'k6', 'artillery'],
      performanceScore: 0.83,
    },
    'qe-flaky-investigator': {
      domains: ['test-execution'],
      capabilities: ['flaky-detection', 'test-stability', 'retry'],
      performanceScore: 0.78,
    },
    'qe-chaos-engineer': {
      domains: ['chaos-resilience'],
      capabilities: ['chaos-testing', 'resilience', 'fault-injection'],
      performanceScore: 0.75,
    },
  };

  constructor(
    private readonly memory: MemoryBackend,
    private readonly eventBus?: EventBus,
    config: Partial<QEReasoningBankConfig> = {}
  ) {
    this.config = { ...DEFAULT_QE_REASONING_BANK_CONFIG, ...config };
    this.patternStore = createPatternStore(memory, {
      embeddingDimension: this.config.embeddingDimension,
      ...config.patternStore,
    });
  }

  /**
   * Initialize the reasoning bank
   */
  async initialize(): Promise<void> {
    if (this.initialized) return;

    await this.patternStore.initialize();

    // Load any pre-trained patterns
    await this.loadPretrainedPatterns();

    this.initialized = true;
    console.log('[QEReasoningBank] Initialized');
  }

  /**
   * Load pre-trained patterns for common QE scenarios
   */
  private async loadPretrainedPatterns(): Promise<void> {
    // Check if we already have patterns
    const stats = await this.patternStore.getStats();
    if (stats.totalPatterns > 0) {
      console.log(`[QEReasoningBank] Found ${stats.totalPatterns} existing patterns`);
      return;
    }

    // Add foundational patterns
    const foundationalPatterns: CreateQEPatternOptions[] = [
      {
        patternType: 'test-template',
        name: 'AAA Unit Test',
        description: 'Arrange-Act-Assert pattern for clear, maintainable unit tests',
        template: {
          type: 'code',
          content: `describe('{{className}}', () => {
  describe('{{methodName}}', () => {
    it('should {{expectedBehavior}}', {{async}} () => {
      // Arrange
      {{arrangeCode}}

      // Act
      {{actCode}}

      // Assert
      {{assertCode}}
    });
  });
});`,
          variables: [
            { name: 'className', type: 'string', required: true, description: 'Class under test' },
            { name: 'methodName', type: 'string', required: true, description: 'Method under test' },
            { name: 'expectedBehavior', type: 'string', required: true, description: 'Expected behavior in plain English' },
            { name: 'async', type: 'string', required: false, defaultValue: '', description: 'async keyword if needed' },
            { name: 'arrangeCode', type: 'code', required: true, description: 'Setup code' },
            { name: 'actCode', type: 'code', required: true, description: 'Action code' },
            { name: 'assertCode', type: 'code', required: true, description: 'Assertion code' },
          ],
        },
        context: {
          testType: 'unit',
          tags: ['unit-test', 'aaa', 'arrange-act-assert', 'best-practice'],
        },
      },
      {
        patternType: 'mock-pattern',
        name: 'Dependency Mock',
        description: 'Pattern for mocking external dependencies in tests',
        template: {
          type: 'code',
          content: `const mock{{DependencyName}} = {
  {{mockMethods}}
};

vi.mock('{{modulePath}}', () => ({
  {{DependencyName}}: vi.fn(() => mock{{DependencyName}}),
}));`,
          variables: [
            { name: 'DependencyName', type: 'string', required: true, description: 'Name of dependency to mock' },
            { name: 'modulePath', type: 'string', required: true, description: 'Module path to mock' },
            { name: 'mockMethods', type: 'code', required: true, description: 'Mock method implementations' },
          ],
        },
        context: {
          framework: 'vitest',
          testType: 'unit',
          tags: ['mock', 'vitest', 'dependency-injection'],
        },
      },
      {
        patternType: 'coverage-strategy',
        name: 'Risk-Based Coverage',
        description: 'Prioritize coverage by code risk and complexity',
        template: {
          type: 'prompt',
          content: `Analyze coverage gaps for {{targetPath}} with focus on:
1. Critical business logic paths
2. Error handling branches
3. Edge cases and boundary conditions
4. High-complexity functions (cyclomatic complexity > 10)

Risk scoring:
- Critical: Business logic, auth, payments
- High: Data validation, external integrations
- Medium: Internal utilities, helpers
- Low: Config, constants`,
          variables: [
            { name: 'targetPath', type: 'string', required: true, description: 'Path to analyze' },
          ],
        },
        context: {
          tags: ['coverage', 'risk-based', 'prioritization'],
        },
      },
      {
        patternType: 'flaky-fix',
        name: 'Timing-Based Flakiness',
        description: 'Fix flaky tests caused by timing issues',
        template: {
          type: 'prompt',
          content: `The test {{testName}} is flaky due to timing issues.

Common fixes:
1. Replace setTimeout with explicit waits
2. Use waitFor or waitForCondition
3. Mock time-dependent functions
4. Increase timeouts for async operations
5. Add retry logic with exponential backoff

Check for:
- Race conditions in async code
- Missing await keywords
- Shared state between tests
- External service dependencies`,
          variables: [
            { name: 'testName', type: 'string', required: true, description: 'Name of flaky test' },
          ],
        },
        context: {
          tags: ['flaky', 'timing', 'async', 'stability'],
        },
      },
    ];

    for (const options of foundationalPatterns) {
      try {
        await this.patternStore.create(options);
      } catch (error) {
        console.warn(`[QEReasoningBank] Failed to load pattern ${options.name}:`, error);
      }
    }

    console.log(`[QEReasoningBank] Loaded ${foundationalPatterns.length} foundational patterns`);
  }

  /**
   * Store a new pattern
   */
  async storePattern(options: CreateQEPatternOptions): Promise<Result<QEPattern>> {
    if (!this.initialized) {
      await this.initialize();
    }

    if (!this.config.enableLearning) {
      return err(new Error('Pattern learning is disabled'));
    }

    // Generate embedding if not provided
    if (!options.embedding) {
      const embedding = await this.embed(
        `${options.name} ${options.description} ${options.context?.tags?.join(' ') || ''}`
      );
      options = { ...options, embedding };
    }

    return this.patternStore.create(options);
  }

  /**
   * Search for patterns
   */
  async searchPatterns(
    query: string | number[],
    options?: PatternSearchOptions
  ): Promise<Result<PatternSearchResult[]>> {
    if (!this.initialized) {
      await this.initialize();
    }

    // Generate embedding for text query
    let searchQuery = query;
    if (typeof query === 'string') {
      searchQuery = await this.embed(query);
    }

    return this.patternStore.search(searchQuery, {
      ...options,
      useVectorSearch: true,
    });
  }

  /**
   * Get pattern by ID
   */
  async getPattern(id: string): Promise<QEPattern | null> {
    if (!this.initialized) {
      await this.initialize();
    }

    return this.patternStore.get(id);
  }

  /**
   * Record pattern usage outcome
   */
  async recordOutcome(outcome: LearningOutcome): Promise<Result<void>> {
    if (!this.initialized) {
      await this.initialize();
    }

    if (!this.config.enableLearning) {
      return ok(undefined);
    }

    const result = await this.patternStore.recordUsage(
      outcome.patternId,
      outcome.success
    );

    if (result.success) {
      this.stats.learningOutcomes++;
      if (outcome.success) {
        this.stats.successfulOutcomes++;
      }
    }

    return result;
  }

  /**
   * Route a task to optimal agent
   */
  async routeTask(request: QERoutingRequest): Promise<Result<QERoutingResult>> {
    if (!this.initialized) {
      await this.initialize();
    }

    if (!this.config.enableRouting) {
      return err(new Error('Task routing is disabled'));
    }

    this.stats.routingRequests++;

    try {
      // 1. Detect domains from task description
      const detectedDomains = request.domain
        ? [request.domain]
        : detectQEDomains(request.task);

      if (detectedDomains.length === 0) {
        detectedDomains.push('test-generation'); // Default
      }

      // 2. Search for similar patterns
      const embedding = await this.embed(request.task);
      const patternResults = await this.patternStore.search(embedding, {
        limit: this.config.maxRoutingCandidates,
        domain: detectedDomains[0],
        useVectorSearch: true,
      });

      const patterns = patternResults.success
        ? patternResults.value.map((r) => r.pattern)
        : [];

      // 3. Calculate agent scores
      const agentScores: Array<{ agent: string; score: number; reasoning: string[] }> = [];

      for (const [agentType, profile] of Object.entries(this.agentCapabilities)) {
        let score = 0;
        const reasoning: string[] = [];

        // Domain match (0-0.4)
        const domainMatch = detectedDomains.filter((d) =>
          profile.domains.includes(d)
        ).length;
        const domainScore =
          domainMatch > 0 ? (domainMatch / detectedDomains.length) * 0.4 : 0;
        score += domainScore * this.config.routingWeights.similarity;
        if (domainScore > 0) {
          reasoning.push(`Domain match: ${(domainScore * 100).toFixed(0)}%`);
        }

        // Capability match (0-0.3)
        if (request.capabilities && request.capabilities.length > 0) {
          const capMatch = request.capabilities.filter((c) =>
            profile.capabilities.some(
              (pc) => pc.toLowerCase().includes(c.toLowerCase())
            )
          ).length;
          const capScore =
            capMatch > 0 ? (capMatch / request.capabilities.length) * 0.3 : 0;
          score += capScore * this.config.routingWeights.capabilities;
          if (capScore > 0) {
            reasoning.push(`Capability match: ${(capScore * 100).toFixed(0)}%`);
          }
        } else {
          score += 0.15 * this.config.routingWeights.capabilities;
        }

        // Historical performance (0-0.3)
        score += profile.performanceScore * 0.3 * this.config.routingWeights.performance;
        reasoning.push(`Performance score: ${(profile.performanceScore * 100).toFixed(0)}%`);

        // Pattern similarity boost
        const agentPatterns = patterns.filter((p) =>
          profile.domains.includes(p.qeDomain)
        );
        if (agentPatterns.length > 0) {
          const patternBoost = Math.min(0.1, agentPatterns.length * 0.02);
          score += patternBoost;
          reasoning.push(`Pattern matches: ${agentPatterns.length}`);
        }

        agentScores.push({ agent: agentType, score, reasoning });
      }

      // Sort by score
      agentScores.sort((a, b) => b.score - a.score);

      const recommended = agentScores[0];
      const alternatives = agentScores.slice(1, 4);

      // Generate guidance
      const guidance: string[] = [];
      if (this.config.enableGuidance && detectedDomains.length > 0) {
        const domainGuidance = getCombinedGuidance(detectedDomains[0], {
          framework: request.context?.framework,
          language: request.context?.language,
          includeAntiPatterns: true,
        });
        guidance.push(...domainGuidance.slice(0, 5));
      }

      // Update stats
      this.stats.totalRoutingConfidence += recommended.score;

      const result: QERoutingResult = {
        recommendedAgent: recommended.agent,
        confidence: recommended.score,
        alternatives: alternatives.map((a) => ({ agent: a.agent, score: a.score })),
        domains: detectedDomains,
        patterns,
        guidance,
        reasoning: recommended.reasoning.join('; '),
      };

      return ok(result);
    } catch (error) {
      return err(error instanceof Error ? error : new Error(String(error)));
    }
  }

  /**
   * Get guidance for a domain
   */
  getGuidance(domain: QEDomain, _context?: Partial<QEPatternContext>): QEGuidance {
    return getGuidance(domain);
  }

  /**
   * Generate guidance context for Claude
   */
  generateContext(
    domain: QEDomain,
    context?: { framework?: TestFramework; language?: ProgrammingLanguage }
  ): string {
    return generateGuidanceContext(domain, context || {});
  }

  /**
   * Check for anti-patterns
   */
  checkAntiPatterns(domain: QEDomain, content: string) {
    return checkAntiPatterns(domain, content);
  }

  /**
   * Generate embedding for text
   *
   * Uses ONNX transformer embeddings when available, with hash-based fallback
   * for ARM64 or when transformers module cannot be loaded.
   */
  async embed(text: string): Promise<number[]> {
    // Try ONNX embeddings if enabled
    if (this.config.useONNXEmbeddings) {
      try {
        const { computeRealEmbedding } = await import('./real-embeddings.js');
        const embedding = await computeRealEmbedding(text);
        // Resize to configured dimension if needed (384 -> 128)
        if (embedding.length !== this.config.embeddingDimension) {
          return this.resizeEmbedding(embedding, this.config.embeddingDimension);
        }
        return embedding;
      } catch (error) {
        // ARM64 ONNX compatibility issue or module not available
        // Fall through to hash-based embedding silently
        if (process.env.DEBUG) {
          console.warn(
            '[QEReasoningBank] ONNX embeddings unavailable, using hash fallback:',
            error instanceof Error ? error.message : String(error)
          );
        }
      }
    }

    // Hash-based fallback (always works, including ARM64)
    return this.hashEmbedding(text);
  }

  /**
   * Resize embedding to target dimension using averaging or truncation
   */
  private resizeEmbedding(embedding: number[], targetDim: number): number[] {
    if (embedding.length === targetDim) {
      return embedding;
    }

    if (embedding.length > targetDim) {
      // Average adjacent values to reduce dimension
      const ratio = embedding.length / targetDim;
      const result = new Array(targetDim).fill(0);
      for (let i = 0; i < targetDim; i++) {
        const start = Math.floor(i * ratio);
        const end = Math.floor((i + 1) * ratio);
        let sum = 0;
        for (let j = start; j < end; j++) {
          sum += embedding[j];
        }
        result[i] = sum / (end - start);
      }
      // Normalize
      const magnitude = Math.sqrt(result.reduce((sum, val) => sum + val * val, 0));
      if (magnitude > 0) {
        for (let i = 0; i < targetDim; i++) {
          result[i] /= magnitude;
        }
      }
      return result;
    } else {
      // Interpolate to increase dimension (less common)
      const result = new Array(targetDim).fill(0);
      const ratio = (embedding.length - 1) / (targetDim - 1);
      for (let i = 0; i < targetDim; i++) {
        const pos = i * ratio;
        const lower = Math.floor(pos);
        const upper = Math.min(lower + 1, embedding.length - 1);
        const weight = pos - lower;
        result[i] = embedding[lower] * (1 - weight) + embedding[upper] * weight;
      }
      // Normalize
      const magnitude = Math.sqrt(result.reduce((sum, val) => sum + val * val, 0));
      if (magnitude > 0) {
        for (let i = 0; i < targetDim; i++) {
          result[i] /= magnitude;
        }
      }
      return result;
    }
  }

  /**
   * Simple hash-based embedding fallback
   */
  private hashEmbedding(text: string): number[] {
    const dimension = this.config.embeddingDimension;
    const embedding = new Array(dimension).fill(0);
    const normalized = text.toLowerCase().trim();

    // Use multiple hash passes for better distribution
    for (let pass = 0; pass < 3; pass++) {
      for (let i = 0; i < normalized.length; i++) {
        const charCode = normalized.charCodeAt(i);
        const idx = (charCode * (i + 1) * (pass + 1)) % dimension;
        embedding[idx] += Math.sin(charCode * (pass + 1)) / (i + 1);
      }
    }

    // Normalize to unit vector
    const magnitude = Math.sqrt(
      embedding.reduce((sum, val) => sum + val * val, 0)
    );

    if (magnitude > 0) {
      for (let i = 0; i < dimension; i++) {
        embedding[i] /= magnitude;
      }
    }

    return embedding;
  }

  /**
   * Get statistics
   */
  async getStats(): Promise<QEReasoningBankStats> {
    if (!this.initialized) {
      await this.initialize();
    }

    const patternStoreStats = await this.patternStore.getStats();

    const byDomain: Record<QEDomain, number> = {} as Record<QEDomain, number>;
    for (const domain of QE_DOMAIN_LIST) {
      byDomain[domain] = patternStoreStats.byDomain[domain] || 0;
    }

    return {
      totalPatterns: patternStoreStats.totalPatterns,
      byDomain,
      routingRequests: this.stats.routingRequests,
      avgRoutingConfidence:
        this.stats.routingRequests > 0
          ? this.stats.totalRoutingConfidence / this.stats.routingRequests
          : 0,
      learningOutcomes: this.stats.learningOutcomes,
      patternSuccessRate:
        this.stats.learningOutcomes > 0
          ? this.stats.successfulOutcomes / this.stats.learningOutcomes
          : 0,
      patternStoreStats,
    };
  }

  /**
   * Dispose the reasoning bank
   */
  async dispose(): Promise<void> {
    await this.patternStore.dispose();
    this.initialized = false;
  }
}

// ============================================================================
// Factory Functions
// ============================================================================

/**
 * Create a new QEReasoningBank instance
 */
export function createQEReasoningBank(
  memory: MemoryBackend,
  eventBus?: EventBus,
  config?: Partial<QEReasoningBankConfig>
): QEReasoningBank {
  return new QEReasoningBank(memory, eventBus, config);
}

// ============================================================================
// Convenience Exports
// ============================================================================

export {
  detectQEDomain,
  detectQEDomains,
  mapQEDomainToAQE,
  applyPatternTemplate,
} from './qe-patterns.js';

export type {
  QEPattern,
  QEPatternType,
  QEDomain,
  QEPatternContext,
  ProgrammingLanguage,
  TestFramework,
  CreateQEPatternOptions,
} from './qe-patterns.js';

export {
  getGuidance,
  getCombinedGuidance,
  generateGuidanceContext,
} from './qe-guidance.js';

export type { QEGuidance } from './qe-guidance.js';