# Create RAN causal inference workspace
mkdir -p ran-causal/{models,data,interventions,results}
cd ran-causal

# Initialize AgentDB for causal patterns
npx agentdb@latest init ./.agentdb/ran-causal.db --dimension 1536

# Install causal inference packages
npm init -y
npm install agentdb @tensorflow/tfjs-node
npm install causal-graph
npm install bayesian-network

import { createAgentDBAdapter, computeEmbedding } from 'agentic-flow/reasoningbank';

class RANCausalInference {
  private agentDB: AgentDBAdapter;
  private causalGraph: Map<string, Set<string>>;

  async initialize() {
    this.agentDB = await createAgentDBAdapter({
      dbPath: '.agentdb/ran-causal.db',
      enableLearning: true,
      enableReasoning: true,
      cacheSize: 1500,
    });

    this.causalGraph = new Map();
    await this.loadKnownCausalRelationships();
  }

  async discoverCausalRelationships(ranData: Array<RANObservation>) {
    // Basic causal discovery using correlation + temporal precedence
    const correlations = this.calculateCorrelations(ranData);
    const temporalRelations = this.analyzeTemporalRelations(ranData);

    // Combine evidence for causal discovery
    const causalRelations = this.inferCausality(correlations, temporalRelations);

    // Store discovered relationships
    await this.storeCausalRelationships(causalRelations);

    return causalRelations;
  }

  private calculateCorrelations(data: Array<RANObservation>): Map<string, number> {
    const correlations = new Map();
    const parameters = Object.keys(data[0]).filter(k => k !== 'timestamp');

    for (let i = 0; i < parameters.length; i++) {
      for (let j = i + 1; j < parameters.length; j++) {
        const param1 = parameters[i];
        const param2 = parameters[j];

        const correlation = this.pearsonCorrelation(
          data.map(d => d[param1]),
          data.map(d => d[param2])
        );

        correlations.set(`${param1} -> ${param2}`, Math.abs(correlation));
      }
    }

    return correlations;
  }

  private analyzeTemporalRelations(data: Array<RANObservation>): Map<string, number> {
    const temporalRelations = new Map();
    const parameters = Object.keys(data[0]).filter(k => k !== 'timestamp');

    // Sort by timestamp
    data.sort((a, b) => a.timestamp - b.timestamp);

    for (const param1 of parameters) {
      for (const param2 of parameters) {
        if (param1 === param2) continue;

        // Calculate Granger causality
        const grangerScore = this.calculateGrangerCausality(
          data.map(d => d[param1]),
          data.map(d => d[param2])
        );

        temporalRelations.set(`${param1} -> ${param2}`, grangerScore);
      }
    }

    return temporalRelations;
  }

  private inferCausality(correlations: Map<string, number>, temporal: Map<string, number>) {
    const causalRelations = [];

    for (const [relation, corr] of correlations) {
      const temporalScore = temporal.get(relation) || 0;

      // Combine correlation strength with temporal precedence
      const causalScore = corr * 0.6 + temporalScore * 0.4;

      if (causalScore > 0.3) {  // Threshold for causal relationship
        const [cause, effect] = relation.split(' -> ');
        causalRelations.push({
          cause,
          effect,
          strength: causalScore,
          evidence: {
            correlation: corr,
            temporal: temporalScore
          }
        });
      }
    }

    return causalRelations.sort((a, b) => b.strength - a.strength);
  }

  private pearsonCorrelation(x: number[], y: number[]): number {
    const n = x.length;
    const sumX = x.reduce((a, b) => a + b, 0);
    const sumY = y.reduce((a, b) => a + b, 0);
    const sumXY = x.reduce((sum, xi, i) => sum + xi * y[i], 0);
    const sumXX = x.reduce((sum, xi) => sum + xi * xi, 0);
    const sumYY = y.reduce((sum, yi) => sum + yi * yi, 0);

    const numerator = n * sumXY - sumX * sumY;
    const denominator = Math.sqrt((n * sumXX - sumX * sumX) * (n * sumYY - sumY * sumY));

    return denominator === 0 ? 0 : numerator / denominator;
  }

  private calculateGrangerCausality(cause: number[], effect: number[]): number {
    // Simplified Granger causality test
    if (cause.length < 10) return 0;

    const lag = 3; // Use 3 time steps for prediction
    let totalError = 0;
    let baselineError = 0;

    // Calculate baseline error (predicting using effect's own past)
    for (let i = lag; i < effect.length; i++) {
      const prediction = effect.slice(i - lag, i).reduce((a, b) => a + b, 0) / lag;
      baselineError += Math.pow(effect[i] - prediction, 2);
    }

    // Calculate error with cause included
    for (let i = lag; i < effect.length; i++) {
      const causeLag = cause.slice(i - lag, i).reduce((a, b) => a + b, 0) / lag;
      const effectLag = effect.slice(i - lag, i).reduce((a, b) => a + b, 0) / lag;
      const prediction = effectLag * 0.7 + causeLag * 0.3;
      totalError += Math.pow(effect[i] - prediction, 2);
    }

    // Granger causality score
    return baselineError > 0 ? (baselineError - totalError) / baselineError : 0;
  }

  async storeCausalRelationships(relationships: Array<any>) {
    for (const rel of relationships) {
      const embedding = await computeEmbedding(JSON.stringify(rel));

      await this.agentDB.insertPattern({
        id: '',
        type: 'causal-relationship',
        domain: 'ran-causal-discovery',
        pattern_data: JSON.stringify({ embedding, pattern: rel }),
        confidence: rel.strength,
        usage_count: 1,
        success_count: rel.strength > 0.5 ? 1 : 0,
        created_at: Date.now(),
        last_used: Date.now(),
      });
    }
  }
}

interface RANObservation {
  timestamp: number;
  throughput: number;
  latency: number;
  packetLoss: number;
  signalStrength: number;
  interference: number;
  handoverCount: number;
  energyConsumption: number;
  [key: string]: number;
}

class RANInterventionPredictor {
  private causalModel: Map<string, Map<string, number>>;

  constructor() {
    this.causalModel = new Map();
  }

  async predictInterventionEffect(intervention: RANIntervention, currentState: RANState): Promise<RANPrediction> {
    // Simple causal model for intervention prediction
    const effects = new Map<string, number>();

    // Apply causal rules based on intervention type
    switch (intervention.type) {
      case 'increase_power':
        effects.set('signalStrength', 0.15);
        effects.set('throughput', 0.12);
        effects.set('energyConsumption', 0.08);
        effects.set('interference', 0.05);
        break;

      case 'adjust_beamforming':
        effects.set('signalStrength', 0.20);
        effects.set('interference', -0.10);
        effects.set('throughput', 0.15);
        effects.set('latency', -0.08);
        break;

      case 'optimize_handover':
        effects.set('handoverCount', -0.20);
        effects.set('latency', -0.12);
        effects.set('packetLoss', -0.05);
        effects.set('throughput', 0.08);
        break;
    }

    // Calculate predicted state
    const predictedState: RANState = { ...currentState };

    for (const [parameter, effect] of effects) {
      if (predictedState[parameter]) {
        predictedState[parameter] *= (1 + effect);
      }
    }

    return {
      predictedState,
      confidence: this.calculatePredictionConfidence(intervention, currentState),
      causalPath: this.traceCausalPath(intervention.type, effects),
      expectedImprovement: this.calculateExpectedImprovement(currentState, predictedState)
    };
  }

  private calculatePredictionConfidence(intervention: RANIntervention, state: RANState): number {
    // Base confidence on intervention type and current state similarity
    const baseConfidence = {
      'increase_power': 0.85,
      'adjust_beamforming': 0.75,
      'optimize_handover': 0.80
    }[intervention.type] || 0.7;

    // Adjust confidence based on state conditions
    const stateFactor = this.evaluateStateConditions(intervention, state);

    return Math.min(baseConfidence * stateFactor, 0.95);
  }

  private evaluateStateConditions(intervention: RANIntervention, state: RANState): number {
    let factor = 1.0;

    switch (intervention.type) {
      case 'increase_power':
        // More effective when signal strength is low
        factor = state.signalStrength < -80 ? 1.2 : 0.9;
        break;
      case 'adjust_beamforming':
        // More effective with high interference
        factor = state.interference > 0.1 ? 1.15 : 0.85;
        break;
      case 'optimize_handover':
        // More effective with high handover count
        factor = state.handoverCount > 5 ? 1.25 : 0.8;
        break;
    }

    return factor;
  }

  private traceCausalPath(interventionType: string, effects: Map<string, number>): string[] {
    const path = [interventionType];

    // Add primary effects
    for (const [param, effect] of effects) {
      if (Math.abs(effect) > 0.1) {
        path.push(`${param} (${effect > 0 ? '+' : ''}${(effect * 100).toFixed(1)}%)`);
      }
    }

    return path;
  }

  private calculateExpectedImprovement(currentState: RANState, predictedState: RANState): number {
    // Calculate weighted improvement across key KPIs
    const weights = {
      throughput: 0.3,
      latency: 0.25,
      packetLoss: 0.2,
      energyConsumption: 0.15,
      signalStrength: 0.1
    };

    let totalImprovement = 0;

    for (const [kpi, weight] of Object.entries(weights)) {
      const current = currentState[kpi] || 0;
      const predicted = predictedState[kpi] || 0;

      let improvement = 0;
      if (kpi === 'latency' || kpi === 'packetLoss' || kpi === 'energyConsumption') {
        // Lower is better for these metrics
        improvement = (current - predicted) / current;
      } else {
        // Higher is better for these metrics
        improvement = (predicted - current) / current;
      }

      totalImprovement += improvement * weight;
    }

    return totalImprovement;
  }
}

