#!/usr/bin/env node
/**
 * Edge-Net Multi-Network Module
 *
 * Enables creation, discovery, and contribution to multiple edge networks.
 * Each network is cryptographically isolated with its own:
 * - Genesis block and network ID
 * - QDAG ledger
 * - Peer registry
 * - Access control (public/private/invite-only)
 *
 * Security Features:
 * - Network ID derived from genesis hash (tamper-evident)
 * - Ed25519 signatures for network announcements
 * - Optional invite codes for private networks
 * - Cryptographic proof of network membership
 */

import { createHash, randomBytes } from 'crypto';
import { promises as fs } from 'fs';
import { homedir } from 'os';
import { join, dirname } from 'path';
import { fileURLToPath } from 'url';
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';

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

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

const c = (color, text) => `${colors[color]}${text}${colors.reset}`;

// Network types
const NetworkType = {
  PUBLIC: 'public',        // Anyone can join and discover
  PRIVATE: 'private',      // Requires invite code to join
  CONSORTIUM: 'consortium', // Requires approval from existing members
};

// Well-known public networks (bootstrap)
const WELL_KNOWN_NETWORKS = [
  {
    id: 'mainnet',
    name: 'Edge-Net Mainnet',
    description: 'Primary public compute network',
    type: NetworkType.PUBLIC,
    genesisHash: 'edgenet-mainnet-genesis-v1',
    bootstrapNodes: ['edge-net.ruvector.dev:9000'],
    created: '2024-01-01T00:00:00Z',
  },
  {
    id: 'testnet',
    name: 'Edge-Net Testnet',
    description: 'Testing and development network',
    type: NetworkType.PUBLIC,
    genesisHash: 'edgenet-testnet-genesis-v1',
    bootstrapNodes: ['testnet.ruvector.dev:9000'],
    created: '2024-01-01T00:00:00Z',
  },
];

// Directory structure
function getNetworksDir() {
  const dir = join(homedir(), '.ruvector', 'networks');
  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
  return dir;
}

function getRegistryFile() {
  return join(getNetworksDir(), 'registry.json');
}

function getNetworkDir(networkId) {
  const dir = join(getNetworksDir(), networkId);
  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
  return dir;
}

/**
 * Network Genesis - defines a network's identity
 */
export class NetworkGenesis {
  constructor(options = {}) {
    this.version = 1;
    this.name = options.name || 'Custom Network';
    this.description = options.description || 'A custom edge-net network';
    this.type = options.type || NetworkType.PUBLIC;
    this.creator = options.creator || null; // Creator's public key
    this.creatorSiteId = options.creatorSiteId || 'anonymous';
    this.created = options.created || new Date().toISOString();
    this.parameters = {
      minContributors: options.minContributors || 1,
      confirmationThreshold: options.confirmationThreshold || 3,
      creditMultiplier: options.creditMultiplier || 1.0,
      maxPeers: options.maxPeers || 100,
      ...options.parameters,
    };
    this.inviteRequired = this.type !== NetworkType.PUBLIC;
    this.approvers = options.approvers || []; // For consortium networks
    this.nonce = options.nonce || randomBytes(16).toString('hex');
  }

  /**
   * Compute network ID from genesis hash
   */
  computeNetworkId() {
    const data = JSON.stringify({
      version: this.version,
      name: this.name,
      type: this.type,
      creator: this.creator,
      created: this.created,
      parameters: this.parameters,
      nonce: this.nonce,
    });

    const hash = createHash('sha256').update(data).digest('hex');
    return `net-${hash.slice(0, 16)}`;
  }

  /**
   * Create signed genesis block
   */
  createSignedGenesis(signFn) {
    const genesis = {
      ...this,
      networkId: this.computeNetworkId(),
    };

    if (signFn) {
      const dataToSign = JSON.stringify(genesis);
      genesis.signature = signFn(dataToSign);
    }

    return genesis;
  }

  /**
   * Generate invite code for private networks
   */
  generateInviteCode() {
    if (this.type === NetworkType.PUBLIC) {
      throw new Error('Public networks do not require invite codes');
    }

    const networkId = this.computeNetworkId();
    const secret = randomBytes(16).toString('hex');
    const code = Buffer.from(`${networkId}:${secret}`).toString('base64url');

    return {
      code,
      networkId,
      validUntil: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(), // 7 days
    };
  }
}

/**
 * Network Registry - manages known networks
 */
export class NetworkRegistry {
  constructor() {
    this.networks = new Map();
    this.activeNetwork = null;
    this.loaded = false;
  }

