/**
 * Agentic QE v3 - Quality Gate Protocol
 * Cross-domain protocol for release candidate quality gate evaluation
 *
 * Trigger: Release candidate event
 * Participants: Queen, Quality Gate, Coverage, Regression, Security domains
 * Actions: Aggregate metrics, evaluate, ML risk assessment, recommend
 */

import { v4 as uuidv4 } from 'uuid';
import {
  Result,
  ok,
  err,
  DomainName,
  Severity,
} from '../../shared/types';
import {
  EventBus,
  MemoryBackend,
  AgentCoordinator,
} from '../../kernel/interfaces';
import { createEvent } from '../../shared/events/domain-events';

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

export const QualityGateProtocolEvents = {
  QualityGateTriggered: 'coordination.QualityGateTriggered',
  QualityGateCompleted: 'coordination.QualityGateCompleted',
  DeploymentApproved: 'coordination.DeploymentApproved',
  DeploymentBlocked: 'coordination.DeploymentBlocked',
} as const;

// ============================================================================
// Types
// ============================================================================

/**
 * Release candidate information
 */
export interface ReleaseCandidate {
  id: string;
  version: string;
  branch: string;
  commitHash: string;
  buildId?: string;
  artifacts?: string[];
  createdAt: Date;
  metadata?: Record<string, unknown>;
}

/**
 * Aggregated metrics from all participating domains
 */
export interface AggregatedMetrics {
  // Coverage metrics
  coverage: {
    line: number;
    branch: number;
    function: number;
    statement: number;
    trend: 'improving' | 'declining' | 'stable';
  };

  // Test execution metrics
  testExecution: {
    total: number;
    passed: number;
    failed: number;
    skipped: number;
    passRate: number;
    flakyTests: number;
    duration: number;
  };

  // Quality metrics
  quality: {
    overallScore: number;
    technicalDebt: number;
    codeSmells: number;
    duplications: number;
    criticalBugs: number;
  };

  // Security metrics
  security: {
    vulnerabilities: {
      critical: number;
      high: number;
      medium: number;
      low: number;
    };
    complianceScore: number;
    lastAuditDate?: Date;
  };

  // Defect intelligence metrics
  defects: {
    regressionRisk: number;
    predictedDefects: number;
    hotspotCount: number;
  };

  // Metadata
  collectedAt: Date;
  sources: DomainName[];
}

/**
 * Quality gate check result
 */
export interface GateCheckResult {
  name: string;
  category: 'coverage' | 'tests' | 'quality' | 'security' | 'regression';
  passed: boolean;
  blocking: boolean;
  value: number;
  threshold: number;
  severity: Severity;
  message: string;
}

/**
 * ML-based risk assessment result
 */
export interface RiskAssessment {
  overallRisk: number;
  riskLevel: Severity;
  confidence: number;
  factors: RiskFactor[];
  historicalComparison?: {
    similarReleases: number;
    successRate: number;
  };
  predictions: {
    defectProbability: number;
    rollbackProbability: number;
    incidentProbability: number;
  };
}

export interface RiskFactor {
  name: string;
  contribution: number;
  description: string;
  mitigationSuggestion?: string;
}

/**
 * Quality gate recommendation
 */
export interface QualityGateRecommendation {
  decision: 'approved' | 'blocked' | 'conditional';
  confidence: number;
  summary: string;
  blockingIssues: string[];
  warnings: string[];
  conditions?: string[];
  rollbackPlan?: string;
  nextSteps: string[];
}

/**
 * Complete quality gate evaluation result
 */
export interface QualityGateEvaluation {
  id: string;
  releaseCandidate: ReleaseCandidate;
  metrics: AggregatedMetrics;
  checks: GateCheckResult[];
  riskAssessment: RiskAssessment;
  recommendation: QualityGateRecommendation;
  duration: number;
  evaluatedAt: Date;
}

/**
 * Configuration for quality gate thresholds
 */
export interface QualityGateThresholds {
  coverage: {
    line: { min: number; blocking: boolean };
    branch: { min: number; blocking: boolean };
  };
  tests: {
    passRate: { min: number; blocking: boolean };
    maxFlakyTests: { max: number; blocking: boolean };
  };
  quality: {
    minScore: { min: number; blocking: boolean };
    maxCriticalBugs: { max: number; blocking: boolean };
  };
  security: {
    maxCriticalVulns: { max: number; blocking: boolean };
    maxHighVulns: { max: number; blocking: boolean };
    minComplianceScore: { min: number; blocking: boolean };
  };
  regression: {
    maxRisk: { max: number; blocking: boolean };
  };
}

/**
 * Protocol configuration
 */
export interface QualityGateProtocolConfig {
  thresholds: QualityGateThresholds;
  enableMLRiskAssessment: boolean;
  publishEvents: boolean;
  timeout: number;
  parallelMetricsCollection: boolean;
  storeEvaluationHistory: boolean;
}

// ============================================================================
// Default Configuration
// ============================================================================

const DEFAULT_THRESHOLDS: QualityGateThresholds = {
  coverage: {
    line: { min: 80, blocking: true },
    branch: { min: 70, blocking: false },
  },
  tests: {
    passRate: { min: 100, blocking: true },
    maxFlakyTests: { max: 5, blocking: false },
  },
  quality: {
    minScore: { min: 70, blocking: false },
    maxCriticalBugs: { max: 0, blocking: true },
  },
  security: {
    maxCriticalVulns: { max: 0, blocking: true },
    maxHighVulns: { max: 3, blocking: false },
    minComplianceScore: { min: 80, blocking: false },
  },
  regression: {
    maxRisk: { max: 0.7, blocking: false },
  },
};

