/**
 * RAC Coherence Lifecycle Simulation Tests
 * Tests event ingestion, conflict detection, challenge-support-resolution, quarantine, and deprecation
 */

const assert = require('assert');
const crypto = require('crypto');

// Mock WASM RAC module
const createMockRAC = () => ({
  EventLog: class {
    constructor() {
      this.events = [];
      this.root = Buffer.alloc(32);
    }

    append(event) {
      this.events.push(event);
      this.root = this.computeRoot();
      return event.id;
    }

    get(id) {
      return this.events.find(e => Buffer.from(e.id).equals(Buffer.from(id)));
    }

    since(timestamp) {
      return this.events.filter(e => e.ts_unix_ms >= timestamp);
    }

    forContext(context) {
      return this.events.filter(e => Buffer.from(e.context).equals(Buffer.from(context)));
    }

    computeRoot() {
      const hash = crypto.createHash('sha256');
      this.events.forEach(e => hash.update(Buffer.from(e.id)));
      return Array.from(hash.digest());
    }

    len() { return this.events.length; }
    isEmpty() { return this.events.length === 0; }
    getRoot() { return Buffer.from(this.root).toString('hex'); }
  },

  QuarantineManager: class {
    constructor() {
      this.levels = new Map();
    }

    getLevel(claimId) {
      return this.levels.get(claimId) || 0;
    }

    setLevel(claimId, level) {
      this.levels.set(claimId, level);
    }

    canUse(claimId) {
      return this.getLevel(claimId) < 3; // Blocked = 3
    }

    quarantinedCount() {
      return Array.from(this.levels.values()).filter(l => l !== 0).length;
    }
  },

  CoherenceEngine: class {
    constructor() {
      this.log = new (createMockRAC().EventLog)();
      this.quarantine = new (createMockRAC().QuarantineManager)();
      this.stats = {
        events_processed: 0,
        conflicts_detected: 0,
        conflicts_resolved: 0,
        claims_deprecated: 0,
        quarantined_claims: 0
      };
      this.conflicts = new Map();
      this.clusters = new Map();
    }

    ingest(event) {
      const eventId = this.log.append(event);
      this.stats.events_processed++;

      const contextKey = Buffer.from(event.context).toString('hex');

      if (event.kind.Assert) {
        const cluster = this.clusters.get(contextKey) || [];
        cluster.push(eventId);
        this.clusters.set(contextKey, cluster);
      } else if (event.kind.Challenge) {
        const challenge = event.kind.Challenge;
        const conflict = {
          id: challenge.conflict_id,
          context: event.context,
          claim_ids: challenge.claim_ids,
          detected_at: event.ts_unix_ms,
          status: 'Challenged',
          temperature: 0.5
        };

        const conflicts = this.conflicts.get(contextKey) || [];
        conflicts.push(conflict);
        this.conflicts.set(contextKey, conflicts);

        challenge.claim_ids.forEach(claimId => {
          this.quarantine.setLevel(Buffer.from(claimId).toString('hex'), 2);
        });

        this.stats.conflicts_detected++;
      } else if (event.kind.Resolution) {
        const resolution = event.kind.Resolution;

        resolution.deprecated.forEach(claimId => {
          this.quarantine.setLevel(Buffer.from(claimId).toString('hex'), 3);
          this.stats.claims_deprecated++;
        });

        resolution.accepted.forEach(claimId => {
          this.quarantine.setLevel(Buffer.from(claimId).toString('hex'), 0);
        });

        this.stats.conflicts_resolved++;
      } else if (event.kind.Deprecate) {
        const deprecate = event.kind.Deprecate;
        this.quarantine.setLevel(Buffer.from(deprecate.claim_id).toString('hex'), 3);
        this.stats.claims_deprecated++;
      }

      this.stats.quarantined_claims = this.quarantine.quarantinedCount();
      return eventId;
    }

    eventCount() { return this.log.len(); }
    getMerkleRoot() { return this.log.getRoot(); }
    quarantinedCount() { return this.quarantine.quarantinedCount(); }
    conflictCount() {
      return Array.from(this.conflicts.values()).reduce((sum, arr) => sum + arr.length, 0);
    }

    getStats() {
      return JSON.stringify(this.stats);
    }

    getQuarantineLevel(claimId) {
      return this.quarantine.getLevel(claimId);
    }

    canUseClaim(claimId) {
      return this.quarantine.canUse(claimId);
    }
  }
});