  async load() {
    try {
      // Load well-known networks
      for (const network of WELL_KNOWN_NETWORKS) {
        this.networks.set(network.id, {
          ...network,
          isWellKnown: true,
          joined: false,
          stats: null,
        });
      }

      // Load user's network registry
      if (existsSync(getRegistryFile())) {
        const data = JSON.parse(await fs.readFile(getRegistryFile(), 'utf-8'));

        for (const network of data.networks || []) {
          this.networks.set(network.id, {
            ...network,
            isWellKnown: false,
          });
        }

        this.activeNetwork = data.activeNetwork || null;
      }

      this.loaded = true;
    } catch (err) {
      console.error('Failed to load network registry:', err.message);
    }
  }

  async save() {
    const data = {
      version: 1,
      activeNetwork: this.activeNetwork,
      networks: Array.from(this.networks.values()).filter(n => !n.isWellKnown),
      savedAt: new Date().toISOString(),
    };

    await fs.writeFile(getRegistryFile(), JSON.stringify(data, null, 2));
  }

  /**
   * Create a new network
   */
  async createNetwork(options, identity) {
    const genesis = new NetworkGenesis({
      ...options,
      creator: identity?.publicKey,
      creatorSiteId: identity?.siteId,
    });

    const networkId = genesis.computeNetworkId();

    // Create network directory structure
    const networkDir = getNetworkDir(networkId);
    await fs.mkdir(join(networkDir, 'peers'), { recursive: true });

    // Save genesis block
    const genesisData = genesis.createSignedGenesis(
      identity?.sign ? (data) => identity.sign(data) : null
    );
    await fs.writeFile(
      join(networkDir, 'genesis.json'),
      JSON.stringify(genesisData, null, 2)
    );

    // Initialize QDAG for this network
    const qdag = {
      networkId,
      nodes: [{
        id: 'genesis',
        type: 'genesis',
        timestamp: Date.now(),
        message: `Genesis: ${genesis.name}`,
        parents: [],
        weight: 1,
        confirmations: 0,
      }],
      tips: ['genesis'],
      confirmed: ['genesis'],
      createdAt: Date.now(),
    };
    await fs.writeFile(
      join(networkDir, 'qdag.json'),
      JSON.stringify(qdag, null, 2)
    );

    // Initialize peer list
    await fs.writeFile(
      join(networkDir, 'peers.json'),
      JSON.stringify([], null, 2)
    );

    // Register network
    const networkEntry = {
      id: networkId,
      name: genesis.name,
      description: genesis.description,
      type: genesis.type,
      creator: genesis.creator,
      creatorSiteId: genesis.creatorSiteId,
      created: genesis.created,
      parameters: genesis.parameters,
      genesisHash: createHash('sha256')
        .update(JSON.stringify(genesisData))
        .digest('hex')
        .slice(0, 32),
      joined: true,
      isOwner: true,
      stats: { nodes: 1, contributors: 0, credits: 0 },
    };

    this.networks.set(networkId, networkEntry);
    await this.save();

    // Generate invite codes if private
    let inviteCodes = null;
    if (genesis.type !== NetworkType.PUBLIC) {
      inviteCodes = [];
      for (let i = 0; i < 5; i++) {
        inviteCodes.push(genesis.generateInviteCode());
      }
      await fs.writeFile(
        join(networkDir, 'invites.json'),
        JSON.stringify(inviteCodes, null, 2)
      );
    }

    return { networkId, genesis: genesisData, inviteCodes };
  }

  /**
   * Join an existing network
   */
  async joinNetwork(networkId, inviteCode = null) {
    const network = this.networks.get(networkId);

    if (!network) {
      throw new Error(`Network not found: ${networkId}`);
    }

    if (network.joined) {
      return { alreadyJoined: true, network };
    }

    // Verify invite code for private networks
    if (network.type === NetworkType.PRIVATE) {
      if (!inviteCode) {
        throw new Error('Private network requires invite code');
      }

      const isValid = await this.verifyInviteCode(networkId, inviteCode);
      if (!isValid) {
        throw new Error('Invalid or expired invite code');
      }
    }

    // Create local network directory
    const networkDir = getNetworkDir(networkId);

    // For well-known networks, create initial structure
    if (network.isWellKnown) {
      const qdag = {
        networkId,
        nodes: [{
          id: 'genesis',
          type: 'genesis',
          timestamp: Date.now(),
          message: `Joined: ${network.name}`,
          parents: [],
          weight: 1,
          confirmations: 0,
        }],
        tips: ['genesis'],
        confirmed: ['genesis'],
        createdAt: Date.now(),
      };
      await fs.writeFile(
        join(networkDir, 'qdag.json'),
        JSON.stringify(qdag, null, 2)
      );

      await fs.writeFile(
        join(networkDir, 'peers.json'),
        JSON.stringify([], null, 2)
      );
    }

    network.joined = true;
    network.joinedAt = new Date().toISOString();
    await this.save();

    return { joined: true, network };
  }