interface RANIntervention {
  type: 'increase_power' | 'adjust_beamforming' | 'optimize_handover' | 'reduce_energy';
  parameters: Record<string, number>;
}

interface RANState {
  throughput: number;
  latency: number;
  packetLoss: number;
  signalStrength: number;
  interference: number;
  handoverCount: number;
  energyConsumption: number;
  [key: string]: number;
}

interface RANPrediction {
  predictedState: RANState;
  confidence: number;
  causalPath: string[];
  expectedImprovement: number;
}

import * as tf from '@tensorflow/tfjs-node';

class RANGPCM {
  private graphStructure: Map<string, Set<string>>;
  private posteriorNetworks: Map<string, tf.LayersModel>;
  private agentDB: AgentDBAdapter;

  async initialize() {
    this.graphStructure = new Map();
    this.posteriorNetworks = new Map();
    await this.initializeGraphStructure();
    await this.buildPosteriorNetworks();
  }

  private async initializeGraphStructure() {
    // Define RAN causal graph structure based on domain knowledge
    const edges = [
      // Physical layer effects
      ['signalStrength', 'throughput'],
      ['interference', 'throughput'],
      ['signalStrength', 'latency'],
      ['interference', 'latency'],

      // Network layer effects
      ['throughput', 'packetLoss'],
      ['latency', 'packetLoss'],
      ['handoverCount', 'latency'],
      ['handoverCount', 'packetLoss'],

      // Resource effects
      ['energyConsumption', 'signalStrength'],
      ['energyConsumption', 'throughput'],

      // Mobility effects
      ['userVelocity', 'handoverCount'],
      ['userVelocity', 'signalStrength'],

      // Capacity effects
      ['userCount', 'throughput'],
      ['userCount', 'latency'],
      ['userCount', 'interference']
    ];

    for (const [parent, child] of edges) {
      if (!this.graphStructure.has(parent)) {
        this.graphStructure.set(parent, new Set());
      }
      this.graphStructure.get(parent)!.add(child);
    }
  }

  private async buildPosteriorNetworks() {
    // Build neural network for each conditional probability
    for (const [parent, children] of this.graphStructure) {
      for (const child of children) {
        const network = this.buildPosteriorNetwork(parent, child);
        this.posteriorNetworks.set(`${parent}->${child}`, network);
      }
    }
  }

  private buildPosteriorNetwork(parent: string, child: string): tf.LayersModel {
    // Network to learn P(child | parent, context)
    const model = tf.sequential({
      layers: [
        tf.layers.dense({ inputShape: [8], units: 64, activation: 'relu' }),  // Parent + context
        tf.layers.dense({ units: 32, activation: 'relu' }),
        tf.layers.dense({ units: 16, activation: 'relu' }),
        tf.layers.dense({ units: 1, activation: 'sigmoid' })  // Child probability/value
      ]
    });

    model.compile({
      optimizer: tf.train.adam(0.001),
      loss: 'meanSquaredError',
      metrics: ['mae']
    });

    return model;
  }

  async trainGPCM(trainingData: Array<RANObservation>) {
    const trainingPairs = this.generateTrainingPairs(trainingData);

    for (const [parent, child] of trainingPairs) {
      const network = this.posteriorNetworks.get(`${parent}->${child}`);
      if (!network) continue;

      const inputs = tf.tensor2d(parent);
      const outputs = tf.tensor2d(child.map(v => [v]));

      await network.fit(inputs, outputs, {
        epochs: 50,
        batchSize: 32,
        validationSplit: 0.2,
        shuffle: true
      });

      inputs.dispose();
      outputs.dispose();

      console.log(`Trained P(${child} | ${parent})`);
    }
  }

  private generateTrainingPairs(data: Array<RANObservation>): Array<[number[], number[]]> {
    const pairs: Array<[number[], number[]]> = [];

    for (const observation of data) {
      // Generate training pairs for each causal relation
      for (const [parent, children] of this.graphStructure) {
        const parentValue = observation[parent] || 0;
        const context = this.extractContext(observation, parent);
        const input = [parentValue, ...context];

        for (const child of children) {
          const childValue = observation[child] || 0;
          pairs.push([input, [childValue]]);
        }
      }
    }

    return pairs;
  }

  private extractContext(observation: RANObservation, excludeKey: string): number[] {
    const contextParams = ['userCount', 'userVelocity', 'interference', 'energyConsumption'];
    return contextParams
      .filter(param => param !== excludeKey)
      .map(param => observation[param] || 0);
  }

  async predictInterventionEffects(
    intervention: RANIntervention,
    currentState: RANState
  ): Promise<RANCausalEffects> {
    // Apply intervention to current state
    const intervenedState = this.applyIntervention(currentState, intervention);

    // Calculate causal effects using GPCM
    const effects = await this.propagateCausalEffects(intervenedState, intervention.type);

    return {
      immediateEffects: this.calculateImmediateEffects(currentState, intervenedState),
      propagatedEffects: effects,
      totalEffects: this.calculateTotalEffects(effects),
      confidence: this.calculateCausalConfidence(intervention, currentState)
    };
  }

  private applyIntervention(state: RANState, intervention: RANIntervention): RANState {
    const newState = { ...state };

    switch (intervention.type) {
      case 'increase_power':
        newState.signalStrength *= 1.15;
        newState.energyConsumption *= 1.08;
        newState.interference *= 1.05;
        break;
      case 'adjust_beamforming':
        newState.signalStrength *= 1.20;
        newState.interference *= 0.90;
        break;
      case 'optimize_handover':
        newState.handoverCount *= 0.80;
        break;
      case 'reduce_energy':
        newState.energyConsumption *= 0.85;
        newState.signalStrength *= 0.95;
        newState.throughput *= 0.90;
        break;
    }

    return newState;
  }

  private async propagateCausalEffects(state: RANState, interventionType: string): Promise<Map<string, number>> {
    const effects = new Map<string, number>();
    const visited = new Set<string>();
    const queue: string[] = this.getDirectEffects(interventionType);

    while (queue.length > 0) {
      const parameter = queue.shift()!;
      if (visited.has(parameter)) continue;
      visited.add(parameter);

      // Get parent parameters that affect this one
      const parents = this.getParents(parameter);
      if (parents.length === 0) continue;

      // Calculate effect using posterior network
      for (const parent of parents) {
        const network = this.posteriorNetworks.get(`${parent}->${parameter}`);
        if (!network) continue;

        const context = this.extractContext(state as RANObservation, parent);
        const input = tf.tensor2d([[state[parent] || 0, ...context]]);
        const prediction = network.predict(input) as tf.Tensor;
        const predictedValue = (await prediction.data())[0];

        const current = state[parameter] || 0;
        const effect = (predictedValue - current) / current;

        effects.set(parameter, effect);

        // Add children to queue for further propagation
        const children = this.graphStructure.get(parameter);
        if (children) {
          queue.push(...children);
        }

        input.dispose();
        prediction.dispose();
      }
    }

    return effects;
  }

  private getDirectEffects(interventionType: string): string[] {
    const directEffects = {
      'increase_power': ['signalStrength', 'energyConsumption', 'interference'],
      'adjust_beamforming': ['signalStrength', 'interference'],
      'optimize_handover': ['handoverCount'],
      'reduce_energy': ['energyConsumption', 'signalStrength', 'throughput']
    }[interventionType] || [];

    return directEffects;
  }

  private getParents(parameter: string): string[] {
    const parents: string[] = [];
    for (const [parent, children] of this.graphStructure) {
      if (children.has(parameter)) {
        parents.push(parent);
      }
    }
    return parents;
  }

  private calculateImmediateEffects(currentState: RANState, intervenedState: RANState): Map<string, number> {
    const effects = new Map<string, number>();

    for (const [key, value] of Object.entries(intervenedState)) {
      const current = currentState[key] || 0;
      if (current > 0) {
        effects.set(key, (value - current) / current);
      }
    }

    return effects;
  }

  private calculateTotalEffects(propagatedEffects: Map<string, number>): Map<string, number> {
    // Combine direct and indirect effects
    const totalEffects = new Map<string, number>();

    // Add propagated effects
    for (const [parameter, effect] of propagatedEffects) {
      totalEffects.set(parameter, effect);
    }

    return totalEffects;
  }

  private calculateCausalConfidence(intervention: RANIntervention, state: RANState): number {
    // Calculate confidence based on network certainty and state conditions
    const baseConfidence = {
      'increase_power': 0.85,
      'adjust_beamforming': 0.75,
      'optimize_handover': 0.80,
      'reduce_energy': 0.70
    }[intervention.type] || 0.7;

    // Adjust based on how well the current state matches training conditions
    const stateSimilarity = this.calculateStateSimilarity(state);

    return Math.min(baseConfidence * stateSimilarity, 0.95);
  }

  private calculateStateSimilarity(state: RANState): number {
    // Simplified state similarity calculation
    // In practice, this would compare against stored patterns
    return 0.8 + Math.random() * 0.2;  // Placeholder
  }

