/**
 * Agentic QE v3 - Pattern Store with HNSW Indexing
 * ADR-021: QE ReasoningBank for Pattern Learning
 *
 * Provides persistent pattern storage with HNSW vector indexing for
 * O(log n) approximate nearest neighbor search.
 */

import { v4 as uuidv4 } from 'uuid';
import type { MemoryBackend } from '../kernel/interfaces.js';
import type { Result } from '../shared/types/index.js';
import { ok, err } from '../shared/types/index.js';
import {
  QEPattern,
  QEPatternContext,
  QEPatternTemplate,
  QEPatternType,
  QEDomain,
  CreateQEPatternOptions,
  calculateQualityScore,
  shouldPromotePattern,
  validateQEPattern,
  mapQEDomainToAQE,
} from './qe-patterns.js';

// ============================================================================
// Pattern Store Configuration
// ============================================================================

/**
 * Pattern store configuration
 */
export interface PatternStoreConfig {
  /** Namespace for pattern storage keys */
  namespace: string;

  /** Dimension of embedding vectors */
  embeddingDimension: number;

  /** HNSW configuration */
  hnsw: {
    M: number;
    efConstruction: number;
    efSearch: number;
    maxElements: number;
  };

  /** Promotion threshold (successful uses required) */
  promotionThreshold: number;

  /** Minimum confidence for storage */
  minConfidence: number;

  /** Maximum patterns per domain */
  maxPatternsPerDomain: number;

  /** Enable automatic cleanup of low-quality patterns */
  autoCleanup: boolean;

  /** Cleanup interval in milliseconds */
  cleanupIntervalMs: number;
}

/**
 * Default pattern store configuration
 */
export const DEFAULT_PATTERN_STORE_CONFIG: PatternStoreConfig = {
  namespace: 'qe-patterns',
  embeddingDimension: 128,
  hnsw: {
    M: 16,
    efConstruction: 200,
    efSearch: 100,
    maxElements: 50000,
  },
  promotionThreshold: 3,
  minConfidence: 0.3,
  maxPatternsPerDomain: 5000,
  autoCleanup: true,
  cleanupIntervalMs: 3600000, // 1 hour
};

// ============================================================================
// Pattern Store Statistics
// ============================================================================

/**
 * Pattern store statistics
 */
export interface PatternStoreStats {
  /** Total patterns stored */
  totalPatterns: number;

  /** Patterns by tier */
  byTier: {
    shortTerm: number;
    longTerm: number;
  };

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

  /** Patterns by type */
  byType: Record<QEPatternType, number>;

  /** Average confidence score */
  avgConfidence: number;

  /** Average quality score */
  avgQualityScore: number;

  /** Average success rate */
  avgSuccessRate: number;

  /** Search operations count */
  searchOperations: number;

  /** Average search latency (ms) */
  avgSearchLatencyMs: number;

  /** HNSW index stats */
  hnswStats: {
    nativeAvailable: boolean;
    vectorCount: number;
    indexSizeBytes: number;
  };
}

// ============================================================================
// Pattern Search Options
// ============================================================================

/**
 * Options for pattern search
 */
export interface PatternSearchOptions {
  /** Maximum number of results */
  limit?: number;

  /** Filter by pattern type */
  patternType?: QEPatternType;

  /** Filter by QE domain */
  domain?: QEDomain;

  /** Filter by tier */
  tier?: 'short-term' | 'long-term';

  /** Minimum confidence threshold */
  minConfidence?: number;

  /** Minimum quality score */
  minQualityScore?: number;

  /** Context to match against */
  context?: Partial<QEPatternContext>;

  /** Include vector similarity search */
  useVectorSearch?: boolean;
}

/**
 * Pattern search result
 */
export interface PatternSearchResult {
  pattern: QEPattern;
  score: number;
  matchType: 'vector' | 'exact' | 'context';
}

// ============================================================================
// Pattern Store Interface
// ============================================================================

/**
 * Interface for pattern store operations
 */
export interface IPatternStore {
  /** Initialize the store */
  initialize(): Promise<void>;

  /** Store a new pattern */
  store(pattern: QEPattern): Promise<Result<string>>;