const DEFAULT_CONFIG: QualityGateProtocolConfig = {
  thresholds: DEFAULT_THRESHOLDS,
  enableMLRiskAssessment: true,
  publishEvents: true,
  timeout: 120000, // 2 minutes
  parallelMetricsCollection: true,
  storeEvaluationHistory: true,
};

// ============================================================================
// Protocol Interface
// ============================================================================

export interface IQualityGateProtocol {
  /**
   * Execute quality gate evaluation for a release candidate
   */
  execute(releaseCandidate: ReleaseCandidate): Promise<Result<QualityGateEvaluation, Error>>;

  /**
   * Aggregate metrics from all participating domains
   */
  aggregateMetrics(releaseCandidate: ReleaseCandidate): Promise<Result<AggregatedMetrics, Error>>;

  /**
   * Evaluate quality gate checks against aggregated metrics
   */
  evaluateGate(metrics: AggregatedMetrics): Promise<Result<GateCheckResult[], Error>>;

  /**
   * Perform ML-based deployment risk assessment
   */
  assessRisk(
    metrics: AggregatedMetrics,
    checks: GateCheckResult[]
  ): Promise<Result<RiskAssessment, Error>>;

  /**
   * Generate go/no-go recommendation
   */
  generateRecommendation(
    releaseCandidate: ReleaseCandidate,
    checks: GateCheckResult[],
    riskAssessment: RiskAssessment
  ): Promise<Result<QualityGateRecommendation, Error>>;

  /**
   * Get evaluation history for a release
   */
  getEvaluationHistory(releaseId: string): Promise<QualityGateEvaluation[]>;

  /**
   * Update thresholds configuration
   */
  updateThresholds(thresholds: Partial<QualityGateThresholds>): void;
}

// ============================================================================
// Protocol Implementation
// ============================================================================

export class QualityGateProtocol implements IQualityGateProtocol {
  private config: QualityGateProtocolConfig;
  private readonly participatingDomains: DomainName[] = [
    'quality-assessment',
    'coverage-analysis',
    'defect-intelligence',
    'security-compliance',
    'test-execution',
  ];

  constructor(
    private readonly eventBus: EventBus,
    private readonly memory: MemoryBackend,
    private readonly agentCoordinator: AgentCoordinator,
    config: Partial<QualityGateProtocolConfig> = {}
  ) {
    this.config = {
      ...DEFAULT_CONFIG,
      ...config,
      thresholds: {
        ...DEFAULT_THRESHOLDS,
        ...config.thresholds,
      },
    };
  }

  /**
   * Execute complete quality gate evaluation
   */
  async execute(
    releaseCandidate: ReleaseCandidate
  ): Promise<Result<QualityGateEvaluation, Error>> {
    const evaluationId = uuidv4();
    const startTime = Date.now();
    let spawnedAgentId: string | undefined;

    try {
      // Publish triggered event
      if (this.config.publishEvents) {
        await this.publishQualityGateTriggered(evaluationId, releaseCandidate);
      }

      // Spawn coordinator agent if available
      spawnedAgentId = await this.spawnCoordinatorAgent(evaluationId, releaseCandidate);

      // Step 1: Aggregate metrics from all participating domains
      const metricsResult = await this.aggregateMetrics(releaseCandidate);
      if (!metricsResult.success) {
        await this.publishGateCompleted(evaluationId, releaseCandidate, 'blocked', metricsResult.error.message);
        return err(metricsResult.error);
      }

      // Step 2: Evaluate quality gate checks
      const checksResult = await this.evaluateGate(metricsResult.value);
      if (!checksResult.success) {
        await this.publishGateCompleted(evaluationId, releaseCandidate, 'blocked', checksResult.error.message);
        return err(checksResult.error);
      }

      // Step 3: ML-based risk assessment
      const riskResult = await this.assessRisk(metricsResult.value, checksResult.value);
      if (!riskResult.success) {
        await this.publishGateCompleted(evaluationId, releaseCandidate, 'blocked', riskResult.error.message);
        return err(riskResult.error);
      }

      // Step 4: Generate recommendation
      const recommendationResult = await this.generateRecommendation(
        releaseCandidate,
        checksResult.value,
        riskResult.value
      );
      if (!recommendationResult.success) {
        await this.publishGateCompleted(evaluationId, releaseCandidate, 'blocked', recommendationResult.error.message);
        return err(recommendationResult.error);
      }

      const duration = Date.now() - startTime;

      const evaluation: QualityGateEvaluation = {
        id: evaluationId,
        releaseCandidate,
        metrics: metricsResult.value,
        checks: checksResult.value,
        riskAssessment: riskResult.value,
        recommendation: recommendationResult.value,
        duration,
        evaluatedAt: new Date(),
      };

      // Store evaluation history
      if (this.config.storeEvaluationHistory) {
        await this.storeEvaluation(evaluation);
      }

      // Publish completion events
      if (this.config.publishEvents) {
        await this.publishGateCompleted(
          evaluationId,
          releaseCandidate,
          recommendationResult.value.decision,
          recommendationResult.value.summary
        );

        if (recommendationResult.value.decision === 'approved') {
          await this.publishDeploymentApproved(evaluationId, releaseCandidate, recommendationResult.value);
        } else if (recommendationResult.value.decision === 'blocked') {
          await this.publishDeploymentBlocked(evaluationId, releaseCandidate, recommendationResult.value);
        }
      }

      // Cleanup spawned agent
      if (spawnedAgentId) {
        await this.stopCoordinatorAgent(spawnedAgentId);
      }

      return ok(evaluation);
    } catch (error) {
      // Cleanup on error
      if (spawnedAgentId) {
        await this.stopCoordinatorAgent(spawnedAgentId);
      }
      const errorMessage = error instanceof Error ? error.message : String(error);
      await this.publishGateCompleted(evaluationId, releaseCandidate, 'blocked', errorMessage);
      return err(error instanceof Error ? error : new Error(errorMessage));
    }
  }