  async discoverCausalRelationships(data: Array<RANObservation>): Promise<Array<RANCausalRelation>> {
    const relationships: Array<RANCausalRelation> = [];

    // Use GPCM to discover causal relationships
    for (const [parent, children] of this.graphStructure) {
      for (const child of children) {
        const strength = await this.calculateCausalStrength(parent, child, data);

        if (strength > 0.3) {  // Threshold for causal relationship
          relationships.push({
            parent,
            child,
            strength,
            mechanism: await this.identifyMechanism(parent, child),
            confidence: this.calculateRelationConfidence(parent, child, data)
          });
        }
      }
    }

    // Store discovered relationships in AgentDB
    await this.storeCausalRelationships(relationships);

    return relationships.sort((a, b) => b.strength - a.strength);
  }

  private async calculateCausalStrength(parent: string, child: string, data: Array<RANObservation>): Promise<number> {
    // Calculate causal strength using posterior network
    const network = this.posteriorNetworks.get(`${parent}->${child}`);
    if (!network) return 0;

    const predictions = [];
    const actuals = [];

    for (const observation of data) {
      const context = this.extractContext(observation, parent);
      const input = tf.tensor2d([[observation[parent] || 0, ...context]]);
      const prediction = network.predict(input) as tf.Tensor;
      const predictedValue = (await prediction.data())[0];

      predictions.push(predictedValue);
      actuals.push(observation[child] || 0);

      input.dispose();
      prediction.dispose();
    }

    // Calculate correlation as strength measure
    return this.pearsonCorrelation(predictions, actuals);
  }

  private async identifyMechanism(parent: string, child: string): Promise<string> {
    // Identify causal mechanism based on domain knowledge
    const mechanisms: Record<string, Record<string, string>> = {
      'signalStrength': {
        'throughput': 'Shannon capacity theorem',
        'latency': 'Modulation and coding scheme',
        'packetLoss': 'Block error rate'
      },
      'interference': {
        'throughput': 'Signal-to-interference ratio',
        'latency': 'Retransmission delays',
        'packetLoss': 'Collision probability'
      },
      'energyConsumption': {
        'signalStrength': 'Power amplifier efficiency',
        'throughput': 'Resource allocation trade-offs'
      }
    };

    return mechanisms[parent]?.[child] || 'Unknown mechanism';
  }

  private calculateRelationConfidence(parent: string, child: string, data: Array<RANObservation>): number {
    // Calculate confidence based on data consistency and sample size
    const sampleSize = data.length;
    const baseConfidence = Math.min(sampleSize / 100, 0.9);

    // Adjust for data quality
    const dataQuality = this.assessDataQuality(parent, child, data);

    return baseConfidence * dataQuality;
  }

  private assessDataQuality(parent: string, child: string, data: Array<RANObservation>): number {
    // Assess data quality based on variance, missing values, outliers
    const parentValues = data.map(d => d[parent] || 0).filter(v => v > 0);
    const childValues = data.map(d => d[child] || 0).filter(v => v > 0);

    if (parentValues.length < data.length * 0.8 || childValues.length < data.length * 0.8) {
      return 0.7;  // Missing data penalty
    }

    const parentVariance = this.calculateVariance(parentValues);
    const childVariance = this.calculateVariance(childValues);

    // Penalize very low variance (insufficient variation)
    if (parentVariance < 0.01 || childVariance < 0.01) {
      return 0.6;
    }

    return 0.9;
  }

  private calculateVariance(values: number[]): number {
    const mean = values.reduce((a, b) => a + b, 0) / values.length;
    const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
    return variance;
  }

  private async storeCausalRelationships(relationships: Array<RANCausalRelation>) {
    for (const rel of relationships) {
      const embedding = await computeEmbedding(JSON.stringify(rel));

      await this.agentDB.insertPattern({
        id: '',
        type: 'gpcm-causal-relationship',
        domain: 'ran-causal-modeling',
        pattern_data: JSON.stringify({ embedding, pattern: rel }),
        confidence: rel.confidence,
        usage_count: 1,
        success_count: rel.strength > 0.5 ? 1 : 0,
        created_at: Date.now(),
        last_used: Date.now(),
      });
    }
  }
}

interface RANCausalRelation {
  parent: string;
  child: string;
  strength: number;
  mechanism: string;
  confidence: number;
}

interface RANCausalEffects {
  immediateEffects: Map<string, number>;
  propagatedEffects: Map<string, number>;
  totalEffects: Map<string, number>;
  confidence: number;
}

class RANCounterfactualAnalysis {
  private gpcm: RANGPCM;
  private agentDB: AgentDBAdapter;

  async analyzeCounterfactual(
    currentState: RANState,
    actualOutcome: RANState,
    counterfactualIntervention: RANIntervention
  ): Promise<RANCounterfactualResult> {
    // Calculate what would have happened with different intervention
    const counterfactualState = await this.simulateCounterfactual(currentState, counterfactualIntervention);

    // Compare actual vs counterfactual
    const comparison = this.compareOutcomes(actualOutcome, counterfactualState);

    // Calculate causal attribution
    const attribution = this.calculateCausalAttribution(currentState, actualOutcome, counterfactualState);

    return {
      counterfactualState,
      comparison,
      attribution,
      confidence: this.calculateCounterfactualConfidence(currentState, counterfactualIntervention)
    };
  }

  private async simulateCounterfactual(state: RANState, intervention: RANIntervention): Promise<RANState> {
    // Use GPCM to simulate counterfactual outcome
    const effects = await this.gpcm.predictInterventionEffects(intervention, state);

    const counterfactualState = { ...state };

    // Apply both immediate and propagated effects
    for (const [parameter, effect] of effects.totalEffects) {
      if (counterfactualState[parameter]) {
        counterfactualState[parameter] *= (1 + effect);
      }
    }

    return counterfactualState;
  }

  private compareOutcomes(actual: RANState, counterfactual: RANState): RANOutcomeComparison {
    const improvements: Array<{ parameter: string, improvement: number }> = [];
    const degradations: Array<{ parameter: string, degradation: number }> = [];

    for (const [parameter, actualValue] of Object.entries(actual)) {
      const counterfactualValue = counterfactualState[parameter];
      if (!counterfactualValue) continue;

      const change = (counterfactualValue - actualValue) / actualValue;

      if (change > 0.01) {
        improvements.push({ parameter, improvement: change });
      } else if (change < -0.01) {
        degradations.push({ parameter, degradation: Math.abs(change) });
      }
    }

    return {
      improvements,
      degradations,
      overallImprovement: this.calculateOverallImprovement(actual, counterfactual),
      significantChanges: [...improvements, ...degradations].filter(c => Math.abs(c.improvement || c.degradation) > 0.05)
    };
  }

  private calculateOverallImprovement(actual: RANState, counterfactual: RANState): number {
    // Weighted overall improvement
    const weights = {
      throughput: 0.3,
      latency: -0.25,  // Negative because lower is better
      packetLoss: -0.2,
      energyConsumption: -0.15,
      signalStrength: 0.1
    };

    let totalImprovement = 0;

    for (const [parameter, weight] of Object.entries(weights)) {
      const actual = actual[parameter] || 0;
      const counterfactual = counterfactual[parameter] || 0;

      const change = (counterfactual - actual) / actual;
      totalImprovement += change * Math.abs(weight);
    }

    return totalImprovement;
  }

  private calculateCausalAttribution(
    currentState: RANState,
    actualOutcome: RANState,
    counterfactualState: RANState
  ): RANCausalAttribution {
    const attribution: RANCausalAttribution = {
      primaryCauses: [],
      secondaryCauses: [],
      causalChain: [],
      attributionStrength: 0
    };

    // Identify primary causal factors
    for (const [parameter, actualValue] of Object.entries(currentState)) {
      const actualOutcomeValue = actualOutcome[parameter];
      const counterfactualValue = counterfactualState[parameter];

      if (!actualOutcomeValue || !counterfactualValue) continue;

      const actualChange = Math.abs(actualOutcomeValue - actualValue) / actualValue;
      const counterfactualChange = Math.abs(counterfactualValue - actualValue) / actualValue;

      if (actualChange > 0.1) {
        attribution.primaryCauses.push({
          parameter,
          contribution: actualChange,
          actualImpact: actualChange,
          counterfactualImpact: counterfactualChange
        });
      }
    }

    // Sort by contribution
    attribution.primaryCauses.sort((a, b) => b.contribution - a.contribution);

    // Calculate overall attribution strength
    attribution.attributionStrength = attribution.primaryCauses.reduce((sum, cause) => sum + cause.contribution, 0);

    return attribution;
  }

  private calculateCounterfactualConfidence(state: RANState, intervention: RANIntervention): number {
    // Confidence based on state similarity and intervention type
    const baseConfidence = {
      'increase_power': 0.80,
      'adjust_beamforming': 0.75,
      'optimize_handover': 0.85,
      'reduce_energy': 0.70
    }[intervention.type] || 0.7;

    // Adjust based on how typical the state is
    const stateTypicality = this.assessStateTypicality(state);

    return baseConfidence * stateTypicality;
  }

  private assessStateTypicality(state: RANState): number {
    // Simplified typicality assessment
    // In practice, would compare against historical distribution
    return 0.8 + Math.random() * 0.2;
  }