  /** Create and store a pattern from options */
  create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;

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

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

  /** Update pattern after use */
  recordUsage(
    id: string,
    success: boolean
  ): Promise<Result<void>>;

  /** Promote pattern from short-term to long-term */
  promote(id: string): Promise<Result<void>>;

  /** Delete a pattern */
  delete(id: string): Promise<Result<void>>;

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

  /** Run cleanup to remove low-quality patterns */
  cleanup(): Promise<{ removed: number; promoted: number }>;

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

// ============================================================================
// Pattern Store Implementation
// ============================================================================

/**
 * Pattern Store with HNSW indexing
 *
 * Provides O(log n) pattern search using HNSW approximate nearest neighbor.
 */
export class PatternStore implements IPatternStore {
  private readonly config: PatternStoreConfig;
  private initialized = false;
  private cleanupTimer?: NodeJS.Timeout;

  // In-memory caches for fast access
  private patternCache: Map<string, QEPattern> = new Map();
  private domainIndex: Map<QEDomain, Set<string>> = new Map();
  private typeIndex: Map<QEPatternType, Set<string>> = new Map();
  private tierIndex: Map<'short-term' | 'long-term', Set<string>> = new Map();

  // HNSW index for vector search (lazy loaded)
  private hnswIndex: any = null;
  private hnswAvailable = false;

  // Statistics
  private stats = {
    searchOperations: 0,
    searchLatencies: [] as number[],
  };

  constructor(
    private readonly memory: MemoryBackend,
    config: Partial<PatternStoreConfig> = {}
  ) {
    this.config = { ...DEFAULT_PATTERN_STORE_CONFIG, ...config };
  }

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

    // Initialize indices
    this.tierIndex.set('short-term', new Set());
    this.tierIndex.set('long-term', new Set());

    // Initialize HNSW if available
    await this.initializeHNSW();

    // Load existing patterns from memory
    await this.loadPatterns();

    // Start cleanup timer if enabled
    if (this.config.autoCleanup) {
      this.cleanupTimer = setInterval(
        () => this.cleanup(),
        this.config.cleanupIntervalMs
      );
    }

    this.initialized = true;
  }

  /**
   * Initialize HNSW index
   */
  private async initializeHNSW(): Promise<void> {
    try {
      // Try to import and use the existing HNSWIndex
      const { HNSWIndex } = await import(
        '../domains/coverage-analysis/services/hnsw-index.js'
      );

      this.hnswIndex = new HNSWIndex(this.memory, {
        dimensions: this.config.embeddingDimension,
        M: this.config.hnsw.M,
        efConstruction: this.config.hnsw.efConstruction,
        efSearch: this.config.hnsw.efSearch,
        maxElements: this.config.hnsw.maxElements,
        namespace: `${this.config.namespace}:hnsw`,
        metric: 'cosine',
      });

      await this.hnswIndex.initialize();
      this.hnswAvailable = this.hnswIndex.isNativeAvailable();

      console.log(
        `[PatternStore] HNSW initialized (native: ${this.hnswAvailable})`
      );
    } catch (error) {
      console.warn(
        '[PatternStore] HNSW not available, using memory backend search:',
        error
      );
      this.hnswAvailable = false;
    }
  }

  /**
   * Load existing patterns from memory
   */
  private async loadPatterns(): Promise<void> {
    const keys = await this.memory.search(`${this.config.namespace}:pattern:*`, 10000);

    for (const key of keys) {
      const pattern = await this.memory.get<QEPattern>(key);
      if (pattern) {
        this.indexPattern(pattern);
      }
    }

    console.log(`[PatternStore] Loaded ${this.patternCache.size} patterns`);
  }

  /**
   * Index a pattern in local caches
   */
  private indexPattern(pattern: QEPattern): void {
    this.patternCache.set(pattern.id, pattern);

    // Domain index
    if (!this.domainIndex.has(pattern.qeDomain)) {
      this.domainIndex.set(pattern.qeDomain, new Set());
    }
    this.domainIndex.get(pattern.qeDomain)!.add(pattern.id);

    // Type index
    if (!this.typeIndex.has(pattern.patternType)) {
      this.typeIndex.set(pattern.patternType, new Set());
    }
    this.typeIndex.get(pattern.patternType)!.add(pattern.id);

    // Tier index
    this.tierIndex.get(pattern.tier)!.add(pattern.id);
  }