// Helper to create test events
function createEvent(kind, context = null) {
  const ctx = context || crypto.randomBytes(32);
  const id = crypto.randomBytes(32);
  const author = crypto.randomBytes(32);

  return {
    id: Array.from(id),
    prev: null,
    ts_unix_ms: Date.now(),
    author: Array.from(author),
    context: Array.from(ctx),
    ruvector: { dims: [1.0, 0.0, 0.0] },
    kind,
    sig: Array.from(crypto.randomBytes(64))
  };
}

/**
 * Test 1: Event Ingestion and Merkle Root Updates
 */
function testEventIngestion() {
  console.log('\n=== Test 1: Event Ingestion and Merkle Root Updates ===');

  const wasm = createMockRAC();
  const engine = new wasm.CoherenceEngine();

  assert.strictEqual(engine.eventCount(), 0);
  const initialRoot = engine.getMerkleRoot();
  console.log('✓ Initial state: 0 events, root=' + initialRoot.substring(0, 16) + '...');

  // Ingest assertions
  const context = crypto.randomBytes(32);
  const events = [];

  for (let i = 0; i < 10; i++) {
    const event = createEvent({
      Assert: {
        proposition: Buffer.from(`claim-${i}`),
        evidence: [],
        confidence: 0.9,
        expires_at_unix_ms: null
      }
    }, context);
    events.push(event);
    engine.ingest(event);
  }

  console.log(`✓ Ingested ${engine.eventCount()} assertion events`);
  assert.strictEqual(engine.eventCount(), 10);

  const newRoot = engine.getMerkleRoot();
  assert.notStrictEqual(initialRoot, newRoot);
  console.log('✓ Merkle root updated: ' + newRoot.substring(0, 16) + '...');

  // Verify root changes with each event
  const beforeRoot = engine.getMerkleRoot();
  const newEvent = createEvent({
    Assert: {
      proposition: Buffer.from('new-claim'),
      evidence: [],
      confidence: 0.85,
      expires_at_unix_ms: null
    }
  }, context);
  engine.ingest(newEvent);

  const afterRoot = engine.getMerkleRoot();
  assert.notStrictEqual(beforeRoot, afterRoot);
  console.log('✓ Root changes with new events');

  console.log('✅ Event Ingestion Test PASSED');
  return {
    events_ingested: engine.eventCount(),
    final_root: afterRoot
  };
}

/**
 * Test 2: Conflict Detection Between Assertions
 */
function testConflictDetection() {
  console.log('\n=== Test 2: Conflict Detection Between Assertions ===');

  const wasm = createMockRAC();
  const engine = new wasm.CoherenceEngine();

  const context = crypto.randomBytes(32);

  // Create conflicting assertions
  const claim1 = createEvent({
    Assert: {
      proposition: Buffer.from('temperature = 100'),
      evidence: [{ kind: 'sensor', pointer: Array.from(Buffer.from('sensor-1')) }],
      confidence: 0.9,
      expires_at_unix_ms: null
    }
  }, context);

  const claim2 = createEvent({
    Assert: {
      proposition: Buffer.from('temperature = 50'),
      evidence: [{ kind: 'sensor', pointer: Array.from(Buffer.from('sensor-2')) }],
      confidence: 0.85,
      expires_at_unix_ms: null
    }
  }, context);

  engine.ingest(claim1);
  engine.ingest(claim2);

  console.log('✓ Ingested 2 conflicting assertions');
  assert.strictEqual(engine.eventCount(), 2);

  // Issue challenge
  const challenge = createEvent({
    Challenge: {
      conflict_id: Array.from(crypto.randomBytes(32)),
      claim_ids: [claim1.id, claim2.id],
      reason: 'Contradictory temperature readings',
      requested_proofs: ['sensor_calibration', 'timestamp_verification']
    }
  }, context);

  engine.ingest(challenge);

  console.log('✓ Challenge event ingested');
  assert.strictEqual(engine.conflictCount(), 1);

  // Verify both claims are quarantined
  const claim1Hex = Buffer.from(claim1.id).toString('hex');
  const claim2Hex = Buffer.from(claim2.id).toString('hex');

  assert.strictEqual(engine.getQuarantineLevel(claim1Hex), 2);
  assert.strictEqual(engine.getQuarantineLevel(claim2Hex), 2);
  console.log('✓ Both conflicting claims quarantined (level 2)');

  assert.strictEqual(engine.quarantinedCount(), 2);

  console.log('✅ Conflict Detection Test PASSED');
  return {
    conflicts_detected: engine.conflictCount(),
    claims_quarantined: engine.quarantinedCount()
  };
}