  async generateCausalExplainability(
    currentState: RANState,
    intervention: RANIntervention,
    predictedOutcome: RANState
  ): Promise<RANCausalExplanation> {
    const explanation: RANCausalExplanation = {
      intervention: intervention.type,
      causalChain: [],
      keyDrivers: [],
      expectedImpacts: [],
      confidenceFactors: [],
      alternatives: []
    };

    // Build causal chain
    explanation.causalChain = await this.buildCausalChain(currentState, intervention, predictedOutcome);

    // Identify key drivers
    explanation.keyDrivers = this.identifyKeyDrivers(currentState, intervention);

    // Expected impacts on key KPIs
    explanation.expectedImpacts = this.calculateExpectedImpacts(currentState, predictedOutcome);

    // Confidence factors
    explanation.confidenceFactors = this.identifyConfidenceFactors(currentState, intervention);

    // Alternative interventions
    explanation.alternatives = await this.generateAlternatives(currentState, intervention);

    return explanation;
  }

  private async buildCausalChain(
    state: RANState,
    intervention: RANIntervention,
    outcome: RANState
  ): Promise<Array<RANCausalStep>> {
    const chain: Array<RANCausalStep> = [];

    // Initial intervention step
    chain.push({
      step: 1,
      description: `Apply ${intervention.type} intervention`,
      parameters: intervention.parameters,
      immediateEffects: this.getImmediateEffects(intervention.type)
    });

    // Propagation steps
    let currentEffects = this.getImmediateEffects(intervention.type);
    let step = 2;

    while (currentEffects.length > 0 && step <= 5) {
      const nextEffects: Array<string> = [];

      for (const effect of currentEffects) {
        const downstreamEffects = this.getDownstreamEffects(effect);
        if (downstreamEffects.length > 0) {
          chain.push({
            step,
            description: `${effect} affects ${downstreamEffects.join(', ')}`,
            parameters: { [effect]: state[effect] },
            immediateEffects: downstreamEffects
          });
          nextEffects.push(...downstreamEffects);
        }
      }

      currentEffects = nextEffects;
      step++;
    }

    return chain;
  }

  private getImmediateEffects(interventionType: string): string[] {
    return {
      'increase_power': ['signalStrength', 'energyConsumption', 'interference'],
      'adjust_beamforming': ['signalStrength', 'interference'],
      'optimize_handover': ['handoverCount', 'latency'],
      'reduce_energy': ['energyConsumption', 'signalStrength', 'throughput']
    }[interventionType] || [];
  }

  private getDownstreamEffects(parameter: string): string[] {
    const downstream: Record<string, string[]> = {
      'signalStrength': ['throughput', 'latency', 'packetLoss'],
      'interference': ['throughput', 'latency', 'packetLoss'],
      'handoverCount': ['latency', 'packetLoss'],
      'energyConsumption': ['signalStrength', 'throughput'],
      'throughput': ['packetLoss'],
      'latency': ['packetLoss']
    };

    return downstream[parameter] || [];
  }

  private identifyKeyDrivers(state: RANState, intervention: RANIntervention): Array<RANKeyDriver> {
    const drivers: Array<RANKeyDriver> = [];

    // Analyze current state to identify key drivers
    const issues: Array<{ parameter: string, severity: number }> = [];

    if (state.signalStrength < -85) issues.push({ parameter: 'signalStrength', severity: 0.9 });
    if (state.latency > 50) issues.push({ parameter: 'latency', severity: 0.8 });
    if (state.packetLoss > 0.05) issues.push({ parameter: 'packetLoss', severity: 0.85 });
    if (state.interference > 0.15) issues.push({ parameter: 'interference', severity: 0.7 });
    if (state.energyConsumption > 100) issues.push({ parameter: 'energyConsumption', severity: 0.6 });

    for (const issue of issues) {
      drivers.push({
        parameter: issue.parameter,
        currentValue: state[issue.parameter],
        targetValue: this.getTargetValue(issue.parameter),
        severity: issue.severity,
        intervention: this.recommendIntervention(issue.parameter, intervention.type)
      });
    }

    return drivers.sort((a, b) => b.severity - a.severity);
  }

  private getTargetValue(parameter: string): number {
    const targets: Record<string, number> = {
      'signalStrength': -70,
      'latency': 20,
      'packetLoss': 0.01,
      'interference': 0.05,
      'energyConsumption': 60
    };

    return targets[parameter] || 0;
  }

  private recommendIntervention(issueParameter: string, currentIntervention: string): string {
    const recommendations: Record<string, Record<string, string>> = {
      'signalStrength': {
        'increase_power': 'Complementary effect',
        'adjust_beamforming': 'Primary solution',
        'reduce_energy': 'May worsen issue'
      },
      'latency': {
        'optimize_handover': 'Primary solution',
        'adjust_beamforming': 'Secondary benefit',
        'increase_power': 'Minor effect'
      },
      'packetLoss': {
        'adjust_beamforming': 'Primary solution',
        'increase_power': 'Secondary benefit',
        'optimize_handover': 'Minor effect'
      }
    };

    return recommendations[issueParameter]?.[currentIntervention] || 'Unknown effect';
  }

  private calculateExpectedImpacts(currentState: RANState, predictedState: RANState): Array<RANExpectedImpact> {
    const impacts: Array<RANExpectedImpact> = [];

    for (const [kpi, currentValue] of Object.entries(currentState)) {
      const predictedValue = predictedState[kpi];
      if (!predictedValue) continue;

      const change = (predictedValue - currentValue) / currentValue;
      const impact = this.classifyImpact(kpi, change);

      if (impact !== 'neutral') {
        impacts.push({
          kpi,
          currentValue,
          predictedValue,
          changePercent: change * 100,
          impact,
          importance: this.getKPIImportance(kpi)
        });
      }
    }

    return impacts.sort((a, b) => b.importance - a.importance);
  }

  private classifyImpact(kpi: string, change: number): 'positive' | 'negative' | 'neutral' {
    const isLowerBetter = ['latency', 'packetLoss', 'energyConsumption', 'handoverCount'].includes(kpi);

    if (isLowerBetter) {
      return change < -0.02 ? 'positive' : change > 0.02 ? 'negative' : 'neutral';
    } else {
      return change > 0.02 ? 'positive' : change < -0.02 ? 'negative' : 'neutral';
    }
  }

  private getKPIImportance(kpi: string): number {
    const importance: Record<string, number> = {
      'throughput': 0.9,
      'latency': 0.85,
      'packetLoss': 0.8,
      'signalStrength': 0.75,
      'energyConsumption': 0.6,
      'handoverCount': 0.5,
      'interference': 0.7
    };

    return importance[kpi] || 0.5;
  }

  private identifyConfidenceFactors(state: RANState, intervention: RANIntervention): Array<RANConfidenceFactor> {
    const factors: Array<RANConfidenceFactor> = [];

    // Data quality factors
    factors.push({
      factor: 'Data completeness',
      value: this.assessDataCompleteness(state),
      impact: 'high'
    });

    // State condition factors
    factors.push({
      factor: 'State typicality',
      value: this.assessStateTypicality(state),
      impact: 'medium'
    });

    // Intervention complexity
    factors.push({
      factor: 'Intervention complexity',
      value: this.assessInterventionComplexity(intervention),
      impact: 'medium'
    });

    // Historical performance
    factors.push({
      factor: 'Historical success rate',
      value: this.getHistoricalSuccessRate(intervention.type),
      impact: 'high'
    });

    return factors;
  }

  private assessDataCompleteness(state: RANState): number {
    const validParams = Object.values(state).filter(v => v !== undefined && v !== null && v > 0).length;
    return validParams / Object.keys(state).length;
  }

  private assessInterventionComplexity(intervention: RANIntervention): number {
    const complexity: Record<string, number> = {
      'increase_power': 0.9,
      'adjust_beamforming': 0.7,
      'optimize_handover': 0.8,
      'reduce_energy': 0.6
    };

    return complexity[intervention.type] || 0.7;
  }

  private getHistoricalSuccessRate(interventionType: string): number {
    // Would retrieve from AgentDB in practice
    const rates: Record<string, number> = {
      'increase_power': 0.85,
      'adjust_beamforming': 0.78,
      'optimize_handover': 0.82,
      'reduce_energy': 0.75
    };

    return rates[interventionType] || 0.8;
  }

  private async generateAlternatives(state: RANState, currentIntervention: RANIntervention): Promise<Array<RANAlternativeIntervention>> {
    const alternatives: Array<RANAlternativeIntervention> = [];

    // Generate alternative interventions
    const alternativeTypes = ['increase_power', 'adjust_beamforming', 'optimize_handover', 'reduce_energy']
      .filter(type => type !== currentIntervention.type);

    for (const type of alternativeTypes) {
      const altIntervention: RANIntervention = { type, parameters: {} };
      const predictedOutcome = await this.simulateCounterfactual(state, altIntervention);
      const improvement = this.calculateOverallImprovement(state, predictedOutcome);

      alternatives.push({
        intervention: altIntervention,
        expectedImprovement: improvement,
        confidence: this.calculateCounterfactualConfidence(state, altIntervention),
        risks: this.assessInterventionRisks(altIntervention),
        suitability: this.assessSuitability(state, altIntervention)
      });
    }

    return alternatives.sort((a, b) => b.expectedImprovement * b.confidence - a.expectedImprovement * a.confidence);
  }

