#!/usr/bin/env node
/**
 * Multi-Contributor Edge-Net Test with Persistence
 *
 * Tests:
 * 1. Multiple contributors with persistent identities
 * 2. State persistence (patterns, ledger, coherence)
 * 3. Cross-contributor verification
 * 4. Session restore from persisted data
 */

import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';
import { webcrypto } from 'crypto';
import { performance } from 'perf_hooks';
import { homedir } from 'os';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Setup polyfills
async function setupPolyfills() {
  if (typeof globalThis.crypto === 'undefined') {
    globalThis.crypto = webcrypto;
  }
  if (typeof globalThis.performance === 'undefined') {
    globalThis.performance = performance;
  }

  const createStorage = () => {
    const store = new Map();
    return {
      getItem: (key) => store.get(key) || null,
      setItem: (key, value) => store.set(key, String(value)),
      removeItem: (key) => store.delete(key),
      clear: () => store.clear(),
      get length() { return store.size; },
      key: (i) => [...store.keys()][i] || null,
    };
  };

  let cpuCount = 4;
  try {
    const os = await import('os');
    cpuCount = os.cpus().length;
  } catch {}

  if (typeof globalThis.window === 'undefined') {
    globalThis.window = {
      crypto: globalThis.crypto,
      performance: globalThis.performance,
      localStorage: createStorage(),
      sessionStorage: createStorage(),
      navigator: {
        userAgent: `Node.js/${process.version}`,
        hardwareConcurrency: cpuCount,
      },
      location: { href: 'node://localhost', hostname: 'localhost' },
      screen: { width: 1920, height: 1080, colorDepth: 24 },
    };
  }

  if (typeof globalThis.document === 'undefined') {
    globalThis.document = { createElement: () => ({}), body: {}, head: {} };
  }
}