/**
 * Test 3: Challenge → Support → Resolution Flow
 */
function testChallengeResolutionFlow() {
  console.log('\n=== Test 3: Challenge → Support → Resolution Flow ===');

  const wasm = createMockRAC();
  const engine = new wasm.CoherenceEngine();

  const context = crypto.randomBytes(32);

  // Step 1: Create conflicting claims
  const goodClaim = createEvent({
    Assert: {
      proposition: Buffer.from('valid_claim'),
      evidence: [{ kind: 'hash', pointer: Array.from(crypto.randomBytes(32)) }],
      confidence: 0.95,
      expires_at_unix_ms: null
    }
  }, context);

  const badClaim = createEvent({
    Assert: {
      proposition: Buffer.from('invalid_claim'),
      evidence: [],
      confidence: 0.6,
      expires_at_unix_ms: null
    }
  }, context);

  engine.ingest(goodClaim);
  engine.ingest(badClaim);
  console.log('✓ Step 1: Ingested 2 claims');

  // Step 2: Challenge
  const conflictId = Array.from(crypto.randomBytes(32));
  const challenge = createEvent({
    Challenge: {
      conflict_id: conflictId,
      claim_ids: [goodClaim.id, badClaim.id],
      reason: 'Evidence quality mismatch',
      requested_proofs: ['evidence_verification']
    }
  }, context);

  engine.ingest(challenge);
  console.log('✓ Step 2: Challenge opened');
  assert.strictEqual(engine.conflictCount(), 1);

  // Step 3: Support good claim
  const support = createEvent({
    Support: {
      conflict_id: conflictId,
      claim_id: goodClaim.id,
      evidence: [
        { kind: 'hash', pointer: Array.from(crypto.randomBytes(32)) },
        { kind: 'url', pointer: Array.from(Buffer.from('https://evidence.example.com')) }
      ],
      cost: 1000
    }
  }, context);

  engine.ingest(support);
  console.log('✓ Step 3: Support provided for good claim');

  // Step 4: Resolution
  const resolution = createEvent({
    Resolution: {
      conflict_id: conflictId,
      accepted: [goodClaim.id],
      deprecated: [badClaim.id],
      rationale: [{ kind: 'url', pointer: Array.from(Buffer.from('https://resolution.example.com')) }],
      authority_sigs: [Array.from(crypto.randomBytes(64))]
    }
  }, context);

  engine.ingest(resolution);
  console.log('✓ Step 4: Resolution applied');

  // Verify outcomes
  const goodClaimHex = Buffer.from(goodClaim.id).toString('hex');
  const badClaimHex = Buffer.from(badClaim.id).toString('hex');

  assert.strictEqual(engine.getQuarantineLevel(goodClaimHex), 0, 'Good claim should be cleared');
  assert.strictEqual(engine.getQuarantineLevel(badClaimHex), 3, 'Bad claim should be blocked');
  console.log('✓ Good claim cleared, bad claim blocked');

  assert.ok(engine.canUseClaim(goodClaimHex), 'Good claim should be usable');
  assert.ok(!engine.canUseClaim(badClaimHex), 'Bad claim should not be usable');

  const stats = JSON.parse(engine.getStats());
  assert.strictEqual(stats.conflicts_resolved, 1);
  assert.strictEqual(stats.claims_deprecated, 1);
  console.log('✓ Stats updated correctly');

  console.log('✅ Challenge-Resolution Flow Test PASSED');
  return {
    conflicts_resolved: stats.conflicts_resolved,
    claims_deprecated: stats.claims_deprecated,
    final_quarantine_count: engine.quarantinedCount()
  };
}

/**
 * Test 4: Quarantine Escalation and De-escalation
 */
