/**
 * Agentic QE v3 - Learning Consolidation Protocol
 *
 * Schedule: Friday 6pm (weekly)
 * Participants: Learning Coordinator, Transfer Specialist, Pattern Learner
 * Actions: Gather patterns, consolidate, update knowledge base
 */

import { v4 as uuidv4 } from 'uuid';
import {
  Result,
  ok,
  err,
  DomainName,
  ALL_DOMAINS,
  DomainEvent,
} from '../../shared/types/index.js';
import { TimeRange } from '../../shared/value-objects/index.js';
import { EventBus, MemoryBackend } from '../../kernel/interfaces.js';
import {
  LearnedPattern,
  PatternType,
  Knowledge,
  IPatternLearningService,
  IKnowledgeSynthesisService,
} from '../../domains/learning-optimization/interfaces.js';

// ============================================================================
// Protocol Configuration
// ============================================================================

export interface LearningConsolidationConfig {
  /** Minimum patterns per domain to trigger consolidation */
  minPatternsForConsolidation: number;
  /** Pattern similarity threshold for merging (0-1) */
  similarityThreshold: number;
  /** Maximum patterns to keep per domain after consolidation */
  maxPatternsPerDomain: number;
  /** Minimum confidence to retain pattern */
  minConfidenceThreshold: number;
  /** Number of weeks of data to analyze */
  analysisWindowWeeks: number;
  /** Enable cross-project transfer */
  enableCrossProjectTransfer: boolean;
}

const DEFAULT_CONFIG: LearningConsolidationConfig = {
  minPatternsForConsolidation: 5,
  similarityThreshold: 0.85,
  maxPatternsPerDomain: 100,
  minConfidenceThreshold: 0.5,
  analysisWindowWeeks: 4,
  enableCrossProjectTransfer: true,
};

// ============================================================================
// Protocol Events
// ============================================================================

export interface LearningConsolidationStartedEvent extends DomainEvent {
  readonly type: 'LearningConsolidationStarted';
  readonly payload: {
    consolidationId: string;
    timestamp: Date;
    domainsToProcess: DomainName[];
  };
}

export interface PatternConsolidatedEvent extends DomainEvent {
  readonly type: 'PatternConsolidated';
  readonly payload: {
    consolidationId: string;
    domain: DomainName;
    patternsBeforeCount: number;
    patternsAfterCount: number;
    mergedPatternIds: string[];
    removedPatternIds: string[];
  };
}

export interface LearningConsolidationCompletedEvent extends DomainEvent {
  readonly type: 'LearningConsolidationCompleted';
  readonly payload: {
    consolidationId: string;
    stats: ConsolidationStats;
    insights: WeeklyInsight[];
    duration: number;
  };
}

export interface TransferReadyEvent extends DomainEvent {
  readonly type: 'TransferReady';
  readonly payload: {
    consolidationId: string;
    transferablePatterns: TransferablePattern[];
    targetProjects: string[];
  };
}

// ============================================================================
// Protocol Data Types
// ============================================================================

export interface DomainPatternGroup {
  domain: DomainName;
  patterns: LearnedPattern[];
  stats: DomainPatternStats;
}

export interface DomainPatternStats {
  totalPatterns: number;
  avgConfidence: number;
  avgSuccessRate: number;
  avgUsageCount: number;
  topPatternType: PatternType;
  newPatternsThisWeek: number;
}

export interface ConsolidationStats {
  domainsProcessed: number;
  totalPatternsAnalyzed: number;
  patternsMerged: number;
  patternsRemoved: number;
  patternsRetained: number;
  knowledgeItemsUpdated: number;
  improvementOpportunities: number;
  crossDomainTransfers: number;
}

export interface WeeklyInsight {
  type: 'improvement' | 'trend' | 'anomaly' | 'recommendation';
  domain: DomainName;
  title: string;
  description: string;
  impact: 'high' | 'medium' | 'low';
  actionItems: string[];
}

export interface TransferablePattern {
  patternId: string;
  domain: DomainName;
  name: string;
  applicableDomains: DomainName[];
  transferConfidence: number;
  reason: string;
}

export interface ConsolidationResult {
  consolidationId: string;
  startedAt: Date;
  completedAt: Date;
  stats: ConsolidationStats;
  insights: WeeklyInsight[];
  transferablePatterns: TransferablePattern[];
  domainReports: DomainConsolidationReport[];
}