// Colors
const c = {
  reset: '\x1b[0m',
  bold: '\x1b[1m',
  dim: '\x1b[2m',
  cyan: '\x1b[36m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  red: '\x1b[31m',
  magenta: '\x1b[35m',
};

function toHex(bytes) {
  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
}

// Storage directory
const STORAGE_DIR = join(homedir(), '.ruvector', 'edge-net-test');

function ensureStorageDir() {
  if (!existsSync(STORAGE_DIR)) {
    mkdirSync(STORAGE_DIR, { recursive: true });
  }
  return STORAGE_DIR;
}

// Contributor class with persistence
class PersistentContributor {
  constructor(wasm, id, storageDir) {
    this.wasm = wasm;
    this.id = id;
    this.storageDir = storageDir;
    this.identityPath = join(storageDir, `contributor-${id}.identity`);
    this.statePath = join(storageDir, `contributor-${id}.state`);
    this.piKey = null;
    this.coherence = null;
    this.reasoning = null;
    this.memory = null;
    this.ledger = null;
    this.patterns = [];
  }

  // Initialize or restore from persistence
  async initialize() {
    const password = `contributor-${this.id}-secret`;

    // Try to restore identity
    if (existsSync(this.identityPath)) {
      console.log(`  ${c.cyan}[${this.id}]${c.reset} Restoring identity from storage...`);
      const backup = new Uint8Array(readFileSync(this.identityPath));
      this.piKey = this.wasm.PiKey.restoreFromBackup(backup, password);
      console.log(`  ${c.green}✓${c.reset} Identity restored: ${this.piKey.getShortId()}`);
    } else {
      console.log(`  ${c.cyan}[${this.id}]${c.reset} Generating new identity...`);
      this.piKey = new this.wasm.PiKey();
      // Persist immediately
      const backup = this.piKey.createEncryptedBackup(password);
      writeFileSync(this.identityPath, Buffer.from(backup));
      console.log(`  ${c.green}✓${c.reset} New identity created: ${this.piKey.getShortId()}`);
    }

    // Initialize components
    this.coherence = new this.wasm.CoherenceEngine();
    this.reasoning = new this.wasm.ReasoningBank();
    this.memory = new this.wasm.CollectiveMemory(this.getNodeId());
    this.ledger = new this.wasm.QDAGLedger();

    // Try to restore state
    if (existsSync(this.statePath)) {
      console.log(`  ${c.cyan}[${this.id}]${c.reset} Restoring state...`);
      const state = JSON.parse(readFileSync(this.statePath, 'utf-8'));

      // Restore ledger state if available
      if (state.ledger) {
        const ledgerBytes = new Uint8Array(state.ledger);
        const imported = this.ledger.importState(ledgerBytes);
        console.log(`  ${c.green}✓${c.reset} Ledger restored: ${imported} transactions`);
      }

      // Restore patterns
      if (state.patterns) {
        this.patterns = state.patterns;
        state.patterns.forEach(p => this.reasoning.store(JSON.stringify(p)));
        console.log(`  ${c.green}✓${c.reset} Patterns restored: ${state.patterns.length}`);
      }
    }

    return this;
  }

  getNodeId() {
    return `node-${this.id}-${this.piKey.getShortId()}`;
  }

  getPublicKey() {
    return this.piKey.getPublicKey();
  }

  // Sign data
  sign(data) {
    const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
    return this.piKey.sign(bytes);
  }

  // Verify signature from another contributor
  verify(data, signature, publicKey) {
    const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
    return this.piKey.verify(bytes, signature, publicKey);
  }

  // Store a pattern
  storePattern(pattern) {
    const id = this.reasoning.store(JSON.stringify(pattern));
    this.patterns.push(pattern);
    return id;
  }

  // Lookup patterns
  lookupPatterns(query, k = 3) {
    return JSON.parse(this.reasoning.lookup(JSON.stringify(query), k));
  }

  // Get coherence stats
  getCoherenceStats() {
    return JSON.parse(this.coherence.getStats());
  }

  // Get memory stats
  getMemoryStats() {
    return JSON.parse(this.memory.getStats());
  }

  // Persist state
  persist() {
    const state = {
      timestamp: Date.now(),
      nodeId: this.getNodeId(),
      patterns: this.patterns,
      ledger: Array.from(this.ledger.exportState()),
      stats: {
        coherence: this.getCoherenceStats(),
        memory: this.getMemoryStats(),
        patternCount: this.reasoning.count(),
        txCount: this.ledger.transactionCount()
      }
    };

    writeFileSync(this.statePath, JSON.stringify(state, null, 2));
    return state;
  }

  // Cleanup WASM resources
  cleanup() {
    if (this.piKey) this.piKey.free();
    if (this.coherence) this.coherence.free();
    if (this.reasoning) this.reasoning.free();
    if (this.memory) this.memory.free();
    if (this.ledger) this.ledger.free();
  }
}

// Network simulation
class EdgeNetwork {
  constructor(wasm, storageDir) {
    this.wasm = wasm;
    this.storageDir = storageDir;
    this.contributors = new Map();
    this.sharedMessages = [];
  }

  async addContributor(id) {
    const contributor = new PersistentContributor(this.wasm, id, this.storageDir);
    await contributor.initialize();
    this.contributors.set(id, contributor);
    return contributor;
  }

  // Broadcast a signed message
  broadcastMessage(senderId, message) {
    const sender = this.contributors.get(senderId);
    const signature = sender.sign(message);

    this.sharedMessages.push({
      from: senderId,
      message,
      signature: Array.from(signature),
      publicKey: Array.from(sender.getPublicKey()),
      timestamp: Date.now()
    });

    return signature;
  }

  // Verify all messages from network perspective
  verifyAllMessages() {
    const results = [];

    for (const msg of this.sharedMessages) {
      const signature = new Uint8Array(msg.signature);
      const publicKey = new Uint8Array(msg.publicKey);

      // Each contributor verifies
      for (const [id, contributor] of this.contributors) {
        if (id !== msg.from) {
          const valid = contributor.verify(msg.message, signature, publicKey);
          results.push({
            message: msg.message.substring(0, 30) + '...',
            from: msg.from,
            verifiedBy: id,
            valid
          });
        }
      }
    }

    return results;
  }

  // Share patterns across network
  sharePatterns() {
    const allPatterns = [];

    for (const [id, contributor] of this.contributors) {
      contributor.patterns.forEach(p => {
        allPatterns.push({ ...p, contributor: id });
      });
    }

    return allPatterns;
  }

  // Persist all contributors
  persistAll() {
    const states = {};
    for (const [id, contributor] of this.contributors) {
      states[id] = contributor.persist();
    }

    // Save network state
    const networkState = {
      timestamp: Date.now(),
      contributors: Array.from(this.contributors.keys()),
      messages: this.sharedMessages,
      totalPatterns: this.sharePatterns().length
    };

    writeFileSync(
      join(this.storageDir, 'network-state.json'),
      JSON.stringify(networkState, null, 2)
    );

    return { states, networkState };
  }

  cleanup() {
    for (const [, contributor] of this.contributors) {
      contributor.cleanup();
    }
  }
}

// Main test
async function runMultiContributorTest() {
  console.log(`
${c.cyan}╔═══════════════════════════════════════════════════════════════╗${c.reset}
${c.cyan}║${c.reset}  ${c.bold}Multi-Contributor Edge-Net Test with Persistence${c.reset}           ${c.cyan}║${c.reset}
${c.cyan}╚═══════════════════════════════════════════════════════════════╝${c.reset}
`);

  await setupPolyfills();

  // Load WASM
  const { createRequire } = await import('module');
  const require = createRequire(import.meta.url);
  console.log(`${c.dim}Loading WASM module...${c.reset}`);
  const wasm = require('./node/ruvector_edge_net.cjs');
  console.log(`${c.green}✓${c.reset} WASM module loaded\n`);

  // Setup storage
  const storageDir = ensureStorageDir();
  console.log(`${c.cyan}Storage:${c.reset} ${storageDir}\n`);

  // Check if this is a continuation
  const networkStatePath = join(storageDir, 'network-state.json');
  const isContinuation = existsSync(networkStatePath);

  if (isContinuation) {
    const prevState = JSON.parse(readFileSync(networkStatePath, 'utf-8'));
    console.log(`${c.yellow}Continuing from previous session:${c.reset}`);
    console.log(`  Previous timestamp: ${new Date(prevState.timestamp).toISOString()}`);
    console.log(`  Contributors: ${prevState.contributors.join(', ')}`);
    console.log(`  Messages: ${prevState.messages.length}`);
    console.log(`  Patterns: ${prevState.totalPatterns}\n`);
  } else {
    console.log(`${c.green}Starting fresh network...${c.reset}\n`);
  }

  // Create network
  const network = new EdgeNetwork(wasm, storageDir);

  try {
    // ==== Phase 1: Initialize Contributors ====
    console.log(`${c.bold}=== Phase 1: Initialize Contributors ===${c.reset}\n`);

    const contributorIds = ['alice', 'bob', 'charlie'];

    for (const id of contributorIds) {
      await network.addContributor(id);
    }

    console.log(`\n${c.green}✓${c.reset} ${network.contributors.size} contributors initialized\n`);

    // ==== Phase 2: Cross-Verification ====
    console.log(`${c.bold}=== Phase 2: Cross-Verification ===${c.reset}\n`);

    // Each contributor signs a message
    for (const id of contributorIds) {
      const message = `Hello from ${id} at ${Date.now()}`;
      network.broadcastMessage(id, message);
      console.log(`  ${c.cyan}[${id}]${c.reset} Broadcast: "${message.substring(0, 40)}..."`);
    }

    // Verify all signatures
    const verifications = network.verifyAllMessages();
    const allValid = verifications.every(v => v.valid);

    console.log(`\n  ${c.bold}Verification Results:${c.reset}`);
    verifications.forEach(v => {
      console.log(`    ${v.valid ? c.green + '✓' : c.red + '✗'}${c.reset} ${v.from} → ${v.verifiedBy}`);
    });
    console.log(`\n${allValid ? c.green + '✓' : c.red + '✗'}${c.reset} All ${verifications.length} verifications ${allValid ? 'passed' : 'FAILED'}\n`);

    // ==== Phase 3: Pattern Storage ====
    console.log(`${c.bold}=== Phase 3: Pattern Storage & Learning ===${c.reset}\n`);

    // Each contributor stores some patterns
    const patternData = {
      alice: [
        { centroid: [1.0, 0.0, 0.0], confidence: 0.95, task: 'compute' },
        { centroid: [0.9, 0.1, 0.0], confidence: 0.88, task: 'inference' }
      ],
      bob: [
        { centroid: [0.0, 1.0, 0.0], confidence: 0.92, task: 'training' },
        { centroid: [0.1, 0.9, 0.0], confidence: 0.85, task: 'validation' }
      ],
      charlie: [
        { centroid: [0.0, 0.0, 1.0], confidence: 0.90, task: 'storage' },
        { centroid: [0.1, 0.1, 0.8], confidence: 0.87, task: 'retrieval' }
      ]
    };

    for (const [id, patterns] of Object.entries(patternData)) {
      const contributor = network.contributors.get(id);
      patterns.forEach(p => contributor.storePattern(p));
      console.log(`  ${c.cyan}[${id}]${c.reset} Stored ${patterns.length} patterns`);
    }

    // Lookup patterns
    console.log(`\n  ${c.bold}Pattern Lookups:${c.reset}`);
    const alice = network.contributors.get('alice');
    const similar = alice.lookupPatterns([0.95, 0.05, 0.0], 2);
    console.log(`    Alice searches for [0.95, 0.05, 0.0]: Found ${similar.length} similar patterns`);
    similar.forEach((p, i) => {
      console.log(`      ${i + 1}. similarity=${p.similarity.toFixed(3)}, task=${p.pattern?.task || 'unknown'}`);
    });

    const totalPatterns = network.sharePatterns();
    console.log(`\n${c.green}✓${c.reset} Total patterns in network: ${totalPatterns.length}\n`);

    // ==== Phase 4: Coherence Check ====
    console.log(`${c.bold}=== Phase 4: Coherence State ===${c.reset}\n`);

    for (const [id, contributor] of network.contributors) {
      const stats = contributor.getCoherenceStats();
      console.log(`  ${c.cyan}[${id}]${c.reset} Merkle: ${contributor.coherence.getMerkleRoot().substring(0, 16)}... | Events: ${stats.total_events || 0}`);
    }

    // ==== Phase 5: Persistence ====
    console.log(`\n${c.bold}=== Phase 5: Persistence ===${c.reset}\n`);

    const { states, networkState } = network.persistAll();

    console.log(`  ${c.green}✓${c.reset} Network state persisted`);
    console.log(`    Contributors: ${networkState.contributors.length}`);
    console.log(`    Messages: ${networkState.messages.length}`);
    console.log(`    Total patterns: ${networkState.totalPatterns}`);

    for (const [id, state] of Object.entries(states)) {
      console.log(`\n  ${c.cyan}[${id}]${c.reset} State saved:`);
      console.log(`    Node ID: ${state.nodeId}`);
      console.log(`    Patterns: ${state.stats.patternCount}`);
      console.log(`    Ledger TX: ${state.stats.txCount}`);
    }

    // ==== Phase 6: Verify Persistence ====
    console.log(`\n${c.bold}=== Phase 6: Verify Persistence Files ===${c.reset}\n`);

    const files = readdirSync(storageDir);
    console.log(`  Files in ${storageDir}:`);
    files.forEach(f => {
      const path = join(storageDir, f);
      const stat = existsSync(path) ? readFileSync(path).length : 0;
      console.log(`    ${c.dim}•${c.reset} ${f} (${stat} bytes)`);
    });

    // ==== Summary ====
    console.log(`
${c.cyan}╔═══════════════════════════════════════════════════════════════╗${c.reset}
${c.cyan}║${c.reset}  ${c.bold}${c.green}All Tests Passed!${c.reset}                                          ${c.cyan}║${c.reset}
${c.cyan}╚═══════════════════════════════════════════════════════════════╝${c.reset}

${c.bold}Summary:${c.reset}
  • ${c.green}✓${c.reset} ${network.contributors.size} contributors initialized with persistent identities
  • ${c.green}✓${c.reset} ${verifications.length} cross-verifications passed
  • ${c.green}✓${c.reset} ${totalPatterns.length} patterns stored and searchable
  • ${c.green}✓${c.reset} State persisted to ${storageDir}
  • ${c.green}✓${c.reset} ${isContinuation ? 'Continued from' : 'Started'} session

${c.dim}Run again to test persistence restoration!${c.reset}
`);

  } finally {
    network.cleanup();
  }
}

// Run
runMultiContributorTest().catch(err => {
  console.error(`${c.red}Error: ${err.message}${c.reset}`);
  console.error(err.stack);
  process.exit(1);
});