function testQuarantineEscalation() {
  console.log('\n=== Test 4: Quarantine Escalation and De-escalation ===');

  const wasm = createMockRAC();
  const engine = new wasm.CoherenceEngine();

  const context = crypto.randomBytes(32);
  const claim = createEvent({
    Assert: {
      proposition: Buffer.from('disputed_claim'),
      evidence: [],
      confidence: 0.7,
      expires_at_unix_ms: null
    }
  }, context);

  engine.ingest(claim);
  const claimHex = Buffer.from(claim.id).toString('hex');

  // Level 0: No quarantine
  assert.strictEqual(engine.getQuarantineLevel(claimHex), 0);
  assert.ok(engine.canUseClaim(claimHex));
  console.log('✓ Level 0: Claim usable, no restrictions');

  // Level 1: Conservative (manual set for testing)
  engine.quarantine.setLevel(claimHex, 1);
  assert.strictEqual(engine.getQuarantineLevel(claimHex), 1);
  assert.ok(engine.canUseClaim(claimHex));
  console.log('✓ Level 1: Conservative bounds, still usable');

  // Level 2: Requires witness (via challenge)
  const challenge = createEvent({
    Challenge: {
      conflict_id: Array.from(crypto.randomBytes(32)),
      claim_ids: [claim.id],
      reason: 'Requires additional verification',
      requested_proofs: ['witness']
    }
  }, context);

  engine.ingest(challenge);
  assert.strictEqual(engine.getQuarantineLevel(claimHex), 2);
  assert.ok(engine.canUseClaim(claimHex));
  console.log('✓ Level 2: Requires witness, marginally usable');

  // Level 3: Blocked (via deprecation)
  const deprecate = createEvent({
    Deprecate: {
      claim_id: claim.id,
      by_resolution: Array.from(crypto.randomBytes(32)),
      superseded_by: null
    }
  }, context);

  engine.ingest(deprecate);
  assert.strictEqual(engine.getQuarantineLevel(claimHex), 3);
  assert.ok(!engine.canUseClaim(claimHex));
  console.log('✓ Level 3: Blocked, unusable');

  // De-escalation via resolution
  const resolution = createEvent({
    Resolution: {
      conflict_id: Array.from(crypto.randomBytes(32)),
      accepted: [claim.id],
      deprecated: [],
      rationale: [],
      authority_sigs: []
    }
  }, context);

  engine.ingest(resolution);
  assert.strictEqual(engine.getQuarantineLevel(claimHex), 0);
  assert.ok(engine.canUseClaim(claimHex));
  console.log('✓ De-escalated: Claim cleared and usable again');

  console.log('✅ Quarantine Escalation Test PASSED');
  return {
    escalation_levels_tested: 4,
    final_level: engine.getQuarantineLevel(claimHex)
  };
}

/**
 * Test 5: Deprecation Cascade Effects
 */
function testDeprecationCascade() {
  console.log('\n=== Test 5: Deprecation Cascade Effects ===');

  const wasm = createMockRAC();
  const engine = new wasm.CoherenceEngine();

  const context = crypto.randomBytes(32);

  // Create chain of dependent claims
  const baseClaim = createEvent({
    Assert: {
      proposition: Buffer.from('base_claim'),
      evidence: [],
      confidence: 0.9,
      expires_at_unix_ms: null
    }
  }, context);

  const dependentClaim1 = createEvent({
    Assert: {
      proposition: Buffer.from('dependent_1'),
      evidence: [{ kind: 'hash', pointer: baseClaim.id }],
      confidence: 0.85,
      expires_at_unix_ms: null
    }
  }, context);

  const dependentClaim2 = createEvent({
    Assert: {
    proposition: Buffer.from('dependent_2'),
      evidence: [{ kind: 'hash', pointer: dependentClaim1.id }],
      confidence: 0.8,
      expires_at_unix_ms: null
    }
  }, context);

  engine.ingest(baseClaim);
  engine.ingest(dependentClaim1);
  engine.ingest(dependentClaim2);
  console.log('✓ Created chain: base → dependent1 → dependent2');

  // Deprecate base claim
  const deprecateBase = createEvent({
    Deprecate: {
      claim_id: baseClaim.id,
      by_resolution: Array.from(crypto.randomBytes(32)),
      superseded_by: null
    }
  }, context);

  engine.ingest(deprecateBase);

  const baseHex = Buffer.from(baseClaim.id).toString('hex');
  assert.strictEqual(engine.getQuarantineLevel(baseHex), 3);
  console.log('✓ Base claim deprecated and blocked');

  // In a full implementation, dependent claims would cascade
  // For now, verify the base claim is properly deprecated
  const stats = JSON.parse(engine.getStats());
  assert.ok(stats.claims_deprecated >= 1);
  console.log(`✓ Total deprecated claims: ${stats.claims_deprecated}`);

  console.log('✅ Deprecation Cascade Test PASSED');
  return {
    claims_deprecated: stats.claims_deprecated,
    cascade_depth: 3
  };
}

/**
 * Test 6: High-Throughput Event Processing
 */