  private assessInterventionRisks(intervention: RANIntervention): string[] {
    const risks: Record<string, string[]> = {
      'increase_power': ['Increased energy consumption', 'Higher interference', 'Regulatory limits'],
      'adjust_beamforming': ['Complex implementation', 'User tracking requirements', 'CSI accuracy'],
      'optimize_handover': ['Handover failure risk', 'Service interruption', 'Complex parameter tuning'],
      'reduce_energy': ['Performance degradation', 'Coverage reduction', 'User experience impact']
    };

    return risks[intervention.type] || ['Unknown risks'];
  }

  private assessSuitability(state: RANState, intervention: RANIntervention): number {
    let suitability = 0.5;

    switch (intervention.type) {
      case 'increase_power':
        suitability = state.signalStrength < -80 ? 0.9 : 0.4;
        break;
      case 'adjust_beamforming':
        suitability = state.interference > 0.1 ? 0.85 : 0.5;
        break;
      case 'optimize_handover':
        suitability = state.handoverCount > 5 ? 0.9 : 0.3;
        break;
      case 'reduce_energy':
        suitability = state.energyConsumption > 100 ? 0.8 : 0.4;
        break;
    }

    return suitability;
  }
}

interface RANCounterfactualResult {
  counterfactualState: RANState;
  comparison: RANOutcomeComparison;
  attribution: RANCausalAttribution;
  confidence: number;
}

interface RANOutcomeComparison {
  improvements: Array<{ parameter: string, improvement: number }>;
  degradations: Array<{ parameter: string, degradation: number }>;
  overallImprovement: number;
  significantChanges: Array<{ parameter: string, improvement?: number, degradation?: number }>;
}

interface RANCausalAttribution {
  primaryCauses: Array<{
    parameter: string;
    contribution: number;
    actualImpact: number;
    counterfactualImpact: number;
  }>;
  secondaryCauses: Array<{
    parameter: string;
    contribution: number;
  }>;
  causalChain: string[];
  attributionStrength: number;
}

interface RANCausalExplanation {
  intervention: string;
  causalChain: Array<RANCausalStep>;
  keyDrivers: Array<RANKeyDriver>;
  expectedImpacts: Array<RANExpectedImpact>;
  confidenceFactors: Array<RANConfidenceFactor>;
  alternatives: Array<RANAlternativeIntervention>;
}

interface RANCausalStep {
  step: number;
  description: string;
  parameters: Record<string, number>;
  immediateEffects: string[];
}

interface RANKeyDriver {
  parameter: string;
  currentValue: number;
  targetValue: number;
  severity: number;
  intervention: string;
}

interface RANExpectedImpact {
  kpi: string;
  currentValue: number;
  predictedValue: number;
  changePercent: number;
  impact: 'positive' | 'negative' | 'neutral';
  importance: number;
}

interface RANConfidenceFactor {
  factor: string;
  value: number;
  impact: 'low' | 'medium' | 'high';
}

interface RANAlternativeIntervention {
  intervention: RANIntervention;
  expectedImprovement: number;
  confidence: number;
  risks: string[];
  suitability: number;
}

class ProductionRANCausalSystem {
  private gpcm: RANGPCM;
  private counterfactual: RANCounterfactualAnalysis;
  private agentDB: AgentDBAdapter;
  private optimizationHistory: Array<RANCausalOptimizationRecord>;

  async initialize() {
    await Promise.all([
      this.gpcm.initialize(),
      this.counterfactual.initialize()
    ]);

    this.optimizationHistory = [];
    await this.loadHistoricalData();

    console.log('RAN Causal System initialized');
  }

  async runCausalOptimization(currentState: RANState): Promise<RANCausalOptimizationResult> {
    const startTime = Date.now();
    const optimizationId = this.generateOptimizationId();

    try {
      // Step 1: Causal Discovery - Update causal model with latest data
      await this.updateCausalModel(currentState);

      // Step 2: Generate intervention candidates
      const candidates = await this.generateInterventionCandidates(currentState);

      // Step 3: Predict outcomes for each candidate
      const predictions = await Promise.all(
        candidates.map(async (candidate) => ({
          intervention: candidate,
          prediction: await this.gpcm.predictInterventionEffects(candidate, currentState),
          explanation: await this.counterfactual.generateCausalExplainability(
            currentState,
            candidate,
            await this.predictOutcome(currentState, candidate)
          )
        }))
      );

      // Step 4: Select best intervention using causal reasoning
      const selectedIntervention = await this.selectBestIntervention(predictions, currentState);

      // Step 5: Execute intervention (simulated)
      const actualOutcome = await this.executeIntervention(currentState, selectedIntervention.intervention);

      // Step 6: Update causal model with actual results
      await this.updateModelWithResults(currentState, selectedIntervention.intervention, actualOutcome);

      // Step 7: Generate comprehensive report
      const report = await this.generateCausalReport(
        currentState,
        selectedIntervention,
        actualOutcome,
        predictions
      );

      const result: RANCausalOptimizationResult = {
        optimizationId,
        currentState,
        selectedIntervention: selectedIntervention.intervention,
        actualOutcome,
        causalExplanation: selectedIntervention.explanation,
        alternativePredictions: predictions,
        performanceMetrics: {
          executionTime: Date.now() - startTime,
          causalAccuracy: this.calculateCausalAccuracy(selectedIntervention, actualOutcome),
          improvement: this.calculateImprovement(currentState, actualOutcome),
          confidence: selectedIntervention.prediction.confidence
        },
        report,
        timestamp: Date.now()
      };

      // Store optimization record
      await this.storeOptimizationRecord(result);

      return result;

    } catch (error) {
      console.error('RAN causal optimization failed:', error);
      return this.generateFallbackResult(currentState, optimizationId, startTime);
    }
  }

  private async updateCausalModel(currentState: RANState) {
    // Retrieve recent observations to update causal model
    const recentData = await this.getRecentRANData(100); // Last 100 observations

    if (recentData.length > 50) {
      await this.gpcm.trainGPCM(recentData);

      // Discover new causal relationships
      const newRelationships = await this.gpcm.discoverCausalRelationships(recentData);

      if (newRelationships.length > 0) {
        console.log(`Discovered ${newRelationships.length} new causal relationships`);
      }
    }
  }

  private async generateInterventionCandidates(state: RANState): Promise<Array<RANIntervention>> {
    const candidates: Array<RANIntervention> = [];

    // Standard interventions
    const baseInterventions: Array<{ type: RANIntervention['type'], priority: number }> = [
      { type: 'increase_power', priority: this.calculateInterventionPriority(state, 'increase_power') },
      { type: 'adjust_beamforming', priority: this.calculateInterventionPriority(state, 'adjust_beamforming') },
      { type: 'optimize_handover', priority: this.calculateInterventionPriority(state, 'optimize_handover') },
      { type: 'reduce_energy', priority: this.calculateInterventionPriority(state, 'reduce_energy') }
    ];

    // Sort by priority and create interventions
    baseInterventions.sort((a, b) => b.priority - a.priority);

    for (const baseIntervention of baseInterventions) {
      const intervention: RANIntervention = {
        type: baseIntervention.type,
        parameters: this.calculateInterventionParameters(state, baseIntervention.type)
      };

      candidates.push(intervention);
    }

    return candidates;
  }

  private calculateInterventionPriority(state: RANState, interventionType: string): number {
    let priority = 0.5;

    switch (interventionType) {
      case 'increase_power':
        priority = state.signalStrength < -80 ? 0.9 :
                   state.throughput < 500 ? 0.7 : 0.3;
        break;
      case 'adjust_beamforming':
        priority = state.interference > 0.15 ? 0.9 :
                   state.signalStrength < -75 && state.signalStrength > -85 ? 0.7 : 0.4;
        break;
      case 'optimize_handover':
        priority = state.handoverCount > 8 ? 0.9 :
                   state.latency > 60 ? 0.7 : 0.3;
        break;
      case 'reduce_energy':
        priority = state.energyConsumption > 120 ? 0.8 :
                   state.signalStrength > -70 ? 0.6 : 0.2;
        break;
    }

    return priority;
  }

  private calculateInterventionParameters(state: RANState, interventionType: string): Record<string, number> {
    const parameters: Record<string, number> = {};

    switch (interventionType) {
      case 'increase_power':
        parameters.powerIncrease = Math.min(((-80 - state.signalStrength) / 20) * 3, 6); // Max 6dB
        parameters.duration = 300; // 5 minutes
        break;
      case 'adjust_beamforming':
        parameters.beamWidth = Math.max(15, 30 - state.interference * 100); // Narrower for high interference
        parameters.azimuthAdjustment = this.calculateOptimalAzimuth(state);
        break;
      case 'optimize_handover':
        parameters.hysteresisAdjustment = state.handoverCount > 8 ? 2 : -1;
        parameters.timeToTriggerAdjustment = state.latency > 50 ? -100 : 50;
        break;
      case 'reduce_energy':
        parameters.powerReduction = Math.min((state.energyConsumption - 80) / 20, 4); // Max 4dB
        parameters.resourceSavings = 0.2; // 20% resource reduction
        break;
    }

    return parameters;
  }

  private calculateOptimalAzimuth(state: RANState): number {
    // Simplified azimuth calculation based on interference patterns
    return state.interference > 0.1 ? -15 : 0; // Adjust 15 degrees if high interference
  }