  /**
   * Verify invite code
   */
  async verifyInviteCode(networkId, code) {
    try {
      const decoded = Buffer.from(code, 'base64url').toString();
      const [codeNetworkId, secret] = decoded.split(':');

      if (codeNetworkId !== networkId) {
        return false;
      }

      // In production, verify against network's invite registry
      // For local simulation, accept any properly formatted code
      return secret && secret.length === 32;
    } catch {
      return false;
    }
  }

  /**
   * Discover networks from DHT/registry
   */
  async discoverNetworks(options = {}) {
    const discovered = [];

    // Always include well-known networks
    for (const network of WELL_KNOWN_NETWORKS) {
      const existing = this.networks.get(network.id);
      discovered.push({
        ...network,
        joined: existing?.joined || false,
        source: 'well-known',
      });
    }

    // Scan for locally known networks
    try {
      const networksDir = getNetworksDir();
      const dirs = await fs.readdir(networksDir);

      for (const dir of dirs) {
        if (dir === 'registry.json') continue;

        const genesisPath = join(networksDir, dir, 'genesis.json');
        if (existsSync(genesisPath)) {
          try {
            const genesis = JSON.parse(await fs.readFile(genesisPath, 'utf-8'));
            const existing = this.networks.get(genesis.networkId || dir);

            if (!existing?.isWellKnown) {
              discovered.push({
                id: genesis.networkId || dir,
                name: genesis.name,
                description: genesis.description,
                type: genesis.type,
                creator: genesis.creatorSiteId,
                created: genesis.created,
                joined: existing?.joined || false,
                source: 'local',
              });
            }
          } catch (e) {
            // Skip invalid genesis files
          }
        }
      }
    } catch (err) {
      // Networks directory doesn't exist yet
    }

    // In production: Query DHT/bootstrap nodes for public networks
    // This is simulated here

    return discovered;
  }

  /**
   * Set active network for contributions
   */
  async setActiveNetwork(networkId) {
    const network = this.networks.get(networkId);

    if (!network) {
      throw new Error(`Network not found: ${networkId}`);
    }

    if (!network.joined) {
      throw new Error(`Must join network first: ${networkId}`);
    }

    this.activeNetwork = networkId;
    await this.save();

    return network;
  }

  /**
   * Get network info
   */
  getNetwork(networkId) {
    return this.networks.get(networkId);
  }

  /**
   * Get active network
   */
  getActiveNetwork() {
    if (!this.activeNetwork) return null;
    return this.networks.get(this.activeNetwork);
  }

  /**
   * Get all joined networks
   */
  getJoinedNetworks() {
    return Array.from(this.networks.values()).filter(n => n.joined);
  }

  /**
   * Get network statistics
   */
  async getNetworkStats(networkId) {
    const networkDir = getNetworkDir(networkId);
    const qdagPath = join(networkDir, 'qdag.json');
    const peersPath = join(networkDir, 'peers.json');

    const stats = {
      nodes: 0,
      contributions: 0,
      contributors: 0,
      credits: 0,
      peers: 0,
    };

    try {
      if (existsSync(qdagPath)) {
        const qdag = JSON.parse(await fs.readFile(qdagPath, 'utf-8'));
        const contributions = (qdag.nodes || []).filter(n => n.type === 'contribution');

        stats.nodes = qdag.nodes?.length || 0;
        stats.contributions = contributions.length;
        stats.contributors = new Set(contributions.map(c => c.contributor)).size;
        stats.credits = contributions.reduce((sum, c) => sum + (c.credits || 0), 0);
      }

      if (existsSync(peersPath)) {
        const peers = JSON.parse(await fs.readFile(peersPath, 'utf-8'));
        stats.peers = peers.length;
      }
    } catch (err) {
      // Stats not available
    }

    return stats;
  }

  /**
   * List all networks
   */
  listNetworks() {
    return Array.from(this.networks.values());
  }
}

/**
 * Multi-Network Manager - coordinates contributions across networks
 */
export class MultiNetworkManager {
  constructor(identity) {
    this.identity = identity;
    this.registry = new NetworkRegistry();
    this.activeConnections = new Map();
  }