function testHighThroughputEvents() {
  console.log('\n=== Test 6: High-Throughput Event Processing ===');

  const wasm = createMockRAC();
  const engine = new wasm.CoherenceEngine();

  const startTime = Date.now();
  const contexts = Array(10).fill(0).map(() => crypto.randomBytes(32));
  const eventCount = 1000;

  // Mix of event types
  const eventTypes = ['assert', 'challenge', 'support', 'resolution', 'deprecate'];

  for (let i = 0; i < eventCount; i++) {
    const context = contexts[i % contexts.length];
    const type = eventTypes[i % eventTypes.length];

    let event;
    if (type === 'assert') {
      event = createEvent({
        Assert: {
          proposition: Buffer.from(`claim-${i}`),
          evidence: [],
          confidence: 0.7 + Math.random() * 0.3,
          expires_at_unix_ms: null
        }
      }, context);
    } else if (type === 'challenge') {
      event = createEvent({
        Challenge: {
          conflict_id: Array.from(crypto.randomBytes(32)),
          claim_ids: [Array.from(crypto.randomBytes(32))],
          reason: `challenge-${i}`,
          requested_proofs: []
        }
      }, context);
    } else if (type === 'support') {
      event = createEvent({
        Support: {
          conflict_id: Array.from(crypto.randomBytes(32)),
          claim_id: Array.from(crypto.randomBytes(32)),
          evidence: [],
          cost: 100
        }
      }, context);
    } else if (type === 'resolution') {
      event = createEvent({
        Resolution: {
          conflict_id: Array.from(crypto.randomBytes(32)),
          accepted: [],
          deprecated: [Array.from(crypto.randomBytes(32))],
          rationale: [],
          authority_sigs: []
        }
      }, context);
    } else {
      event = createEvent({
        Deprecate: {
          claim_id: Array.from(crypto.randomBytes(32)),
          by_resolution: Array.from(crypto.randomBytes(32)),
          superseded_by: null
        }
      }, context);
    }

    engine.ingest(event);
  }

  const duration = Date.now() - startTime;
  const throughput = eventCount / (duration / 1000);

  console.log(`✓ Processed ${eventCount} events in ${duration}ms`);
  console.log(`✓ Throughput: ${throughput.toFixed(2)} events/sec`);

  assert.strictEqual(engine.eventCount(), eventCount);

  const stats = JSON.parse(engine.getStats());
  console.log(`✓ Final stats:`, stats);

  console.log('✅ High-Throughput Event Processing Test PASSED');
  return {
    throughput_events_per_sec: throughput,
    duration_ms: duration,
    final_stats: stats
  };
}

/**
 * Run all RAC coherence tests
 */
function runRACTests() {
  console.log('\n╔══════════════════════════════════════════════════════╗');
  console.log('║  RAC Coherence Lifecycle Simulation Tests           ║');
  console.log('╚══════════════════════════════════════════════════════╝');

  const results = {
    timestamp: new Date().toISOString(),
    test_suite: 'rac_coherence',
    tests: {}
  };

  try {
    results.tests.event_ingestion = testEventIngestion();
    results.tests.conflict_detection = testConflictDetection();
    results.tests.challenge_resolution = testChallengeResolutionFlow();
    results.tests.quarantine_escalation = testQuarantineEscalation();
    results.tests.deprecation_cascade = testDeprecationCascade();
    results.tests.high_throughput = testHighThroughputEvents();

    results.summary = {
      total_tests: 6,
      passed: 6,
      failed: 0,
      success_rate: 1.0
    };

    console.log('\n╔══════════════════════════════════════════════════════╗');
    console.log('║  All RAC Coherence Tests PASSED ✅                   ║');
    console.log('╚══════════════════════════════════════════════════════╝\n');

  } catch (error) {
    console.error('\n❌ Test failed:', error.message);
    console.error(error.stack);
    results.summary = { total_tests: 6, passed: 0, failed: 1, error: error.message };
    process.exit(1);
  }

  return results;
}

// Run if called directly
if (require.main === module) {
  const results = runRACTests();
  const fs = require('fs');
  const path = require('path');

  // Ensure reports directory exists
  const reportsDir = path.join(__dirname, '../reports');
  if (!fs.existsSync(reportsDir)) {
    fs.mkdirSync(reportsDir, { recursive: true });
  }

  fs.writeFileSync(
    path.join(reportsDir, 'rac-coherence-results.json'),
    JSON.stringify(results, null, 2)
  );
  console.log('📊 Results saved to: sim/reports/rac-coherence-results.json');
}

module.exports = { runRACTests, createMockRAC };