  /**
   * Remove pattern from local indices
   */
  private unindexPattern(pattern: QEPattern): void {
    this.patternCache.delete(pattern.id);
    this.domainIndex.get(pattern.qeDomain)?.delete(pattern.id);
    this.typeIndex.get(pattern.patternType)?.delete(pattern.id);
    this.tierIndex.get(pattern.tier)?.delete(pattern.id);
  }

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

    // Validate pattern
    const validation = validateQEPattern(pattern);
    if (!validation.valid) {
      return err(new Error(`Invalid pattern: ${validation.errors.join(', ')}`));
    }

    // Check confidence threshold
    if (pattern.confidence < this.config.minConfidence) {
      return err(
        new Error(
          `Pattern confidence ${pattern.confidence} below threshold ${this.config.minConfidence}`
        )
      );
    }

    // Check domain limit
    const domainCount = this.domainIndex.get(pattern.qeDomain)?.size || 0;
    if (domainCount >= this.config.maxPatternsPerDomain) {
      // Run cleanup for this domain
      await this.cleanupDomain(pattern.qeDomain);
    }

    // Store in memory backend
    const key = `${this.config.namespace}:pattern:${pattern.id}`;
    await this.memory.set(key, pattern, {
      namespace: this.config.namespace,
      persist: true,
    });

    // Index locally
    this.indexPattern(pattern);

    // Add to HNSW if embedding is available
    if (this.hnswIndex && pattern.embedding) {
      try {
        await this.hnswIndex.insert(pattern.id, pattern.embedding, {
          patternType: pattern.patternType,
          qeDomain: pattern.qeDomain,
          confidence: pattern.confidence,
          qualityScore: pattern.qualityScore,
        });
      } catch (error) {
        console.warn(`[PatternStore] Failed to index embedding for ${pattern.id}:`, error);
      }
    }