export interface DomainConsolidationReport {
  domain: DomainName;
  patternsBeforeCount: number;
  patternsAfterCount: number;
  mergedPatterns: MergedPatternInfo[];
  removedPatterns: RemovedPatternInfo[];
  topPerformingPatterns: LearnedPattern[];
  improvementAreas: string[];
}

export interface MergedPatternInfo {
  resultPatternId: string;
  sourcePatternIds: string[];
  mergeReason: string;
}

export interface RemovedPatternInfo {
  patternId: string;
  name: string;
  removalReason: string;
}

// ============================================================================
// Learning Consolidation Protocol Implementation
// ============================================================================

/**
 * Learning Consolidation Protocol
 *
 * Orchestrates weekly learning consolidation across all QE domains.
 * Gathers patterns, consolidates similar ones, removes underperformers,
 * and prepares high-value patterns for cross-project transfer.
 */
export class LearningConsolidationProtocol {
  private readonly config: LearningConsolidationConfig;

  constructor(
    private readonly eventBus: EventBus,
    private readonly memory: MemoryBackend,
    private readonly patternService: IPatternLearningService,
    private readonly knowledgeService: IKnowledgeSynthesisService,
    config: Partial<LearningConsolidationConfig> = {}
  ) {
    this.config = { ...DEFAULT_CONFIG, ...config };
  }

  // ============================================================================
  // Main Execution
  // ============================================================================