  async initialize() {
    await this.registry.load();
    return this;
  }

  /**
   * Create a new network
   */
  async createNetwork(options) {
    console.log(`\n${c('cyan', 'Creating new network...')}\n`);

    const result = await this.registry.createNetwork(options, this.identity);

    console.log(`${c('green', '✓')} Network created successfully!`);
    console.log(`  ${c('cyan', 'Network ID:')}   ${result.networkId}`);
    console.log(`  ${c('cyan', 'Name:')}         ${options.name}`);
    console.log(`  ${c('cyan', 'Type:')}         ${options.type}`);
    console.log(`  ${c('cyan', 'Description:')}  ${options.description || 'N/A'}`);

    if (result.inviteCodes) {
      console.log(`\n${c('bold', 'Invite Codes (share these to invite members):')}`);
      for (const invite of result.inviteCodes.slice(0, 3)) {
        console.log(`  ${c('yellow', invite.code)}`);
      }
      console.log(`  ${c('dim', `(${result.inviteCodes.length} codes saved to network directory)`)}`);
    }

    console.log(`\n${c('dim', 'Network directory:')} ~/.ruvector/networks/${result.networkId}`);

    return result;
  }

  /**
   * Discover available networks
   */
  async discoverNetworks() {
    console.log(`\n${c('cyan', 'Discovering networks...')}\n`);

    const networks = await this.registry.discoverNetworks();

    if (networks.length === 0) {
      console.log(`  ${c('dim', 'No networks found.')}`);
      return networks;
    }

    console.log(`${c('bold', 'Available Networks:')}\n`);

    for (const network of networks) {
      const status = network.joined ? c('green', '● Joined') : c('dim', '○ Not joined');
      const typeIcon = network.type === NetworkType.PUBLIC ? '🌐' :
                       network.type === NetworkType.PRIVATE ? '🔒' : '🏢';

      console.log(`  ${status} ${typeIcon} ${c('bold', network.name)}`);
      console.log(`    ${c('dim', 'ID:')}          ${network.id}`);
      console.log(`    ${c('dim', 'Type:')}        ${network.type}`);
      console.log(`    ${c('dim', 'Description:')} ${network.description || 'N/A'}`);
      console.log(`    ${c('dim', 'Source:')}      ${network.source}`);
      console.log('');
    }

    return networks;
  }

  /**
   * Join a network
   */
  async joinNetwork(networkId, inviteCode = null) {
    console.log(`\n${c('cyan', `Joining network ${networkId}...`)}\n`);

    try {
      const result = await this.registry.joinNetwork(networkId, inviteCode);

      if (result.alreadyJoined) {
        console.log(`${c('yellow', '⚠')} Already joined network: ${result.network.name}`);
      } else {
        console.log(`${c('green', '✓')} Successfully joined: ${result.network.name}`);
      }

      // Set as active if it's the only joined network
      const joinedNetworks = this.registry.getJoinedNetworks();
      if (joinedNetworks.length === 1) {
        await this.registry.setActiveNetwork(networkId);
        console.log(`  ${c('dim', 'Set as active network')}`);
      }

      return result;
    } catch (err) {
      console.log(`${c('red', '✗')} Failed to join: ${err.message}`);
      throw err;
    }
  }

  /**
   * Switch active network
   */
  async switchNetwork(networkId) {
    const network = await this.registry.setActiveNetwork(networkId);
    console.log(`${c('green', '✓')} Active network: ${network.name} (${networkId})`);
    return network;
  }

  /**
   * Show network status
   */
  async showStatus() {
    const active = this.registry.getActiveNetwork();
    const joined = this.registry.getJoinedNetworks();

    console.log(`\n${c('bold', 'NETWORK STATUS:')}\n`);

    if (!active) {
      console.log(`  ${c('yellow', '⚠')} No active network`);
      console.log(`  ${c('dim', 'Join a network to start contributing')}\n`);
      return;
    }

    const stats = await this.registry.getNetworkStats(active.id);

    console.log(`${c('bold', 'Active Network:')}`);
    console.log(`  ${c('cyan', 'Name:')}         ${active.name}`);
    console.log(`  ${c('cyan', 'ID:')}           ${active.id}`);
    console.log(`  ${c('cyan', 'Type:')}         ${active.type}`);
    console.log(`  ${c('cyan', 'QDAG Nodes:')}   ${stats.nodes}`);
    console.log(`  ${c('cyan', 'Contributions:')} ${stats.contributions}`);
    console.log(`  ${c('cyan', 'Contributors:')} ${stats.contributors}`);
    console.log(`  ${c('cyan', 'Total Credits:')} ${stats.credits}`);
    console.log(`  ${c('cyan', 'Connected Peers:')} ${stats.peers}`);

    if (joined.length > 1) {
      console.log(`\n${c('bold', 'Other Joined Networks:')}`);
      for (const network of joined) {
        if (network.id !== active.id) {
          console.log(`  ${c('dim', '○')} ${network.name} (${network.id})`);
        }
      }
    }

    console.log('');
  }