    return ok(pattern.id);
  }

  /**
   * Create and store a pattern from options
   */
  async create(options: CreateQEPatternOptions): Promise<Result<QEPattern>> {
    const now = new Date();

    const pattern: QEPattern = {
      id: uuidv4(),
      patternType: options.patternType,
      qeDomain: this.detectDomainFromType(options.patternType),
      domain: mapQEDomainToAQE(this.detectDomainFromType(options.patternType)),
      name: options.name,
      description: options.description,
      confidence: 0.5, // Initial confidence
      usageCount: 0,
      successRate: 0,
      qualityScore: 0.25, // Initial quality
      context: {
        ...options.context,
        tags: options.context?.tags || [],
      },
      template: {
        ...options.template,
        example: undefined,
      },
      embedding: options.embedding,
      tier: 'short-term',
      createdAt: now,
      lastUsedAt: now,
      successfulUses: 0,
    };

    const storeResult = await this.store(pattern);
    if (!storeResult.success) {
      return err(storeResult.error);
    }

    return ok(pattern);
  }

  /**
   * Detect QE domain from pattern type
   */
  private detectDomainFromType(patternType: QEPatternType): QEDomain {
    const typeToDomain: Record<QEPatternType, QEDomain> = {
      'test-template': 'test-generation',
      'assertion-pattern': 'test-generation',
      'mock-pattern': 'test-generation',
      'coverage-strategy': 'coverage-analysis',
      'mutation-strategy': 'test-generation', // Mutation is part of test generation
      'api-contract': 'contract-testing',
      'visual-baseline': 'visual-accessibility',
      'a11y-check': 'visual-accessibility',
      'perf-benchmark': 'chaos-resilience',
      'flaky-fix': 'test-execution',
      'refactor-safe': 'code-intelligence',
      'error-handling': 'test-generation',
    };
    return typeToDomain[patternType] || 'test-generation';
  }

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

    // Check cache first
    const cached = this.patternCache.get(id);
    if (cached) return cached;

    // Fallback to memory backend
    const key = `${this.config.namespace}:pattern:${id}`;
    const pattern = await this.memory.get<QEPattern>(key);

    if (pattern) {
      this.indexPattern(pattern);
      return pattern;
    }

    return null;
  }

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

    const startTime = performance.now();
    const limit = options.limit || 10;
    const results: PatternSearchResult[] = [];

    try {
      // Vector search if query is embedding and HNSW available
      if (
        Array.isArray(query) &&
        this.hnswIndex &&
        options.useVectorSearch !== false
      ) {
        const hnswResults = await this.hnswIndex.search(query, limit * 2);

        for (const result of hnswResults) {
          const pattern = await this.get(result.key);
          if (pattern && this.matchesFilters(pattern, options)) {
            results.push({
              pattern,
              score: result.score,
              matchType: 'vector',
            });
          }
        }
      }

      // Text search fallback or additional
      if (typeof query === 'string' || results.length < limit) {
        const textResults = await this.searchByText(
          typeof query === 'string' ? query : '',
          options,
          limit - results.length
        );
        results.push(...textResults);
      }

      // Sort by score and limit
      results.sort((a, b) => b.score - a.score);
      const finalResults = results.slice(0, limit);

      // Record stats
      const latency = performance.now() - startTime;
      this.recordSearchLatency(latency);

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

  /**
   * Search patterns by text query
   */
  private async searchByText(
    query: string,
    options: PatternSearchOptions,
    limit: number
  ): Promise<PatternSearchResult[]> {
    const results: PatternSearchResult[] = [];
    const queryLower = query.toLowerCase();

    // Get candidate patterns from indices
    let candidates: Set<string>;

    if (options.domain) {
      candidates = this.domainIndex.get(options.domain) || new Set();
    } else if (options.patternType) {
      candidates = this.typeIndex.get(options.patternType) || new Set();
    } else if (options.tier) {
      candidates = this.tierIndex.get(options.tier) || new Set();
    } else {
      candidates = new Set(this.patternCache.keys());
    }

    for (const id of candidates) {
      if (results.length >= limit) break;

      const pattern = this.patternCache.get(id);
      if (!pattern) continue;

      if (!this.matchesFilters(pattern, options)) continue;

      // Calculate text match score
      let score = 0;

      if (queryLower) {
        const nameLower = pattern.name.toLowerCase();
        const descLower = pattern.description.toLowerCase();

        if (nameLower.includes(queryLower)) score += 0.5;
        if (descLower.includes(queryLower)) score += 0.3;

        for (const tag of pattern.context.tags) {
          if (tag.toLowerCase().includes(queryLower)) {
            score += 0.2;
            break;
          }
        }
      } else {
        // No query - use quality score
        score = pattern.qualityScore;
      }

      if (score > 0 || !queryLower) {
        results.push({
          pattern,
          score: score || pattern.qualityScore,
          matchType: queryLower ? 'exact' : 'context',
        });
      }
    }

    return results;
  }

  /**
   * Check if pattern matches search filters
   */
  private matchesFilters(
    pattern: QEPattern,
    options: PatternSearchOptions
  ): boolean {
    if (options.patternType && pattern.patternType !== options.patternType) {
      return false;
    }

    if (options.domain && pattern.qeDomain !== options.domain) {
      return false;
    }

    if (options.tier && pattern.tier !== options.tier) {
      return false;
    }

    if (
      options.minConfidence !== undefined &&
      pattern.confidence < options.minConfidence
    ) {
      return false;
    }

    if (
      options.minQualityScore !== undefined &&
      pattern.qualityScore < options.minQualityScore
    ) {
      return false;
    }

    if (options.context) {
      const ctx = options.context;

      if (ctx.language && pattern.context.language !== ctx.language) {
        return false;
      }

      if (ctx.framework && pattern.context.framework !== ctx.framework) {
        return false;
      }

      if (ctx.testType && pattern.context.testType !== ctx.testType) {
        return false;
      }
    }

    return true;
  }

  /**
   * Record pattern usage and update stats
   */
  async recordUsage(id: string, success: boolean): Promise<Result<void>> {
    const pattern = await this.get(id);
    if (!pattern) {
      return err(new Error(`Pattern not found: ${id}`));
    }

    const now = new Date();
    const usageCount = pattern.usageCount + 1;
    const successfulUses = pattern.successfulUses + (success ? 1 : 0);
    const successRate = successfulUses / usageCount;

    // Update confidence based on outcomes
    const confidenceDelta = success ? 0.02 : -0.01;
    const confidence = Math.max(
      0.1,
      Math.min(1, pattern.confidence + confidenceDelta)
    );

    const qualityScore = calculateQualityScore({
      confidence,
      usageCount,
      successRate,
    });

    const updated: QEPattern = {
      ...pattern,
      usageCount,
      successfulUses,
      successRate,
      confidence,
      qualityScore,
      lastUsedAt: now,
    };

    // Check for promotion
    if (shouldPromotePattern(updated) && updated.tier === 'short-term') {
      await this.promote(id);
    } else {
      // Update in store
      const key = `${this.config.namespace}:pattern:${id}`;
      await this.memory.set(key, updated, {
        namespace: this.config.namespace,
        persist: true,
      });

      // Update cache
      this.patternCache.set(id, updated);
    }

    return ok(undefined);
  }

  /**
   * Promote pattern from short-term to long-term storage
   */
  async promote(id: string): Promise<Result<void>> {
    const pattern = await this.get(id);
    if (!pattern) {
      return err(new Error(`Pattern not found: ${id}`));
    }

    if (pattern.tier === 'long-term') {
      return ok(undefined); // Already promoted
    }

    const promoted: QEPattern = {
      ...pattern,
      tier: 'long-term',
      confidence: Math.min(1, pattern.confidence + 0.1), // Boost confidence
    };

    // Update tier index
    this.tierIndex.get('short-term')?.delete(id);
    this.tierIndex.get('long-term')?.add(id);

    // Update in store
    const key = `${this.config.namespace}:pattern:${id}`;
    await this.memory.set(key, promoted, {
      namespace: this.config.namespace,
      persist: true,
    });

    this.patternCache.set(id, promoted);

    console.log(
      `[PatternStore] Promoted pattern ${id} (${pattern.name}) to long-term storage`
    );

    return ok(undefined);
  }

  /**
   * Delete a pattern
   */
  async delete(id: string): Promise<Result<void>> {
    const pattern = this.patternCache.get(id);
    if (!pattern) {
      return err(new Error(`Pattern not found: ${id}`));
    }

    // Remove from indices
    this.unindexPattern(pattern);

    // Remove from memory backend
    const key = `${this.config.namespace}:pattern:${id}`;
    await this.memory.delete(key);

    // Remove from HNSW if available
    if (this.hnswIndex) {
      try {
        await this.hnswIndex.delete(id);
      } catch {
        // Ignore HNSW deletion errors
      }
    }

    return ok(undefined);
  }

  /**
   * Get store statistics
   */
  async getStats(): Promise<PatternStoreStats> {
    const byDomain = {} as Record<QEDomain, number>;
    const byType = {} as Record<QEPatternType, number>;

    for (const [domain, ids] of this.domainIndex) {
      byDomain[domain] = ids.size;
    }

    for (const [type, ids] of this.typeIndex) {
      byType[type] = ids.size;
    }

    let totalConfidence = 0;
    let totalQuality = 0;
    let totalSuccess = 0;
    let count = 0;

    for (const pattern of this.patternCache.values()) {
      totalConfidence += pattern.confidence;
      totalQuality += pattern.qualityScore;
      totalSuccess += pattern.successRate;
      count++;
    }

    const hnswStats = this.hnswIndex
      ? await this.hnswIndex.getStats()
      : { nativeHNSW: false, vectorCount: 0, indexSizeBytes: 0 };

    return {
      totalPatterns: this.patternCache.size,
      byTier: {
        shortTerm: this.tierIndex.get('short-term')?.size || 0,
        longTerm: this.tierIndex.get('long-term')?.size || 0,
      },
      byDomain,
      byType,
      avgConfidence: count > 0 ? totalConfidence / count : 0,
      avgQualityScore: count > 0 ? totalQuality / count : 0,
      avgSuccessRate: count > 0 ? totalSuccess / count : 0,
      searchOperations: this.stats.searchOperations,
      avgSearchLatencyMs: this.calculateAvgLatency(),
      hnswStats: {
        nativeAvailable: hnswStats.nativeHNSW,
        vectorCount: hnswStats.vectorCount,
        indexSizeBytes: hnswStats.indexSizeBytes,
      },
    };
  }

  /**
   * Cleanup low-quality patterns
   */
  async cleanup(): Promise<{ removed: number; promoted: number }> {
    let removed = 0;
    let promoted = 0;

    const toRemove: string[] = [];
    const toPromote: string[] = [];

    for (const pattern of this.patternCache.values()) {
      // Check for promotion
      if (shouldPromotePattern(pattern)) {
        toPromote.push(pattern.id);
        continue;
      }

      // Check for removal (short-term, old, low quality)
      if (pattern.tier === 'short-term') {
        const ageMs = Date.now() - pattern.createdAt.getTime();
        const isOld = ageMs > 7 * 24 * 60 * 60 * 1000; // 7 days
        const isLowQuality = pattern.qualityScore < 0.2;
        const isUnused = pattern.usageCount === 0 && ageMs > 24 * 60 * 60 * 1000; // 1 day

        if ((isOld && isLowQuality) || isUnused) {
          toRemove.push(pattern.id);
        }
      }
    }

    // Perform promotions
    for (const id of toPromote) {
      const result = await this.promote(id);
      if (result.success) promoted++;
    }

    // Perform removals
    for (const id of toRemove) {
      const result = await this.delete(id);
      if (result.success) removed++;
    }

    console.log(
      `[PatternStore] Cleanup: removed ${removed}, promoted ${promoted}`
    );

    return { removed, promoted };
  }

  /**
   * Cleanup patterns for a specific domain
   */
  private async cleanupDomain(domain: QEDomain): Promise<void> {
    const ids = this.domainIndex.get(domain);
    if (!ids || ids.size < this.config.maxPatternsPerDomain) return;

    // Get all patterns for domain
    const patterns: QEPattern[] = [];
    for (const id of ids) {
      const pattern = this.patternCache.get(id);
      if (pattern) patterns.push(pattern);
    }

    // Sort by quality score (worst first)
    patterns.sort((a, b) => a.qualityScore - b.qualityScore);

    // Remove lowest quality short-term patterns
    const removeCount = Math.ceil(patterns.length * 0.1); // Remove 10%
    let removed = 0;

    for (const pattern of patterns) {
      if (removed >= removeCount) break;
      if (pattern.tier === 'short-term') {
        await this.delete(pattern.id);
        removed++;
      }
    }
  }

  /**
   * Record search latency
   */
  private recordSearchLatency(latencyMs: number): void {
    this.stats.searchOperations++;
    this.stats.searchLatencies.push(latencyMs);

    // Keep only last 1000 latencies
    if (this.stats.searchLatencies.length > 1000) {
      this.stats.searchLatencies = this.stats.searchLatencies.slice(-1000);
    }
  }

  /**
   * Calculate average search latency
   */
  private calculateAvgLatency(): number {
    if (this.stats.searchLatencies.length === 0) return 0;
    const sum = this.stats.searchLatencies.reduce((a, b) => a + b, 0);
    return sum / this.stats.searchLatencies.length;
  }

  /**
   * Dispose the pattern store
   */
  async dispose(): Promise<void> {
    if (this.cleanupTimer) {
      clearInterval(this.cleanupTimer);
      this.cleanupTimer = undefined;
    }

    this.patternCache.clear();
    this.domainIndex.clear();
    this.typeIndex.clear();
    this.tierIndex.clear();

    this.initialized = false;
  }
}

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

/**
 * Create a new pattern store instance
 */
export function createPatternStore(
  memory: MemoryBackend,
  config?: Partial<PatternStoreConfig>
): PatternStore {
  return new PatternStore(memory, config);
}