  /**
   * Execute the weekly learning consolidation protocol
   */
  async execute(): Promise<Result<ConsolidationResult>> {
    const consolidationId = uuidv4();
    const startedAt = new Date();

    try {
      // Publish start event
      await this.publishStartEvent(consolidationId);

      // Step 1: Gather patterns from all domains
      const gatheredPatterns = await this.gatherPatterns();
      if (!gatheredPatterns.success) {
        return err(gatheredPatterns.error);
      }

      // Step 2: Consolidate patterns per domain
      const domainReports: DomainConsolidationReport[] = [];
      let totalMerged = 0;
      let totalRemoved = 0;
      let totalRetained = 0;

      for (const domainGroup of gatheredPatterns.value) {
        const consolidationResult = await this.consolidatePatterns(
          consolidationId,
          domainGroup
        );
        if (consolidationResult.success) {
          domainReports.push(consolidationResult.value);
          totalMerged += consolidationResult.value.mergedPatterns.length;
          totalRemoved += consolidationResult.value.removedPatterns.length;
          totalRetained += consolidationResult.value.patternsAfterCount;
        }
      }

      // Step 3: Update knowledge base with consolidated patterns
      const knowledgeUpdateResult = await this.updateKnowledgeBase(domainReports);

      // Step 4: Prepare patterns for cross-project transfer
      const transferResult = await this.prepareTransfer(
        consolidationId,
        domainReports
      );

      // Step 5: Generate weekly insights
      const insights = await this.generateInsights(
        gatheredPatterns.value,
        domainReports
      );

      const completedAt = new Date();
      const duration = completedAt.getTime() - startedAt.getTime();

      const stats: ConsolidationStats = {
        domainsProcessed: domainReports.length,
        totalPatternsAnalyzed: gatheredPatterns.value.reduce(
          (sum, g) => sum + g.patterns.length,
          0
        ),
        patternsMerged: totalMerged,
        patternsRemoved: totalRemoved,
        patternsRetained: totalRetained,
        knowledgeItemsUpdated: knowledgeUpdateResult.success
          ? knowledgeUpdateResult.value
          : 0,
        improvementOpportunities: insights.filter(
          (i) => i.type === 'improvement'
        ).length,
        crossDomainTransfers: transferResult.success
          ? transferResult.value.length
          : 0,
      };

      // Publish completion event
      await this.publishCompletedEvent(consolidationId, stats, insights, duration);

      const result: ConsolidationResult = {
        consolidationId,
        startedAt,
        completedAt,
        stats,
        insights,
        transferablePatterns: transferResult.success ? transferResult.value : [],
        domainReports,
      };

      // Store result for historical analysis
      await this.storeConsolidationResult(result);

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

  // ============================================================================
  // Pattern Gathering
  // ============================================================================

  /**
   * Gather patterns from all 12 domains
   */
  async gatherPatterns(): Promise<Result<DomainPatternGroup[]>> {
    try {
      const domainGroups: DomainPatternGroup[] = [];
      const timeRange = TimeRange.lastNDays(this.config.analysisWindowWeeks * 7);

      for (const domain of ALL_DOMAINS) {
        const patterns = await this.getPatternsForDomain(domain, timeRange);
        if (patterns.length > 0) {
          const stats = this.calculateDomainStats(patterns, timeRange);
          domainGroups.push({ domain, patterns, stats });
        }
      }

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

  /**
   * Get patterns for a specific domain
   */
  private async getPatternsForDomain(
    domain: DomainName,
    timeRange: TimeRange
  ): Promise<LearnedPattern[]> {
    const keys = await this.memory.search(`learning:pattern:*`, 500);
    const patterns: LearnedPattern[] = [];

    for (const key of keys) {
      const pattern = await this.memory.get<LearnedPattern>(key);
      if (
        pattern &&
        pattern.domain === domain &&
        !key.includes(':archived:') &&
        (timeRange.contains(pattern.createdAt) || timeRange.contains(pattern.lastUsedAt))
      ) {
        patterns.push(pattern);
      }
    }

    return patterns;
  }

  /**
   * Calculate statistics for a domain's patterns
   */
  private calculateDomainStats(
    patterns: LearnedPattern[],
    timeRange: TimeRange
  ): DomainPatternStats {
    if (patterns.length === 0) {
      return {
        totalPatterns: 0,
        avgConfidence: 0,
        avgSuccessRate: 0,
        avgUsageCount: 0,
        topPatternType: 'workflow-pattern',
        newPatternsThisWeek: 0,
      };
    }

    const typeCounts: Map<PatternType, number> = new Map();
    let totalConfidence = 0;
    let totalSuccessRate = 0;
    let totalUsageCount = 0;
    let newPatterns = 0;

    for (const pattern of patterns) {
      totalConfidence += pattern.confidence;
      totalSuccessRate += pattern.successRate;
      totalUsageCount += pattern.usageCount;
      typeCounts.set(pattern.type, (typeCounts.get(pattern.type) || 0) + 1);

      if (timeRange.contains(pattern.createdAt)) {
        newPatterns++;
      }
    }

    let topType: PatternType = 'workflow-pattern';
    let maxCount = 0;
    for (const [type, count] of typeCounts) {
      if (count > maxCount) {
        maxCount = count;
        topType = type;
      }
    }

    return {
      totalPatterns: patterns.length,
      avgConfidence: totalConfidence / patterns.length,
      avgSuccessRate: totalSuccessRate / patterns.length,
      avgUsageCount: totalUsageCount / patterns.length,
      topPatternType: topType,
      newPatternsThisWeek: newPatterns,
    };
  }

  // ============================================================================
  // Pattern Consolidation
  // ============================================================================

  /**
   * Consolidate patterns within a domain - merge similar, remove underperformers
   */
  async consolidatePatterns(
    consolidationId: string,
    domainGroup: DomainPatternGroup
  ): Promise<Result<DomainConsolidationReport>> {
    try {
      const { domain, patterns } = domainGroup;
      const mergedPatterns: MergedPatternInfo[] = [];
      const removedPatterns: RemovedPatternInfo[] = [];
      const retainedPatterns: LearnedPattern[] = [];

      // Group similar patterns for merging
      const similarGroups = this.groupSimilarPatterns(patterns);

      for (const group of similarGroups) {
        if (group.length >= 2) {
          // Merge similar patterns
          const mergeResult = await this.mergePatternGroup(group);
          if (mergeResult.success) {
            mergedPatterns.push({
              resultPatternId: mergeResult.value.id,
              sourcePatternIds: group.map((p) => p.id),
              mergeReason: 'Similar pattern context and template',
            });
            retainedPatterns.push(mergeResult.value);
          }
        } else {
          // Single pattern - check if it should be retained
          const pattern = group[0];
          if (this.shouldRetainPattern(pattern)) {
            retainedPatterns.push(pattern);
          } else {
            removedPatterns.push({
              patternId: pattern.id,
              name: pattern.name,
              removalReason: this.getRemovalReason(pattern),
            });
            await this.archivePattern(pattern);
          }
        }
      }

      // Trim to max patterns if needed
      const finalPatterns = this.trimToMaxPatterns(retainedPatterns, domain);
      const trimmedCount = retainedPatterns.length - finalPatterns.length;
      if (trimmedCount > 0) {
        const trimmed = retainedPatterns.slice(finalPatterns.length);
        for (const p of trimmed) {
          removedPatterns.push({
            patternId: p.id,
            name: p.name,
            removalReason: 'Exceeded max patterns per domain limit',
          });
          await this.archivePattern(p);
        }
      }

      // Publish domain consolidation event
      await this.publishPatternConsolidatedEvent(
        consolidationId,
        domain,
        patterns.length,
        finalPatterns.length,
        mergedPatterns.map((m) => m.resultPatternId),
        removedPatterns.map((r) => r.patternId)
      );

      const report: DomainConsolidationReport = {
        domain,
        patternsBeforeCount: patterns.length,
        patternsAfterCount: finalPatterns.length,
        mergedPatterns,
        removedPatterns,
        topPerformingPatterns: this.getTopPerformingPatterns(finalPatterns, 5),
        improvementAreas: this.identifyImprovementAreas(domainGroup),
      };

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

  /**
   * Group patterns by similarity
   */
  private groupSimilarPatterns(patterns: LearnedPattern[]): LearnedPattern[][] {
    const groups: LearnedPattern[][] = [];
    const assigned = new Set<string>();

    for (const pattern of patterns) {
      if (assigned.has(pattern.id)) continue;

      const group: LearnedPattern[] = [pattern];
      assigned.add(pattern.id);

      for (const other of patterns) {
        if (assigned.has(other.id)) continue;

        if (this.areSimilarPatterns(pattern, other)) {
          group.push(other);
          assigned.add(other.id);
        }
      }

      groups.push(group);
    }

    return groups;
  }

  /**
   * Check if two patterns are similar enough to merge
   */
  private areSimilarPatterns(a: LearnedPattern, b: LearnedPattern): boolean {
    // Same type required
    if (a.type !== b.type) return false;

    // Check context similarity
    const contextSimilarity = this.calculateContextSimilarity(a.context, b.context);
    if (contextSimilarity < this.config.similarityThreshold) return false;

    // Check template type
    if (a.template.type !== b.template.type) return false;

    return true;
  }

  /**
   * Calculate similarity between two pattern contexts
   */
  private calculateContextSimilarity(
    a: { language?: string; framework?: string; testType?: string; tags: string[] },
    b: { language?: string; framework?: string; testType?: string; tags: string[] }
  ): number {
    let score = 0;
    let factors = 0;

    // Language match
    if (a.language && b.language) {
      factors++;
      if (a.language === b.language) score++;
    }

    // Framework match
    if (a.framework && b.framework) {
      factors++;
      if (a.framework === b.framework) score++;
    }

    // Test type match
    if (a.testType && b.testType) {
      factors++;
      if (a.testType === b.testType) score++;
    }

    // Tag overlap
    if (a.tags.length > 0 && b.tags.length > 0) {
      factors++;
      const overlap = a.tags.filter((t) => b.tags.includes(t)).length;
      const union = new Set([...a.tags, ...b.tags]).size;
      score += overlap / union;
    }

    return factors > 0 ? score / factors : 0;
  }

  /**
   * Merge a group of similar patterns into one
   */
  private async mergePatternGroup(
    group: LearnedPattern[]
  ): Promise<Result<LearnedPattern>> {
    const patternIds = group.map((p) => p.id);
    return this.patternService.consolidatePatterns(patternIds);
  }

  /**
   * Check if a pattern should be retained
   */
  private shouldRetainPattern(pattern: LearnedPattern): boolean {
    // Remove low confidence patterns
    if (pattern.confidence < this.config.minConfidenceThreshold) {
      return false;
    }

    // Remove patterns with poor success rate and low usage
    if (pattern.successRate < 0.3 && pattern.usageCount < 5) {
      return false;
    }

    // Check for staleness (not used in 30 days)
    const daysSinceLastUse =
      (Date.now() - pattern.lastUsedAt.getTime()) / (1000 * 60 * 60 * 24);
    if (daysSinceLastUse > 30 && pattern.usageCount < 10) {
      return false;
    }

    return true;
  }

  /**
   * Get reason for pattern removal
   */
  private getRemovalReason(pattern: LearnedPattern): string {
    if (pattern.confidence < this.config.minConfidenceThreshold) {
      return `Low confidence (${(pattern.confidence * 100).toFixed(1)}%)`;
    }
    if (pattern.successRate < 0.3) {
      return `Low success rate (${(pattern.successRate * 100).toFixed(1)}%)`;
    }
    const daysSinceLastUse =
      (Date.now() - pattern.lastUsedAt.getTime()) / (1000 * 60 * 60 * 24);
    if (daysSinceLastUse > 30) {
      return `Stale - not used in ${Math.round(daysSinceLastUse)} days`;
    }
    return 'Below retention threshold';
  }

  /**
   * Archive a pattern (soft delete)
   */
  private async archivePattern(pattern: LearnedPattern): Promise<void> {
    // Move to archived namespace
    await this.memory.set(`learning:pattern:archived:${pattern.id}`, {
      ...pattern,
      archivedAt: new Date(),
    }, { namespace: 'learning-optimization', persist: true });

    // Delete from active patterns
    await this.memory.delete(`learning:pattern:${pattern.id}`);
  }

  /**
   * Trim patterns to max allowed per domain
   */
  private trimToMaxPatterns(
    patterns: LearnedPattern[],
    _domain: DomainName
  ): LearnedPattern[] {
    if (patterns.length <= this.config.maxPatternsPerDomain) {
      return patterns;
    }

    // Sort by effectiveness score and keep top N
    return patterns
      .sort((a, b) => {
        const scoreA = a.confidence * 0.4 + a.successRate * 0.4 + Math.min(a.usageCount / 100, 0.2);
        const scoreB = b.confidence * 0.4 + b.successRate * 0.4 + Math.min(b.usageCount / 100, 0.2);
        return scoreB - scoreA;
      })
      .slice(0, this.config.maxPatternsPerDomain);
  }

  /**
   * Get top performing patterns
   */
  private getTopPerformingPatterns(
    patterns: LearnedPattern[],
    count: number
  ): LearnedPattern[] {
    return patterns
      .sort((a, b) => {
        const scoreA = a.successRate * 0.6 + a.confidence * 0.4;
        const scoreB = b.successRate * 0.6 + b.confidence * 0.4;
        return scoreB - scoreA;
      })
      .slice(0, count);
  }

  /**
   * Identify improvement areas for a domain
   */
  private identifyImprovementAreas(group: DomainPatternGroup): string[] {
    const areas: string[] = [];
    const { stats } = group;

    if (stats.avgSuccessRate < 0.7) {
      areas.push(`Improve pattern success rate (currently ${(stats.avgSuccessRate * 100).toFixed(1)}%)`);
    }

    if (stats.avgConfidence < 0.6) {
      areas.push(`Increase pattern confidence through more training data`);
    }

    if (stats.newPatternsThisWeek === 0) {
      areas.push(`No new patterns learned this week - consider gathering more experiences`);
    }

    if (stats.avgUsageCount < 5) {
      areas.push(`Low pattern utilization - promote pattern adoption`);
    }

    return areas;
  }

  // ============================================================================
  // Knowledge Base Update
  // ============================================================================

  /**
   * Update knowledge base with consolidated patterns
   */
  async updateKnowledgeBase(
    domainReports: DomainConsolidationReport[]
  ): Promise<Result<number>> {
    try {
      let updatedCount = 0;

      for (const report of domainReports) {
        // Create knowledge entries for top performing patterns
        for (const pattern of report.topPerformingPatterns) {
          const knowledgeResult = await this.createKnowledgeFromPattern(pattern);
          if (knowledgeResult.success) {
            updatedCount++;

            // Share high-performing pattern knowledge with related domains
            if (pattern.successRate >= 0.8) {
              const knowledge = await this.memory.get<Knowledge>(
                `learning:knowledge:pattern:${pattern.id}`
              );
              if (knowledge) {
                // Use knowledgeService to share across domains
                await this.knowledgeService.shareKnowledge(knowledge, [
                  {
                    value: `${pattern.domain}-coordinator`,
                    domain: pattern.domain,
                    type: 'coordinator',
                  },
                ]);
              }
            }
          }
        }

        // Store consolidation summary as knowledge
        await this.storeConsolidationSummary(report);
        updatedCount++;
      }

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

  /**
   * Create a knowledge entry from a high-performing pattern
   */
  private async createKnowledgeFromPattern(
    pattern: LearnedPattern
  ): Promise<Result<void>> {
    const knowledge: Knowledge = {
      id: uuidv4(),
      type: 'heuristic',
      domain: pattern.domain,
      content: {
        format: 'json',
        data: {
          patternId: pattern.id,
          patternType: pattern.type,
          template: pattern.template,
          context: pattern.context,
          effectiveness: {
            confidence: pattern.confidence,
            successRate: pattern.successRate,
            usageCount: pattern.usageCount,
          },
        },
        metadata: {
          sourceType: 'pattern-consolidation',
          consolidatedAt: new Date().toISOString(),
        },
      },
      sourceAgentId: {
        value: 'learning-consolidation-protocol',
        domain: 'learning-optimization',
        type: 'coordinator',
      },
      targetDomains: [pattern.domain],
      relevanceScore: pattern.confidence * 0.5 + pattern.successRate * 0.5,
      version: 1,
      createdAt: new Date(),
    };

    await this.memory.set(`learning:knowledge:pattern:${pattern.id}`, knowledge, {
      namespace: 'learning-optimization',
      persist: true,
    });

    return ok(undefined);
  }

  /**
   * Store consolidation summary as knowledge
   */
  private async storeConsolidationSummary(
    report: DomainConsolidationReport
  ): Promise<void> {
    await this.memory.set(
      `learning:consolidation:summary:${report.domain}:${Date.now()}`,
      {
        domain: report.domain,
        date: new Date(),
        patternsBefore: report.patternsBeforeCount,
        patternsAfter: report.patternsAfterCount,
        mergedCount: report.mergedPatterns.length,
        removedCount: report.removedPatterns.length,
        improvementAreas: report.improvementAreas,
      },
      { namespace: 'learning-optimization', persist: true }
    );
  }

  // ============================================================================
  // Cross-Project Transfer
  // ============================================================================

  /**
   * Prepare high-value patterns for cross-project transfer
   */
  async prepareTransfer(
    consolidationId: string,
    domainReports: DomainConsolidationReport[]
  ): Promise<Result<TransferablePattern[]>> {
    try {
      if (!this.config.enableCrossProjectTransfer) {
        return ok([]);
      }

      const transferablePatterns: TransferablePattern[] = [];

      for (const report of domainReports) {
        for (const pattern of report.topPerformingPatterns) {
          // Only transfer highly effective patterns
          if (pattern.successRate >= 0.8 && pattern.confidence >= 0.7) {
            const applicableDomains = this.findApplicableDomains(pattern);
            if (applicableDomains.length > 1) {
              transferablePatterns.push({
                patternId: pattern.id,
                domain: pattern.domain,
                name: pattern.name,
                applicableDomains,
                transferConfidence: Math.min(pattern.successRate, pattern.confidence),
                reason: `High success rate (${(pattern.successRate * 100).toFixed(0)}%) with ${pattern.usageCount} uses`,
              });
            }
          }
        }
      }

      // Publish transfer ready event if we have patterns to transfer
      if (transferablePatterns.length > 0) {
        await this.publishTransferReadyEvent(consolidationId, transferablePatterns);
      }

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

  /**
   * Find domains where a pattern could be applicable
   */
  private findApplicableDomains(pattern: LearnedPattern): DomainName[] {
    const relatedDomains: Record<DomainName, DomainName[]> = {
      'test-generation': ['test-execution', 'coverage-analysis'],
      'test-execution': ['test-generation', 'coverage-analysis', 'quality-assessment'],
      'coverage-analysis': ['test-generation', 'test-execution', 'quality-assessment'],
      'quality-assessment': ['test-execution', 'coverage-analysis', 'defect-intelligence'],
      'defect-intelligence': ['quality-assessment', 'code-intelligence'],
      'requirements-validation': ['test-generation', 'quality-assessment'],
      'code-intelligence': ['defect-intelligence', 'security-compliance'],
      'security-compliance': ['code-intelligence', 'quality-assessment'],
      'contract-testing': ['test-generation', 'test-execution'],
      'visual-accessibility': ['quality-assessment'],
      'chaos-resilience': ['test-execution', 'quality-assessment'],
      'learning-optimization': ALL_DOMAINS.filter((d) => d !== 'learning-optimization'),
    };

    return [pattern.domain, ...(relatedDomains[pattern.domain] || [])];
  }

  // ============================================================================
  // Insight Generation
  // ============================================================================

  /**
   * Generate weekly learning report with insights
   */
  async generateInsights(
    gatheredPatterns: DomainPatternGroup[],
    domainReports: DomainConsolidationReport[]
  ): Promise<WeeklyInsight[]> {
    const insights: WeeklyInsight[] = [];

    // Analyze each domain
    for (const group of gatheredPatterns) {
      const report = domainReports.find((r) => r.domain === group.domain);

      // Check for significant pattern growth
      if (group.stats.newPatternsThisWeek > 5) {
        insights.push({
          type: 'trend',
          domain: group.domain,
          title: `High pattern learning activity in ${group.domain}`,
          description: `${group.stats.newPatternsThisWeek} new patterns learned this week`,
          impact: 'medium',
          actionItems: ['Review new patterns for quality', 'Monitor success rates'],
        });
      }

      // Check for declining success rates
      if (group.stats.avgSuccessRate < 0.5) {
        insights.push({
          type: 'anomaly',
          domain: group.domain,
          title: `Low average success rate in ${group.domain}`,
          description: `Average success rate is ${(group.stats.avgSuccessRate * 100).toFixed(1)}%`,
          impact: 'high',
          actionItems: [
            'Review pattern selection criteria',
            'Gather more training experiences',
            'Consider retiring low-performing patterns',
          ],
        });
      }

      // Identify improvement opportunities
      if (report && report.improvementAreas.length > 0) {
        insights.push({
          type: 'improvement',
          domain: group.domain,
          title: `Improvement opportunities in ${group.domain}`,
          description: `${report.improvementAreas.length} areas identified for improvement`,
          impact: 'medium',
          actionItems: report.improvementAreas,
        });
      }

      // Recommend consolidation if many patterns
      if (group.patterns.length > this.config.maxPatternsPerDomain * 0.8) {
        insights.push({
          type: 'recommendation',
          domain: group.domain,
          title: `Pattern count nearing limit in ${group.domain}`,
          description: `${group.patterns.length} patterns (limit: ${this.config.maxPatternsPerDomain})`,
          impact: 'low',
          actionItems: [
            'Review pattern effectiveness',
            'Consider more aggressive consolidation',
          ],
        });
      }
    }

    // Cross-domain insights
    const topDomains = gatheredPatterns
      .sort((a, b) => b.stats.avgSuccessRate - a.stats.avgSuccessRate)
      .slice(0, 3);

    if (topDomains.length > 0) {
      insights.push({
        type: 'trend',
        domain: topDomains[0].domain,
        title: 'Top performing domains',
        description: `Best success rates: ${topDomains.map((d) => `${d.domain} (${(d.stats.avgSuccessRate * 100).toFixed(0)}%)`).join(', ')}`,
        impact: 'medium',
        actionItems: ['Analyze successful patterns for cross-domain application'],
      });
    }

    return insights;
  }

  // ============================================================================
  // Event Publishing
  // ============================================================================

  private async publishStartEvent(consolidationId: string): Promise<void> {
    const event: LearningConsolidationStartedEvent = {
      id: uuidv4(),
      type: 'LearningConsolidationStarted',
      timestamp: new Date(),
      source: 'learning-optimization',
      payload: {
        consolidationId,
        timestamp: new Date(),
        domainsToProcess: [...ALL_DOMAINS],
      },
    };
    await this.eventBus.publish(event);
  }

  private async publishPatternConsolidatedEvent(
    consolidationId: string,
    domain: DomainName,
    patternsBeforeCount: number,
    patternsAfterCount: number,
    mergedPatternIds: string[],
    removedPatternIds: string[]
  ): Promise<void> {
    const event: PatternConsolidatedEvent = {
      id: uuidv4(),
      type: 'PatternConsolidated',
      timestamp: new Date(),
      source: 'learning-optimization',
      payload: {
        consolidationId,
        domain,
        patternsBeforeCount,
        patternsAfterCount,
        mergedPatternIds,
        removedPatternIds,
      },
    };
    await this.eventBus.publish(event);
  }

  private async publishCompletedEvent(
    consolidationId: string,
    stats: ConsolidationStats,
    insights: WeeklyInsight[],
    duration: number
  ): Promise<void> {
    const event: LearningConsolidationCompletedEvent = {
      id: uuidv4(),
      type: 'LearningConsolidationCompleted',
      timestamp: new Date(),
      source: 'learning-optimization',
      payload: {
        consolidationId,
        stats,
        insights,
        duration,
      },
    };
    await this.eventBus.publish(event);
  }

  private async publishTransferReadyEvent(
    consolidationId: string,
    transferablePatterns: TransferablePattern[]
  ): Promise<void> {
    // Extract unique target projects (in this case, we derive from domains)
    const targetProjects = [...new Set(
      transferablePatterns.flatMap((p) => p.applicableDomains)
    )].map((d) => `project-${d}`);

    const event: TransferReadyEvent = {
      id: uuidv4(),
      type: 'TransferReady',
      timestamp: new Date(),
      source: 'learning-optimization',
      payload: {
        consolidationId,
        transferablePatterns,
        targetProjects,
      },
    };
    await this.eventBus.publish(event);
  }

  // ============================================================================
  // Storage
  // ============================================================================

  private async storeConsolidationResult(result: ConsolidationResult): Promise<void> {
    await this.memory.set(
      `learning:consolidation:result:${result.consolidationId}`,
      result,
      { namespace: 'learning-optimization', persist: true }
    );

    // Also store in historical timeline
    await this.memory.set(
      `learning:consolidation:history:${result.completedAt.getTime()}`,
      {
        consolidationId: result.consolidationId,
        completedAt: result.completedAt,
        stats: result.stats,
      },
      { namespace: 'learning-optimization', persist: true }
    );
  }

  // ============================================================================
  // Utility Methods
  // ============================================================================

  /**
   * Get previous consolidation results for trend analysis
   */
  async getPreviousConsolidations(count: number): Promise<ConsolidationResult[]> {
    const keys = await this.memory.search('learning:consolidation:result:*', count);
    const results: ConsolidationResult[] = [];

    for (const key of keys) {
      const result = await this.memory.get<ConsolidationResult>(key);
      if (result) {
        results.push(result);
      }
    }

    return results.sort(
      (a, b) => b.completedAt.getTime() - a.completedAt.getTime()
    );
  }

  /**
   * Get consolidation history summary
   */
  async getConsolidationHistory(weeks: number): Promise<{
    consolidations: number;
    totalPatternsMerged: number;
    totalPatternsRemoved: number;
    avgImprovementOpportunities: number;
  }> {
    const results = await this.getPreviousConsolidations(weeks);

    if (results.length === 0) {
      return {
        consolidations: 0,
        totalPatternsMerged: 0,
        totalPatternsRemoved: 0,
        avgImprovementOpportunities: 0,
      };
    }

    const totalMerged = results.reduce((sum, r) => sum + r.stats.patternsMerged, 0);
    const totalRemoved = results.reduce((sum, r) => sum + r.stats.patternsRemoved, 0);
    const avgOpportunities =
      results.reduce((sum, r) => sum + r.stats.improvementOpportunities, 0) /
      results.length;

    return {
      consolidations: results.length,
      totalPatternsMerged: totalMerged,
      totalPatternsRemoved: totalRemoved,
      avgImprovementOpportunities: avgOpportunities,
    };
  }
}

// ============================================================================
// Factory Function
// ============================================================================

/**
 * Create a Learning Consolidation Protocol instance
 */
export function createLearningConsolidationProtocol(
  eventBus: EventBus,
  memory: MemoryBackend,
  patternService: IPatternLearningService,
  knowledgeService: IKnowledgeSynthesisService,
  config?: Partial<LearningConsolidationConfig>
): LearningConsolidationProtocol {
  return new LearningConsolidationProtocol(
    eventBus,
    memory,
    patternService,
    knowledgeService,
    config
  );
}