  /**
   * Aggregate metrics from all participating domains
   */
  async aggregateMetrics(
    releaseCandidate: ReleaseCandidate
  ): Promise<Result<AggregatedMetrics, Error>> {
    try {
      const sources: DomainName[] = [];

      // Collect metrics from each domain
      const [coverageData, testData, qualityData, securityData, defectData] =
        this.config.parallelMetricsCollection
          ? await Promise.all([
              this.getCoverageMetrics(releaseCandidate),
              this.getTestExecutionMetrics(releaseCandidate),
              this.getQualityMetrics(releaseCandidate),
              this.getSecurityMetrics(releaseCandidate),
              this.getDefectMetrics(releaseCandidate),
            ])
          : [
              await this.getCoverageMetrics(releaseCandidate),
              await this.getTestExecutionMetrics(releaseCandidate),
              await this.getQualityMetrics(releaseCandidate),
              await this.getSecurityMetrics(releaseCandidate),
              await this.getDefectMetrics(releaseCandidate),
            ];

      // Track which domains contributed data
      if (coverageData) sources.push('coverage-analysis');
      if (testData) sources.push('test-execution');
      if (qualityData) sources.push('quality-assessment');
      if (securityData) sources.push('security-compliance');
      if (defectData) sources.push('defect-intelligence');

      const metrics: AggregatedMetrics = {
        coverage: coverageData || {
          line: 0,
          branch: 0,
          function: 0,
          statement: 0,
          trend: 'stable',
        },
        testExecution: testData || {
          total: 0,
          passed: 0,
          failed: 0,
          skipped: 0,
          passRate: 0,
          flakyTests: 0,
          duration: 0,
        },
        quality: qualityData || {
          overallScore: 0,
          technicalDebt: 0,
          codeSmells: 0,
          duplications: 0,
          criticalBugs: 0,
        },
        security: securityData || {
          vulnerabilities: { critical: 0, high: 0, medium: 0, low: 0 },
          complianceScore: 0,
        },
        defects: defectData || {
          regressionRisk: 0,
          predictedDefects: 0,
          hotspotCount: 0,
        },
        collectedAt: new Date(),
        sources,
      };

      // Store aggregated metrics for reference
      await this.memory.set(
        `quality-gate:metrics:${releaseCandidate.id}`,
        metrics,
        { namespace: 'coordination', ttl: 86400 * 7 }
      );

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

  /**
   * Evaluate quality gate checks
   */
  async evaluateGate(
    metrics: AggregatedMetrics
  ): Promise<Result<GateCheckResult[], Error>> {
    try {
      const checks: GateCheckResult[] = [];
      const thresholds = this.config.thresholds;

      // Coverage checks
      checks.push(
        this.createCheck(
          'Line Coverage',
          'coverage',
          metrics.coverage.line,
          thresholds.coverage.line.min,
          thresholds.coverage.line.blocking,
          'min',
          'Line coverage percentage'
        )
      );

      checks.push(
        this.createCheck(
          'Branch Coverage',
          'coverage',
          metrics.coverage.branch,
          thresholds.coverage.branch.min,
          thresholds.coverage.branch.blocking,
          'min',
          'Branch coverage percentage'
        )
      );

      // Test execution checks
      checks.push(
        this.createCheck(
          'Test Pass Rate',
          'tests',
          metrics.testExecution.passRate,
          thresholds.tests.passRate.min,
          thresholds.tests.passRate.blocking,
          'min',
          'Percentage of tests passing'
        )
      );

      checks.push(
        this.createCheck(
          'Flaky Tests',
          'tests',
          metrics.testExecution.flakyTests,
          thresholds.tests.maxFlakyTests.max,
          thresholds.tests.maxFlakyTests.blocking,
          'max',
          'Number of flaky tests detected'
        )
      );

      // Quality checks
      checks.push(
        this.createCheck(
          'Quality Score',
          'quality',
          metrics.quality.overallScore,
          thresholds.quality.minScore.min,
          thresholds.quality.minScore.blocking,
          'min',
          'Overall code quality score'
        )
      );

      checks.push(
        this.createCheck(
          'Critical Bugs',
          'quality',
          metrics.quality.criticalBugs,
          thresholds.quality.maxCriticalBugs.max,
          thresholds.quality.maxCriticalBugs.blocking,
          'max',
          'Number of critical bugs'
        )
      );

      // Security checks
      checks.push(
        this.createCheck(
          'Critical Vulnerabilities',
          'security',
          metrics.security.vulnerabilities.critical,
          thresholds.security.maxCriticalVulns.max,
          thresholds.security.maxCriticalVulns.blocking,
          'max',
          'Critical security vulnerabilities'
        )
      );

      checks.push(
        this.createCheck(
          'High Vulnerabilities',
          'security',
          metrics.security.vulnerabilities.high,
          thresholds.security.maxHighVulns.max,
          thresholds.security.maxHighVulns.blocking,
          'max',
          'High severity vulnerabilities'
        )
      );

      checks.push(
        this.createCheck(
          'Compliance Score',
          'security',
          metrics.security.complianceScore,
          thresholds.security.minComplianceScore.min,
          thresholds.security.minComplianceScore.blocking,
          'min',
          'Security compliance score'
        )
      );

      // Regression risk check
      checks.push(
        this.createCheck(
          'Regression Risk',
          'regression',
          metrics.defects.regressionRisk,
          thresholds.regression.maxRisk.max,
          thresholds.regression.maxRisk.blocking,
          'max',
          'ML-predicted regression risk'
        )
      );

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

  /**
   * ML-based risk assessment
   */
  async assessRisk(
    metrics: AggregatedMetrics,
    checks: GateCheckResult[]
  ): Promise<Result<RiskAssessment, Error>> {
    try {
      if (!this.config.enableMLRiskAssessment) {
        // Return basic risk assessment without ML
        return ok(this.createBasicRiskAssessment(metrics, checks));
      }

      // Calculate risk factors
      const factors = this.calculateRiskFactors(metrics, checks);

      // Calculate overall risk score (weighted average)
      const overallRisk = this.calculateOverallRisk(factors);

      // Determine risk level
      const riskLevel = this.riskScoreToSeverity(overallRisk);

      // Get historical comparison
      const historicalComparison = await this.getHistoricalComparison(metrics);

      // Calculate predictions
      const predictions = this.calculatePredictions(metrics, overallRisk, historicalComparison);

      // Calculate confidence based on data quality
      const confidence = this.calculateConfidence(metrics, historicalComparison);

      const assessment: RiskAssessment = {
        overallRisk,
        riskLevel,
        confidence,
        factors,
        historicalComparison,
        predictions,
      };

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

  /**
   * Generate go/no-go recommendation
   */
  async generateRecommendation(
    releaseCandidate: ReleaseCandidate,
    checks: GateCheckResult[],
    riskAssessment: RiskAssessment
  ): Promise<Result<QualityGateRecommendation, Error>> {
    try {
      // Separate blocking and warning issues
      const blockingIssues: string[] = [];
      const warnings: string[] = [];

      for (const check of checks) {
        if (!check.passed) {
          if (check.blocking) {
            blockingIssues.push(`${check.name}: ${check.message} (${check.value} vs threshold ${check.threshold})`);
          } else {
            warnings.push(`${check.name}: ${check.message} (${check.value} vs threshold ${check.threshold})`);
          }
        }
      }

      // Add risk-based warnings
      if (riskAssessment.overallRisk > 0.5) {
        warnings.push(`High deployment risk detected (${Math.round(riskAssessment.overallRisk * 100)}%)`);
      }

      for (const factor of riskAssessment.factors) {
        if (factor.contribution > 0.2) {
          warnings.push(`Risk factor: ${factor.description}`);
        }
      }

      // Determine decision
      let decision: QualityGateRecommendation['decision'];
      if (blockingIssues.length > 0) {
        decision = 'blocked';
      } else if (warnings.length > 0 || riskAssessment.riskLevel === 'high') {
        decision = 'conditional';
      } else {
        decision = 'approved';
      }

      // Generate summary
      const summary = this.generateSummary(decision, blockingIssues, warnings, riskAssessment);

      // Generate conditions for conditional approval
      const conditions = decision === 'conditional'
        ? this.generateConditions(warnings, riskAssessment)
        : undefined;

      // Generate rollback plan
      const rollbackPlan = decision !== 'blocked'
        ? this.generateRollbackPlan(releaseCandidate)
        : undefined;

      // Generate next steps
      const nextSteps = this.generateNextSteps(decision, blockingIssues, warnings);

      // Calculate confidence
      const confidence = this.calculateRecommendationConfidence(
        checks,
        riskAssessment,
        blockingIssues.length === 0
      );

      const recommendation: QualityGateRecommendation = {
        decision,
        confidence,
        summary,
        blockingIssues,
        warnings,
        conditions,
        rollbackPlan,
        nextSteps,
      };

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

  /**
   * Get evaluation history for a release
   */
  async getEvaluationHistory(releaseId: string): Promise<QualityGateEvaluation[]> {
    const keys = await this.memory.search(
      `quality-gate:evaluation:${releaseId}:*`,
      100
    );

    const evaluations: QualityGateEvaluation[] = [];

    for (const key of keys) {
      const evaluation = await this.memory.get<QualityGateEvaluation>(key);
      if (evaluation) {
        evaluations.push(evaluation);
      }
    }

    // Sort by date descending
    return evaluations.sort(
      (a, b) => new Date(b.evaluatedAt).getTime() - new Date(a.evaluatedAt).getTime()
    );
  }

  /**
   * Update thresholds configuration
   */
  updateThresholds(thresholds: Partial<QualityGateThresholds>): void {
    this.config.thresholds = {
      ...this.config.thresholds,
      ...thresholds,
      coverage: { ...this.config.thresholds.coverage, ...thresholds.coverage },
      tests: { ...this.config.thresholds.tests, ...thresholds.tests },
      quality: { ...this.config.thresholds.quality, ...thresholds.quality },
      security: { ...this.config.thresholds.security, ...thresholds.security },
      regression: { ...this.config.thresholds.regression, ...thresholds.regression },
    };
  }

  // ============================================================================
  // Private Helper Methods - Metrics Collection
  // ============================================================================

  private async getCoverageMetrics(
    _releaseCandidate: ReleaseCandidate
  ): Promise<AggregatedMetrics['coverage'] | null> {
    try {
      // Try to get latest coverage data from memory
      const latestCoverage = await this.memory.get<{
        line: number;
        branch: number;
        function: number;
        statement: number;
      }>('coverage:latest');

      if (!latestCoverage) {
        return null;
      }

      // Get previous coverage for trend
      const previousCoverage = await this.memory.get<{
        line: number;
      }>('coverage:previous');

      let trend: 'improving' | 'declining' | 'stable' = 'stable';
      if (previousCoverage) {
        const delta = latestCoverage.line - previousCoverage.line;
        if (delta > 0.5) trend = 'improving';
        else if (delta < -0.5) trend = 'declining';
      }

      return {
        line: latestCoverage.line,
        branch: latestCoverage.branch,
        function: latestCoverage.function,
        statement: latestCoverage.statement,
        trend,
      };
    } catch {
      return null;
    }
  }

  private async getTestExecutionMetrics(
    _releaseCandidate: ReleaseCandidate
  ): Promise<AggregatedMetrics['testExecution'] | null> {
    try {
      // Search for recent test run results
      const runKeys = await this.memory.search('test-execution:run:*', 10);

      if (runKeys.length === 0) {
        return null;
      }

      // Get the most recent run
      const latestRun = await this.memory.get<{
        total: number;
        passed: number;
        failed: number;
        skipped: number;
        duration: number;
      }>(runKeys[0]);

      if (!latestRun) {
        return null;
      }

      // Get flaky test count
      const flakyKeys = await this.memory.search('test-execution:flaky:*', 100);

      return {
        total: latestRun.total,
        passed: latestRun.passed,
        failed: latestRun.failed,
        skipped: latestRun.skipped,
        passRate: latestRun.total > 0 ? (latestRun.passed / latestRun.total) * 100 : 0,
        flakyTests: flakyKeys.length,
        duration: latestRun.duration,
      };
    } catch {
      return null;
    }
  }

  private async getQualityMetrics(
    _releaseCandidate: ReleaseCandidate
  ): Promise<AggregatedMetrics['quality'] | null> {
    try {
      const qualityData = await this.memory.get<{
        overallScore: number;
        technicalDebt: number;
        codeSmells: number;
        duplications: number;
        criticalBugs: number;
      }>('quality-assessment:latest');

      if (!qualityData) {
        return null;
      }

      return qualityData;
    } catch {
      return null;
    }
  }

  private async getSecurityMetrics(
    _releaseCandidate: ReleaseCandidate
  ): Promise<AggregatedMetrics['security'] | null> {
    try {
      const securityData = await this.memory.get<{
        vulnerabilities: { critical: number; high: number; medium: number; low: number };
        complianceScore: number;
        lastAuditDate?: string;
      }>('security-compliance:posture');

      if (!securityData) {
        return null;
      }

      return {
        vulnerabilities: securityData.vulnerabilities,
        complianceScore: securityData.complianceScore,
        lastAuditDate: securityData.lastAuditDate
          ? new Date(securityData.lastAuditDate)
          : undefined,
      };
    } catch {
      return null;
    }
  }

  private async getDefectMetrics(
    _releaseCandidate: ReleaseCandidate
  ): Promise<AggregatedMetrics['defects'] | null> {
    try {
      const defectData = await this.memory.get<{
        regressionRisk: number;
        predictedDefects: number;
        hotspotCount: number;
      }>('defect-intelligence:analysis');

      if (!defectData) {
        return null;
      }

      return defectData;
    } catch {
      return null;
    }
  }

  // ============================================================================
  // Private Helper Methods - Check Creation
  // ============================================================================

  private createCheck(
    name: string,
    category: GateCheckResult['category'],
    value: number,
    threshold: number,
    blocking: boolean,
    comparison: 'min' | 'max',
    description: string
  ): GateCheckResult {
    const passed = comparison === 'min' ? value >= threshold : value <= threshold;

    const severity = this.determineCheckSeverity(blocking, passed, value, threshold, comparison);

    const message = passed
      ? `${description} meets threshold`
      : `${description} ${comparison === 'min' ? 'below' : 'exceeds'} threshold`;

    return {
      name,
      category,
      passed,
      blocking,
      value,
      threshold,
      severity,
      message,
    };
  }

  private determineCheckSeverity(
    blocking: boolean,
    passed: boolean,
    value: number,
    threshold: number,
    comparison: 'min' | 'max'
  ): Severity {
    if (passed) {
      return 'info';
    }

    if (blocking) {
      return 'critical';
    }

    // Calculate how far from threshold
    const deviation = comparison === 'min'
      ? (threshold - value) / threshold
      : (value - threshold) / threshold;

    if (deviation > 0.5) return 'high';
    if (deviation > 0.2) return 'medium';
    return 'low';
  }

  // ============================================================================
  // Private Helper Methods - Risk Assessment
  // ============================================================================

  private createBasicRiskAssessment(
    metrics: AggregatedMetrics,
    checks: GateCheckResult[]
  ): RiskAssessment {
    const failedChecks = checks.filter((c) => !c.passed);
    const overallRisk = Math.min(1, failedChecks.length * 0.15 + metrics.defects.regressionRisk);

    return {
      overallRisk,
      riskLevel: this.riskScoreToSeverity(overallRisk),
      confidence: 0.6, // Lower confidence for basic assessment
      factors: [
        {
          name: 'Failed Checks',
          contribution: failedChecks.length * 0.1,
          description: `${failedChecks.length} quality checks failed`,
        },
      ],
      predictions: {
        defectProbability: overallRisk * 0.5,
        rollbackProbability: overallRisk * 0.3,
        incidentProbability: overallRisk * 0.2,
      },
    };
  }

  private calculateRiskFactors(
    metrics: AggregatedMetrics,
    checks: GateCheckResult[]
  ): RiskFactor[] {
    const factors: RiskFactor[] = [];

    // Coverage risk
    const coverageRisk = 1 - metrics.coverage.line / 100;
    if (coverageRisk > 0.2) {
      factors.push({
        name: 'Low Coverage',
        contribution: coverageRisk * 0.25,
        description: `Test coverage at ${metrics.coverage.line}% is below recommended levels`,
        mitigationSuggestion: 'Add tests for uncovered code paths',
      });
    }

    // Test stability risk
    const testRisk = metrics.testExecution.flakyTests > 0 || metrics.testExecution.failed > 0;
    if (testRisk) {
      const contribution = Math.min(0.3, (metrics.testExecution.failed + metrics.testExecution.flakyTests) * 0.05);
      factors.push({
        name: 'Test Instability',
        contribution,
        description: `${metrics.testExecution.failed} failed tests, ${metrics.testExecution.flakyTests} flaky tests`,
        mitigationSuggestion: 'Fix failing tests and stabilize flaky tests',
      });
    }

    // Security risk
    const securityRisk =
      metrics.security.vulnerabilities.critical * 0.4 +
      metrics.security.vulnerabilities.high * 0.2 +
      metrics.security.vulnerabilities.medium * 0.05;
    if (securityRisk > 0) {
      factors.push({
        name: 'Security Vulnerabilities',
        contribution: Math.min(0.5, securityRisk),
        description: `${metrics.security.vulnerabilities.critical} critical, ${metrics.security.vulnerabilities.high} high vulnerabilities`,
        mitigationSuggestion: 'Address security vulnerabilities before deployment',
      });
    }

    // Regression risk
    if (metrics.defects.regressionRisk > 0.3) {
      factors.push({
        name: 'Regression Risk',
        contribution: metrics.defects.regressionRisk * 0.3,
        description: `ML model predicts ${Math.round(metrics.defects.regressionRisk * 100)}% regression risk`,
        mitigationSuggestion: 'Run extended regression test suite',
      });
    }

    // Failed checks risk
    const failedBlockingChecks = checks.filter((c) => !c.passed && c.blocking);
    if (failedBlockingChecks.length > 0) {
      factors.push({
        name: 'Blocking Checks Failed',
        contribution: Math.min(0.5, failedBlockingChecks.length * 0.2),
        description: `${failedBlockingChecks.length} blocking quality checks failed`,
        mitigationSuggestion: 'Address blocking issues before proceeding',
      });
    }

    return factors;
  }

  private calculateOverallRisk(factors: RiskFactor[]): number {
    if (factors.length === 0) {
      return 0;
    }

    // Sum contributions with diminishing returns
    let totalRisk = 0;
    const sortedFactors = [...factors].sort((a, b) => b.contribution - a.contribution);

    for (let i = 0; i < sortedFactors.length; i++) {
      const weight = 1 / (i + 1); // Diminishing weight for additional factors
      totalRisk += sortedFactors[i].contribution * weight;
    }

    return Math.min(1, totalRisk);
  }

  private async getHistoricalComparison(
    metrics: AggregatedMetrics
  ): Promise<RiskAssessment['historicalComparison'] | undefined> {
    try {
      const historicalKeys = await this.memory.search('quality-gate:evaluation:*', 100);

      if (historicalKeys.length < 5) {
        return undefined;
      }

      let similarCount = 0;
      let successCount = 0;

      for (const key of historicalKeys) {
        const evaluation = await this.memory.get<QualityGateEvaluation>(key);
        if (!evaluation) continue;

        // Check similarity (within 10% on key metrics)
        const coverageSimilar =
          Math.abs(evaluation.metrics.coverage.line - metrics.coverage.line) < 10;
        const qualitySimilar =
          Math.abs(evaluation.metrics.quality.overallScore - metrics.quality.overallScore) < 10;

        if (coverageSimilar && qualitySimilar) {
          similarCount++;
          if (evaluation.recommendation.decision === 'approved') {
            successCount++;
          }
        }
      }

      if (similarCount < 3) {
        return undefined;
      }

      return {
        similarReleases: similarCount,
        successRate: successCount / similarCount,
      };
    } catch {
      return undefined;
    }
  }

  private calculatePredictions(
    metrics: AggregatedMetrics,
    overallRisk: number,
    historicalComparison?: RiskAssessment['historicalComparison']
  ): RiskAssessment['predictions'] {
    // Base predictions on risk score
    let defectProbability = overallRisk * 0.6;
    let rollbackProbability = overallRisk * 0.4;
    let incidentProbability = overallRisk * 0.3;

    // Adjust based on specific metrics
    if (metrics.security.vulnerabilities.critical > 0) {
      incidentProbability += 0.2;
    }

    if (metrics.testExecution.passRate < 100) {
      defectProbability += 0.15;
    }

    // Adjust based on historical data
    if (historicalComparison) {
      const historicalFailureRate = 1 - historicalComparison.successRate;
      defectProbability = (defectProbability + historicalFailureRate) / 2;
      rollbackProbability = (rollbackProbability + historicalFailureRate * 0.5) / 2;
    }

    return {
      defectProbability: Math.min(1, defectProbability),
      rollbackProbability: Math.min(1, rollbackProbability),
      incidentProbability: Math.min(1, incidentProbability),
    };
  }

  private calculateConfidence(
    metrics: AggregatedMetrics,
    historicalComparison?: RiskAssessment['historicalComparison']
  ): number {
    let confidence = 0.7;

    // Increase confidence based on data completeness
    if (metrics.sources.length >= 4) {
      confidence += 0.1;
    }

    // Increase confidence if we have historical data
    if (historicalComparison && historicalComparison.similarReleases >= 10) {
      confidence += 0.1;
    }

    // Decrease confidence if recent security audit is missing
    if (!metrics.security.lastAuditDate) {
      confidence -= 0.1;
    }

    return Math.max(0.5, Math.min(0.95, confidence));
  }

  private riskScoreToSeverity(risk: number): Severity {
    if (risk >= 0.8) return 'critical';
    if (risk >= 0.6) return 'high';
    if (risk >= 0.4) return 'medium';
    if (risk >= 0.2) return 'low';
    return 'info';
  }

  // ============================================================================
  // Private Helper Methods - Recommendation Generation
  // ============================================================================

  private generateSummary(
    decision: QualityGateRecommendation['decision'],
    blockingIssues: string[],
    warnings: string[],
    riskAssessment: RiskAssessment
  ): string {
    switch (decision) {
      case 'approved':
        return `Release approved with ${Math.round((1 - riskAssessment.overallRisk) * 100)}% confidence. All quality gates passed.`;
      case 'conditional':
        return `Conditional approval with ${warnings.length} warning(s). Risk level: ${riskAssessment.riskLevel}. Review recommended before proceeding.`;
      case 'blocked':
        return `Release blocked due to ${blockingIssues.length} critical issue(s). These must be resolved before deployment.`;
    }
  }

  private generateConditions(
    warnings: string[],
    riskAssessment: RiskAssessment
  ): string[] {
    const conditions: string[] = [];

    if (riskAssessment.overallRisk > 0.5) {
      conditions.push('Deploy during low-traffic period');
      conditions.push('Ensure on-call team is available');
    }

    if (warnings.some((w) => w.includes('flaky'))) {
      conditions.push('Monitor test stability for 24 hours post-deployment');
    }

    if (warnings.some((w) => w.includes('coverage'))) {
      conditions.push('Add tests for new functionality within 1 sprint');
    }

    if (warnings.some((w) => w.includes('vulnerability') || w.includes('security'))) {
      conditions.push('Security team sign-off required');
    }

    conditions.push('Feature flag recommended for gradual rollout');

    return conditions;
  }

  private generateRollbackPlan(releaseCandidate: ReleaseCandidate): string {
    return `Rollback Plan for ${releaseCandidate.version}:
1. Monitor key metrics for 15 minutes post-deployment
2. If issues detected, execute: deploy rollback ${releaseCandidate.version}
3. Verify rollback completion via health checks
4. Notify stakeholders and create incident ticket
5. Schedule post-mortem within 24 hours`;
  }

  private generateNextSteps(
    decision: QualityGateRecommendation['decision'],
    blockingIssues: string[],
    _warnings: string[]
  ): string[] {
    const steps: string[] = [];

    switch (decision) {
      case 'approved':
        steps.push('Proceed with deployment');
        steps.push('Monitor deployment metrics');
        steps.push('Notify stakeholders of successful deployment');
        break;

      case 'conditional':
        steps.push('Review warnings with team');
        steps.push('Implement mitigation measures');
        steps.push('Get sign-off from technical lead');
        steps.push('Deploy with enhanced monitoring');
        break;

      case 'blocked':
        steps.push('Address blocking issues:');
        for (const issue of blockingIssues.slice(0, 3)) {
          steps.push(`  - ${issue}`);
        }
        steps.push('Re-run quality gate after fixes');
        steps.push('Update team on blockers and timeline');
        break;
    }

    return steps;
  }

  private calculateRecommendationConfidence(
    checks: GateCheckResult[],
    riskAssessment: RiskAssessment,
    isApproved: boolean
  ): number {
    let confidence = riskAssessment.confidence;

    // Increase confidence if all checks passed
    const allChecksPassed = checks.every((c) => c.passed);
    if (allChecksPassed) {
      confidence += 0.1;
    }

    // Decrease confidence if decision is marginal
    if (!isApproved) {
      const blockingFailed = checks.filter((c) => c.blocking && !c.passed);
      if (blockingFailed.length === 1) {
        confidence -= 0.1; // Marginal failure
      }
    }

    return Math.max(0.5, Math.min(0.95, confidence));
  }

  // ============================================================================
  // Private Helper Methods - Event Publishing
  // ============================================================================

  private async publishQualityGateTriggered(
    evaluationId: string,
    releaseCandidate: ReleaseCandidate
  ): Promise<void> {
    const event = createEvent(
      QualityGateProtocolEvents.QualityGateTriggered,
      'quality-assessment',
      {
        evaluationId,
        releaseCandidate: {
          id: releaseCandidate.id,
          version: releaseCandidate.version,
          branch: releaseCandidate.branch,
        },
        participatingDomains: this.participatingDomains,
        triggeredAt: new Date().toISOString(),
      }
    );

    await this.eventBus.publish(event);
  }

  private async publishGateCompleted(
    evaluationId: string,
    releaseCandidate: ReleaseCandidate,
    decision: string,
    summary: string
  ): Promise<void> {
    const event = createEvent(
      QualityGateProtocolEvents.QualityGateCompleted,
      'quality-assessment',
      {
        evaluationId,
        releaseCandidate: {
          id: releaseCandidate.id,
          version: releaseCandidate.version,
        },
        decision,
        summary,
        completedAt: new Date().toISOString(),
      }
    );

    await this.eventBus.publish(event);
  }

  private async publishDeploymentApproved(
    evaluationId: string,
    releaseCandidate: ReleaseCandidate,
    recommendation: QualityGateRecommendation
  ): Promise<void> {
    const event = createEvent(
      QualityGateProtocolEvents.DeploymentApproved,
      'quality-assessment',
      {
        evaluationId,
        releaseCandidate: {
          id: releaseCandidate.id,
          version: releaseCandidate.version,
          commitHash: releaseCandidate.commitHash,
        },
        confidence: recommendation.confidence,
        conditions: recommendation.conditions,
        rollbackPlan: recommendation.rollbackPlan,
        approvedAt: new Date().toISOString(),
      }
    );

    await this.eventBus.publish(event);
  }

  private async publishDeploymentBlocked(
    evaluationId: string,
    releaseCandidate: ReleaseCandidate,
    recommendation: QualityGateRecommendation
  ): Promise<void> {
    const event = createEvent(
      QualityGateProtocolEvents.DeploymentBlocked,
      'quality-assessment',
      {
        evaluationId,
        releaseCandidate: {
          id: releaseCandidate.id,
          version: releaseCandidate.version,
        },
        blockingIssues: recommendation.blockingIssues,
        nextSteps: recommendation.nextSteps,
        blockedAt: new Date().toISOString(),
      }
    );

    await this.eventBus.publish(event);
  }

  // ============================================================================
  // Private Helper Methods - Storage
  // ============================================================================

  private async storeEvaluation(evaluation: QualityGateEvaluation): Promise<void> {
    const key = `quality-gate:evaluation:${evaluation.releaseCandidate.id}:${evaluation.id}`;

    await this.memory.set(key, evaluation, {
      namespace: 'coordination',
      persist: true,
    });

    // Also store as latest for this release
    await this.memory.set(
      `quality-gate:latest:${evaluation.releaseCandidate.id}`,
      evaluation,
      { namespace: 'coordination', persist: true }
    );
  }

  // ============================================================================
  // Private Helper Methods - Agent Coordination
  // ============================================================================

  /**
   * Spawn a coordinator agent for the quality gate evaluation
   */
  private async spawnCoordinatorAgent(
    evaluationId: string,
    releaseCandidate: ReleaseCandidate
  ): Promise<string | undefined> {
    if (!this.agentCoordinator.canSpawn()) {
      // No capacity for agent - proceed without coordination agent
      return undefined;
    }

    try {
      const result = await this.agentCoordinator.spawn({
        name: `quality-gate-${evaluationId.slice(0, 8)}`,
        domain: 'quality-assessment',
        type: 'coordinator',
        capabilities: [
          'quality-gate-evaluation',
          'metrics-aggregation',
          'risk-assessment',
          'deployment-recommendation',
        ],
        config: {
          evaluationId,
          releaseCandidate: {
            id: releaseCandidate.id,
            version: releaseCandidate.version,
          },
          participatingDomains: this.participatingDomains,
        },
      });

      if (result.success) {
        return result.value;
      }

      // Failed to spawn - continue without agent
      return undefined;
    } catch {
      // Error spawning agent - continue without
      return undefined;
    }
  }

  /**
   * Stop the coordinator agent after evaluation completes
   */
  private async stopCoordinatorAgent(agentId: string): Promise<void> {
    try {
      await this.agentCoordinator.stop(agentId);
    } catch {
      // Best effort cleanup - ignore errors
    }
  }
}

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

export function createQualityGateProtocol(
  eventBus: EventBus,
  memory: MemoryBackend,
  agentCoordinator: AgentCoordinator,
  config?: Partial<QualityGateProtocolConfig>
): IQualityGateProtocol {
  return new QualityGateProtocol(eventBus, memory, agentCoordinator, config);
}