  private async predictOutcome(state: RANState, intervention: RANIntervention): Promise<RANState> {
    const effects = await this.gpcm.predictInterventionEffects(intervention, state);
    const predictedState = { ...state };

    // Apply predicted effects
    for (const [parameter, effect] of effects.totalEffects) {
      if (predictedState[parameter]) {
        predictedState[parameter] *= (1 + effect);
      }
    }

    return predictedState;
  }

  private async selectBestIntervention(
    predictions: Array<any>,
    currentState: RANState
  ): Promise<any> {
    // Score each intervention based on multiple factors
    const scoredPredictions = predictions.map(pred => ({
      ...pred,
      score: this.calculateInterventionScore(pred, currentState)
    }));

    // Sort by score and return best
    scoredPredictions.sort((a, b) => b.score - a.score);

    return scoredPredictions[0];
  }

  private calculateInterventionScore(prediction: any, currentState: RANState): number {
    const weights = {
      improvement: 0.4,
      confidence: 0.25,
      risk: 0.15,
      energyImpact: 0.1,
      complexity: 0.1
    };

    // Normalize improvement to 0-1 range
    const improvementScore = Math.min(Math.max(prediction.prediction.totalEffects.get('improvement') || 0, 0), 1);

    // Confidence is already 0-1
    const confidenceScore = prediction.prediction.confidence;

    // Risk assessment (lower risk = higher score)
    const riskScore = this.assessInterventionRisk(prediction.intervention);

    // Energy impact (favor energy reduction)
    const energyEffect = prediction.prediction.totalEffects.get('energyConsumption') || 0;
    const energyScore = energyEffect < 0 ? Math.min(Math.abs(energyEffect), 1) : 0;

    // Complexity (lower complexity = higher score)
    const complexityScore = this.assessComplexity(prediction.intervention);

    const totalScore =
      improvementScore * weights.improvement +
      confidenceScore * weights.confidence +
      riskScore * weights.risk +
      energyScore * weights.energyImpact +
      complexityScore * weights.complexity;

    return totalScore;
  }

  private assessInterventionRisk(intervention: RANIntervention): number {
    const riskScores: Record<string, number> = {
      'increase_power': 0.6,  // Medium risk (interference, energy)
      'adjust_beamforming': 0.8,  // Low risk
      'optimize_handover': 0.7,  // Low-medium risk
      'reduce_energy': 0.5  // Higher risk (performance impact)
    };

    return riskScores[intervention.type] || 0.7;
  }

  private assessComplexity(intervention: RANIntervention): number {
    const complexityScores: Record<string, number> = {
      'increase_power': 0.9,  // Simple
      'adjust_beamforming': 0.7,  // Moderate
      'optimize_handover': 0.6,  // Complex
      'reduce_energy': 0.8  // Simple-moderate
    };

    return complexityScores[intervention.type] || 0.7;
  }

  private async executeIntervention(state: RANState, intervention: RANIntervention): Promise<RANState> {
    // Simulate intervention execution
    const effects = await this.gpcm.predictInterventionEffects(intervention, state);
    const newState = { ...state };

    // Apply effects with some randomness to simulate real-world variability
    for (const [parameter, effect] of effects.totalEffects) {
      if (newState[parameter]) {
        const variability = 0.1; // 10% variability
        const randomFactor = 1 + (Math.random() - 0.5) * variability;
        newState[parameter] *= (1 + effect * randomFactor);
      }
    }

    return newState;
  }

  private async updateModelWithResults(
    currentState: RANState,
    intervention: RANIntervention,
    actualOutcome: RANState
  ) {
    // Store observation for future model training
    const observation: RANObservation = {
      timestamp: Date.now(),
      ...actualOutcome,
      interventionType: intervention.type,
      interventionParameters: JSON.stringify(intervention.parameters)
    };

    const embedding = await computeEmbedding(JSON.stringify(observation));

    await this.agentDB.insertPattern({
      id: '',
      type: 'ran-intervention-result',
      domain: 'ran-causal-learning',
      pattern_data: JSON.stringify({ embedding, pattern: observation }),
      confidence: this.calculateOutcomeConfidence(currentState, actualOutcome),
      usage_count: 1,
      success_count: this.calculateImprovement(currentState, actualOutcome) > 0.05 ? 1 : 0,
      created_at: Date.now(),
      last_used: Date.now(),
    });
  }

  private calculateOutcomeConfidence(currentState: RANState, actualOutcome: RANState): number {
    // Confidence based on consistency and expected behavior
    const improvement = this.calculateImprovement(currentState, actualOutcome);
    const baseConfidence = 0.8;

    // Adjust confidence based on whether results are reasonable
    const reasonableResults = improvement > -0.2 && improvement < 0.5; // Within reasonable bounds
    const adjustmentFactor = reasonableResults ? 1.0 : 0.7;

    return Math.min(baseConfidence * adjustmentFactor, 0.95);
  }

  private calculateImprovement(currentState: RANState, actualOutcome: RANState): number {
    // Weighted improvement calculation
    const weights = {
      throughput: 0.3,
      latency: -0.25,
      packetLoss: -0.2,
      energyConsumption: -0.15,
      signalStrength: 0.1
    };

    let totalImprovement = 0;

    for (const [kpi, weight] of Object.entries(weights)) {
      const current = currentState[kpi] || 0;
      const actual = actualOutcome[kpi] || 0;

      if (current > 0) {
        const change = (actual - current) / current;
        totalImprovement += change * Math.abs(weight);
      }
    }

    return totalImprovement;
  }

  private calculateCausalAccuracy(selectedIntervention: any, actualOutcome: RANState): number {
    // Compare predicted vs actual outcomes
    const predictedEffects = selectedIntervention.prediction.totalEffects;
    let accuracySum = 0;
    let effectCount = 0;

    for (const [parameter, predictedEffect] of predictedEffects) {
      if (actualOutcome[parameter] && selectedIntervention.currentState[parameter]) {
        const actualChange = (actualOutcome[parameter] - selectedIntervention.currentState[parameter]) / selectedIntervention.currentState[parameter];
        const accuracy = 1 - Math.abs(predictedEffect - actualChange);
        accuracySum += Math.max(0, accuracy);
        effectCount++;
      }
    }

    return effectCount > 0 ? accuracySum / effectCount : 0.5;
  }

  private async generateCausalReport(
    currentState: RANState,
    selectedIntervention: any,
    actualOutcome: RANState,
    allPredictions: Array<any>
  ): Promise<string> {
    const improvement = this.calculateImprovement(currentState, actualOutcome);
    const causalAccuracy = this.calculateCausalAccuracy(selectedIntervention, actualOutcome);

    const report = `
RAN Causal Optimization Report
==============================

Optimization ID: ${this.generateOptimizationId()}
Timestamp: ${new Date().toISOString()}

Current State:
- Throughput: ${currentState.throughput.toFixed(1)} Mbps
- Latency: ${currentState.latency.toFixed(1)} ms
- Packet Loss: ${(currentState.packetLoss * 100).toFixed(2)}%
- Signal Strength: ${currentState.signalStrength.toFixed(1)} dBm
- Energy Consumption: ${currentState.energyConsumption.toFixed(1)} W
- Handover Count: ${currentState.handoverCount}

Selected Intervention: ${selectedIntervention.intervention.type}
Parameters: ${JSON.stringify(selectedIntervention.intervention.parameters, null, 2)}

Causal Explanation:
${selectedIntervention.explanation.causalChain.map(step => `  ${step.step}. ${step.description}`).join('\n')}

Expected Impacts:
${selectedIntervention.explanation.expectedImpacts.map(impact =>
  `  ${impact.kpi}: ${impact.changePercent > 0 ? '+' : ''}${impact.changePercent.toFixed(1)}% (${impact.impact})`
).join('\n')}

Actual Outcome:
- Throughput: ${actualOutcome.throughput.toFixed(1)} Mbps
- Latency: ${actualOutcome.latency.toFixed(1)} ms
- Packet Loss: ${(actualOutcome.packetLoss * 100).toFixed(2)}%
- Signal Strength: ${actualOutcome.signalStrength.toFixed(1)} dBm
- Energy Consumption: ${actualOutcome.energyConsumption.toFixed(1)} W

Performance Metrics:
- Overall Improvement: ${(improvement * 100).toFixed(1)}%
- Causal Accuracy: ${(causalAccuracy * 100).toFixed(1)}%
- Execution Time: ${selectedIntervention.performanceMetrics?.executionTime || 0}ms
- Confidence: ${(selectedIntervention.prediction.confidence * 100).toFixed(1)}%

Key Drivers Identified:
${selectedIntervention.explanation.keyDrivers.map(driver =>
  `  ${driver.parameter}: ${driver.currentValue.toFixed(2)} → ${driver.targetValue.toFixed(2)} (Severity: ${(driver.severity * 100).toFixed(0)}%)`
).join('\n')}

Alternative Interventions Considered:
${allPredictions.filter(p => p.intervention.type !== selectedIntervention.intervention.type).map(pred =>
  `  ${pred.intervention.type}: ${(pred.prediction.totalEffects.get('improvement') || 0 * 100).toFixed(1)}% improvement, ${((pred.prediction.confidence || 0) * 100).toFixed(1)}% confidence`
).join('\n')}

Recommendations:
1. ${improvement > 0.05 ? 'Continue with current intervention strategy' : 'Consider alternative approaches'}
2. ${causalAccuracy > 0.8 ? 'Causal model predictions are accurate' : 'Refine causal model with more data'}
3. ${selectedIntervention.explanation.confidenceFactors.some(f => f.value < 0.7) ? 'Address confidence factors' : 'High confidence in predictions'}
4. Monitor key drivers: ${selectedIntervention.explanation.keyDrivers.slice(0, 3).map(d => d.parameter).join(', ')}

Next Optimization Cycle: ${new Date(Date.now() + 15 * 60 * 1000).toISOString()}
    `.trim();

    return report;
  }