  /**
   * Get active network directory for contributions
   */
  getActiveNetworkDir() {
    const active = this.registry.getActiveNetwork();
    if (!active) return null;
    return getNetworkDir(active.id);
  }
}

// CLI interface
async function main() {
  const args = process.argv.slice(2);
  const command = args[0];

  const registry = new NetworkRegistry();
  await registry.load();

  if (command === 'list' || command === 'ls') {
    console.log(`\n${c('bold', 'NETWORKS:')}\n`);

    const networks = registry.listNetworks();
    const active = registry.activeNetwork;

    for (const network of networks) {
      const isActive = network.id === active;
      const status = network.joined ?
        (isActive ? c('green', '● Active') : c('cyan', '○ Joined')) :
        c('dim', '  Available');
      const typeIcon = network.type === NetworkType.PUBLIC ? '🌐' :
                       network.type === NetworkType.PRIVATE ? '🔒' : '🏢';

      console.log(`  ${status} ${typeIcon} ${c('bold', network.name)}`);
      console.log(`    ${c('dim', 'ID:')} ${network.id}`);
      if (network.description) {
        console.log(`    ${c('dim', network.description)}`);
      }
      console.log('');
    }

  } else if (command === 'discover') {
    const manager = new MultiNetworkManager(null);
    await manager.initialize();
    await manager.discoverNetworks();

  } else if (command === 'create') {
    const name = args[1] || 'My Network';
    const type = args.includes('--private') ? NetworkType.PRIVATE :
                 args.includes('--consortium') ? NetworkType.CONSORTIUM :
                 NetworkType.PUBLIC;
    const description = args.find((a, i) => args[i - 1] === '--desc') || '';

    const manager = new MultiNetworkManager(null);
    await manager.initialize();
    await manager.createNetwork({ name, type, description });

  } else if (command === 'join') {
    const networkId = args[1];
    const inviteCode = args.find((a, i) => args[i - 1] === '--invite');

    if (!networkId) {
      console.log(`${c('red', '✗')} Usage: networks join <network-id> [--invite <code>]`);
      process.exit(1);
    }

    const manager = new MultiNetworkManager(null);
    await manager.initialize();
    await manager.joinNetwork(networkId, inviteCode);

  } else if (command === 'switch' || command === 'use') {
    const networkId = args[1];

    if (!networkId) {
      console.log(`${c('red', '✗')} Usage: networks switch <network-id>`);
      process.exit(1);
    }

    const manager = new MultiNetworkManager(null);
    await manager.initialize();
    await manager.switchNetwork(networkId);

  } else if (command === 'status') {
    const manager = new MultiNetworkManager(null);
    await manager.initialize();
    await manager.showStatus();

  } else if (command === 'help' || !command) {
    console.log(`
${c('bold', 'Edge-Net Multi-Network Manager')}

${c('bold', 'COMMANDS:')}
  ${c('green', 'list')}       List all known networks
  ${c('green', 'discover')}   Discover available networks
  ${c('green', 'create')}     Create a new network
  ${c('green', 'join')}       Join an existing network
  ${c('green', 'switch')}     Switch active network
  ${c('green', 'status')}     Show current network status
  ${c('green', 'help')}       Show this help

${c('bold', 'EXAMPLES:')}
  ${c('dim', '# List networks')}
  $ node networks.js list

  ${c('dim', '# Create a public network')}
  $ node networks.js create "My Research Network" --desc "For ML research"

  ${c('dim', '# Create a private network')}
  $ node networks.js create "Team Network" --private

  ${c('dim', '# Join a network')}
  $ node networks.js join net-abc123def456

  ${c('dim', '# Join a private network with invite')}
  $ node networks.js join net-xyz789 --invite <invite-code>

  ${c('dim', '# Switch active network')}
  $ node networks.js switch net-abc123def456

${c('bold', 'NETWORK TYPES:')}
  ${c('cyan', '🌐 Public')}      Anyone can join and discover
  ${c('cyan', '🔒 Private')}     Requires invite code to join
  ${c('cyan', '🏢 Consortium')}  Requires approval from members
`);
  }
}

main().catch(console.error);