  private async storeOptimizationRecord(result: RANCausalOptimizationResult) {
    const record: RANCausalOptimizationRecord = {
      optimizationId: result.optimizationId,
      timestamp: result.timestamp,
      currentState: result.currentState,
      intervention: result.selectedIntervention,
      outcome: result.actualOutcome,
      improvement: result.performanceMetrics.improvement,
      causalAccuracy: result.performanceMetrics.causalAccuracy,
      confidence: result.performanceMetrics.confidence,
      executionTime: result.performanceMetrics.executionTime
    };

    const embedding = await computeEmbedding(JSON.stringify(record));

    await this.agentDB.insertPattern({
      id: '',
      type: 'ran-causal-optimization',
      domain: 'ran-causal-production',
      pattern_data: JSON.stringify({ embedding, pattern: record }),
      confidence: result.performanceMetrics.confidence,
      usage_count: 1,
      success_count: result.performanceMetrics.improvement > 0.05 ? 1 : 0,
      created_at: Date.now(),
      last_used: Date.now(),
    });

    this.optimizationHistory.push(record);

    // Keep only last 1000 records in memory
    if (this.optimizationHistory.length > 1000) {
      this.optimizationHistory = this.optimizationHistory.slice(-1000);
    }
  }

  private generateOptimizationId(): string {
    return `ran-causal-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  }

  private async getRecentRANData(limit: number): Promise<Array<RANObservation>> {
    // Retrieve recent RAN observations from AgentDB
    const embedding = await computeEmbedding('ran-observation');
    const results = await this.agentDB.retrieveWithReasoning(embedding, {
      domain: 'ran-causal-learning',
      k: limit,
      filters: { timestamp: { $gte: Date.now() - 24 * 3600000 } }  // Last 24 hours
    });

    return results.memories.map(m => m.pattern);
  }

  private async loadHistoricalData() {
    // Load historical optimization records
    const embedding = await computeEmbedding('ran-causal-optimization');
    const results = await this.agentDB.retrieveWithReasoning(embedding, {
      domain: 'ran-causal-production',
      k: 1000
    });

    this.optimizationHistory = results.memories.map(m => m.pattern);
  }

  private generateFallbackResult(state: RANState, optimizationId: string, startTime: number): RANCausalOptimizationResult {
    return {
      optimizationId,
      currentState: state,
      selectedIntervention: { type: 'no_action', parameters: {} },
      actualOutcome: state,
      causalExplanation: null,
      alternativePredictions: [],
      performanceMetrics: {
        executionTime: Date.now() - startTime,
        causalAccuracy: 0,
        improvement: 0,
        confidence: 0.1
      },
      report: 'RAN Causal optimization failed - fallback to no action',
      timestamp: Date.now()
    };
  }

  async generateCausalInsightsReport(): Promise<string> {
    if (this.optimizationHistory.length === 0) {
      return 'No historical data available for causal insights';
    }

    const recent = this.optimizationHistory.slice(-100); // Last 100 optimizations

    const totalOptimizations = recent.length;
    const successfulOptimizations = recent.filter(r => r.improvement > 0.05).length;
    const successRate = successfulOptimizations / totalOptimizations;

    const avgImprovement = recent.reduce((sum, r) => sum + r.improvement, 0) / recent.length;
    const avgCausalAccuracy = recent.reduce((sum, r) => sum + r.causalAccuracy, 0) / recent.length;
    const avgConfidence = recent.reduce((sum, r) => sum + r.confidence, 0) / recent.length;

    // Most effective interventions
    const interventionEffectiveness = this.calculateInterventionEffectiveness(recent);

    // Causal relationship insights
    const causalInsights = await this.analyzeCausalInsights(recent);

    return `
RAN Causal System Insights Report
=================================

Analysis Period: Last ${totalOptimizations} optimizations
Generated: ${new Date().toISOString()}

Performance Summary:
- Success Rate: ${(successRate * 100).toFixed(1)}%
- Average Improvement: ${(avgImprovement * 100).toFixed(1)}%
- Average Causal Accuracy: ${(avgCausalAccuracy * 100).toFixed(1)}%
- Average Confidence: ${(avgConfidence * 100).toFixed(1)}%

Intervention Effectiveness:
${Object.entries(interventionEffectiveness).map(([type, stats]) =>
  `  ${type}: ${(stats.successRate * 100).toFixed(1)}% success, ${(stats.avgImprovement * 100).toFixed(1)}% avg improvement`
).join('\n')}

Key Causal Insights:
${causalInsights.map(insight => `  • ${insight}`).join('\n')}

Temporal Patterns:
${this.analyzeTemporalPatterns(recent).map(pattern => `  • ${pattern}`).join('\n')}

Performance Trends:
${this.analyzePerformanceTrends(recent).map(trend => `  • ${trend}`).join('\n')}

Recommendations:
${this.generateSystemRecommendations(recent, interventionEffectiveness).map(rec => `  ${rec}`).join('\n')}

Model Health:
${this.assessModelHealth()}

Next Steps:
1. ${successRate < 0.7 ? 'Investigate low success rate causes' : 'Maintain current performance'}
2. ${avgCausalAccuracy < 0.8 ? 'Improve causal model accuracy' : 'Causal model performing well'}
3. ${avgConfidence < 0.75 ? 'Address confidence factors' : 'Confidence levels are good'}
4. Continue monitoring and learning from optimization cycles
    `.trim();
  }

  private calculateInterventionEffectiveness(records: Array<RANCausalOptimizationRecord>): Record<string, any> {
    const effectiveness: Record<string, { count: number, successCount: number, totalImprovement: number, successRate: number, avgImprovement: number }> = {};

    for (const record of records) {
      const type = record.intervention.type;
      if (!effectiveness[type]) {
        effectiveness[type] = { count: 0, successCount: 0, totalImprovement: 0, successRate: 0, avgImprovement: 0 };
      }

      effectiveness[type].count++;
      effectiveness[type].totalImprovement += record.improvement;
      if (record.improvement > 0.05) {
        effectiveness[type].successCount++;
      }
    }

    // Calculate rates
    for (const stats of Object.values(effectiveness)) {
      stats.successRate = stats.successCount / stats.count;
      stats.avgImprovement = stats.totalImprovement / stats.count;
    }

    return effectiveness;
  }

  private async analyzeCausalInsights(records: Array<RANCausalOptimizationRecord>): Promise<string[]> {
    const insights: string[] = [];

    // Analyze most successful intervention types
    const effectiveness = this.calculateInterventionEffectiveness(records);
    const mostEffective = Object.entries(effectiveness)
      .sort(([,a], [,b]) => b.successRate - a.successRate)[0];

    if (mostEffective) {
      insights.push(`${mostEffective[0]} shows highest success rate (${(mostEffective[1].successRate * 100).toFixed(1)}%)`);
    }

    // Analyze confidence vs accuracy correlation
    const highConfidenceRecords = records.filter(r => r.confidence > 0.8);
    if (highConfidenceRecords.length > 10) {
      const avgAccuracyHigh = highConfidenceRecords.reduce((sum, r) => sum + r.causalAccuracy, 0) / highConfidenceRecords.length;
      insights.push(`High confidence predictions show ${(avgAccuracyHigh * 100).toFixed(1)}% average causal accuracy`);
    }

    // Analyze improvement patterns
    const significantImprovements = records.filter(r => r.improvement > 0.1);
    if (significantImprovements.length > 0) {
      insights.push(`${significantImprovements.length} optimizations achieved >10% improvement`);
    }

    // Analyze causal model learning
    const recentRecords = records.slice(-20);
    const oldRecords = records.slice(-40, -20);
    if (recentRecords.length >= 10 && oldRecords.length >= 10) {
      const recentAccuracy = recentRecords.reduce((sum, r) => sum + r.causalAccuracy, 0) / recentRecords.length;
      const oldAccuracy = oldRecords.reduce((sum, r) => sum + r.causalAccuracy, 0) / oldRecords.length;

      if (recentAccuracy > oldAccuracy + 0.05) {
        insights.push('Causal model accuracy is improving over time');
      } else if (recentAccuracy < oldAccuracy - 0.05) {
        insights.push('Causal model accuracy may be degrading - review training data');
      }
    }

    return insights;
  }

  private analyzeTemporalPatterns(records: Array<RANCausalOptimizationRecord>): string[] {
    const patterns: string[] = [];

    // Analyze time-of-day patterns
    const hourlyPerformance: Record<number, { count: number, totalImprovement: number }> = {};

    for (const record of records) {
      const hour = new Date(record.timestamp).getHours();
      if (!hourlyPerformance[hour]) {
        hourlyPerformance[hour] = { count: 0, totalImprovement: 0 };
      }
      hourlyPerformance[hour].count++;
      hourlyPerformance[hour].totalImprovement += record.improvement;
    }

    // Find best and worst performing hours
    let bestHour = -1, worstHour = -1;
    let bestAvgImprovement = -Infinity, worstAvgImprovement = Infinity;

    for (const [hour, stats] of Object.entries(hourlyPerformance)) {
      if (stats.count >= 5) {  // Only consider hours with sufficient data
        const avgImprovement = stats.totalImprovement / stats.count;
        if (avgImprovement > bestAvgImprovement) {
          bestAvgImprovement = avgImprovement;
          bestHour = parseInt(hour);
        }
        if (avgImprovement < worstAvgImprovement) {
          worstAvgImprovement = avgImprovement;
          worstHour = parseInt(hour);
        }
      }
    }

    if (bestHour >= 0) {
      patterns.push(`Best performance at ${bestHour}:00 (${(bestAvgImprovement * 100).toFixed(1)}% avg improvement)`);
    }
    if (worstHour >= 0) {
      patterns.push(`Most challenging at ${worstHour}:00 (${(worstAvgImprovement * 100).toFixed(1)}% avg improvement)`);
    }

    return patterns;
  }

  private analyzePerformanceTrends(records: Array<RANCausalOptimizationRecord>): string[] {
    const trends: string[] = [];

    if (records.length < 20) {
      trends.push('Insufficient data for trend analysis');
      return trends;
    }

    // Split into halves for trend comparison
    const midpoint = Math.floor(records.length / 2);
    const firstHalf = records.slice(0, midpoint);
    const secondHalf = records.slice(midpoint);

    const firstHalfSuccess = firstHalf.filter(r => r.improvement > 0.05).length / firstHalf.length;
    const secondHalfSuccess = secondHalf.filter(r => r.improvement > 0.05).length / secondHalf.length;

    if (secondHalfSuccess > firstHalfSuccess + 0.1) {
      trends.push('Success rate improving in recent optimizations');
    } else if (secondHalfSuccess < firstHalfSuccess - 0.1) {
      trends.push('Success rate declining - investigate potential issues');
    } else {
      trends.push('Success rate stable over time');
    }

    return trends;
  }

  private generateSystemRecommendations(
    records: Array<RANCausalOptimizationRecord>,
    effectiveness: Record<string, any>
  ): string[] {
    const recommendations: string[] = [];

    // Success rate recommendations
    const overallSuccessRate = records.filter(r => r.improvement > 0.05).length / records.length;
    if (overallSuccessRate < 0.7) {
      recommendations.push('Improve intervention selection criteria - success rate below 70%');
    }

    // Most effective intervention recommendations
    const bestIntervention = Object.entries(effectiveness)
      .sort(([,a], [,b]) => b.successRate - a.successRate)[0];

    if (bestIntervention) {
      recommendations.push(`Prioritize ${bestIntervention[0]} interventions - highest success rate`);
    }

    // Confidence recommendations
    const avgConfidence = records.reduce((sum, r) => sum + r.confidence, 0) / records.length;
    if (avgConfidence < 0.75) {
      recommendations.push('Address confidence factors to improve prediction reliability');
    }

    // Causal accuracy recommendations
    const avgAccuracy = records.reduce((sum, r) => sum + r.causalAccuracy, 0) / records.length;
    if (avgAccuracy < 0.8) {
      recommendations.push('Retrain causal models with more diverse data');
    }

    return recommendations;
  }

  private assessModelHealth(): string[] {
    const health: string[] = [];

    // Check data sufficiency
    if (this.optimizationHistory.length < 50) {
      health.push('⚠️ Limited historical data - need more optimization cycles');
    } else {
      health.push('✅ Sufficient historical data for reliable predictions');
    }

    // Check recent performance
    const recent = this.optimizationHistory.slice(-10);
    if (recent.length > 0) {
      const recentSuccess = recent.filter(r => r.improvement > 0.05).length / recent.length;
      if (recentSuccess > 0.7) {
        health.push('✅ Recent performance is strong');
      } else {
        health.push('⚠️ Recent success rate below 70% - review approach');
      }
    }

    // Check causal model freshness
    const lastUpdate = this.optimizationHistory.length > 0 ?
      this.optimizationHistory[this.optimizationHistory.length - 1].timestamp : 0;
    const hoursSinceUpdate = (Date.now() - lastUpdate) / (3600000);

    if (hoursSinceUpdate > 24) {
      health.push('⚠️ Causal model may be stale - recent data needed');
    } else {
      health.push('✅ Causal model recently updated');
    }

    return health;
  }
}

interface RANCausalOptimizationRecord {
  optimizationId: string;
  timestamp: number;
  currentState: RANState;
  intervention: RANIntervention;
  outcome: RANState;
  improvement: number;
  causalAccuracy: number;
  confidence: number;
  executionTime: number;
}

interface RANCausalOptimizationResult {
  optimizationId: string;
  currentState: RANState;
  selectedIntervention: RANIntervention;
  actualOutcome: RANState;
  causalExplanation: any;
  alternativePredictions: Array<any>;
  performanceMetrics: {
    executionTime: number;
    causalAccuracy: number;
    improvement: number;
    confidence: number;
  };
  report: string;
  timestamp: number;
}

const causalInference = new RANCausalInference();
await causalInference.initialize();

// Discover causal relationships from RAN data
const ranData = [
  {
    timestamp: Date.now(),
    throughput: 850,
    latency: 45,
    packetLoss: 0.02,
    signalStrength: -75,
    interference: 0.08,
    handoverCount: 3,
    energyConsumption: 75
  },
  // ... more observations
];

const causalRelationships = await causalInference.discoverCausalRelationships(ranData);
console.log(`Discovered ${causalRelationships.length} causal relationships`);

const causalSystem = new ProductionRANCausalSystem();
await causalSystem.initialize();

// Run complete causal optimization cycle
const currentState = {
  throughput: 750,
  latency: 65,
  packetLoss: 0.04,
  signalStrength: -78,
  interference: 0.12,
  handoverCount: 7,
  energyConsumption: 85
};

const result = await causalSystem.runCausalOptimization(currentState);
console.log(`Selected intervention: ${result.selectedIntervention.type}`);
console.log(`Improvement: ${(result.performanceMetrics.improvement * 100).toFixed(1)}%`);
console.log(`Causal accuracy: ${(result.performanceMetrics.causalAccuracy * 100).toFixed(1)}%`);

// Generate insights report
const insights = await causalSystem.generateCausalInsightsReport();
console.log(insights);

const counterfactual = new RANCounterfactualAnalysis();
await counterfactual.initialize();

const currentState = { /* RAN state */ };
const actualOutcome = { /* actual result after intervention */ };
const alternativeIntervention = {
  type: 'adjust_beamforming',
  parameters: { beamWidth: 20 }
};

const counterfactualResult = await counterfactual.analyzeCounterfactual(
  currentState,
  actualOutcome,
  alternativeIntervention
);

console.log(`Would have achieved ${(counterfactualResult.comparison.overallImprovement * 100).toFixed(1)}% improvement`);

# RAN Causal Inference Configuration
export RAN_CAUSAL_DB_PATH=.agentdb/ran-causal.db
export RAN_CAUSAL_MODEL_PATH=./models
export RAN_CAUSAL_LOG_LEVEL=info

# GPCM Configuration
export RAN_CAUSAL_LEARNING_RATE=0.001
export RAN_CAUSAL_BATCH_SIZE=32
export RAN_CAUSAL_EPOCHS=50

# AgentDB Configuration
export AGENTDB_ENABLED=true
export AGENTDB_QUANTIZATION=scalar
export AGENTDB_CACHE_SIZE=1500

# Performance Optimization
export RAN_CAUSAL_GPU_ACCELERATION=false
export RAN_CAUSAL_PARALLEL_INFERENCE=true
export RAN_CAUSAL_CACHE_MODELS=true

// Increase training data and adjust thresholds
const relationships = await gpcm.discoverCausalRelationships(trainingData);
const strongRelationships = relationships.filter(r => r.strength > 0.5 && r.confidence > 0.8);

// Check state similarity and adjust confidence factors
const confidence = counterfactual.calculateCounterfactualConfidence(state, intervention);
if (confidence < 0.7) {
  console.log('Low confidence - gather more similar cases');
}

// Adjust learning rate and add regularization
const optimizer = tf.train.adam(0.0005); // Lower learning rate
// Add L2 regularization to networks

class RANCausalMonitoringIntegration {
  private causalSystem: ProductionRANCausalSystem;

  async integrateWithRANMonitoring() {
    // Real-time RAN KPI monitoring
    setInterval(async () => {
      const currentKPIs = await this.getRANKPIs();
      const analysis = await this.causalSystem.runCausalOptimization(currentKPIs);

      if (analysis.performanceMetrics.improvement > 0.05) {
        await this.applyOptimization(analysis.selectedIntervention);
      }
    }, 60000); // Every minute
  }

  private async getRANKPIs(): Promise<RANState> {
    // Fetch from RAN monitoring system
    const response = await fetch('/api/ran/kpis/current');
    return await response.json();
  }

  private async applyOptimization(intervention: RANIntervention) {
    // Apply optimization to RAN
    await fetch('/api/ran/optimize', {
      method: 'POST',
      body: JSON.stringify(intervention)
    });
  }
}