// Example: Custom Bitcoin Transceiver with WebSocket connection
const { UTXOTransceiver } = require('fractaledger');
const WebSocket = require('ws');

class BitcoinWebSocketTransceiver extends UTXOTransceiver {
  constructor(config = {}) {
    super(config);
    
    this.apiUrl = config.apiUrl || 'https://blockstream.info/api';
    this.wsUrl = config.wsUrl || 'wss://blockstream.info/api/ws';
    this.connections = new Map();
    
    // Initialize any other required properties
    this.monitoredAddresses = new Map();
    this.monitoringConnections = new Map();
    
    console.log('Bitcoin WebSocket Transceiver initialized');
  }
  
  // Implement required methods...
}

module.exports = BitcoinWebSocketTransceiver;

async monitorWalletAddress(address, callback) {
  console.log(`Starting to monitor wallet address: ${address}`);
  
  try {
    // Check if the address is already being monitored
    if (this.monitoredAddresses.has(address)) {
      return this.monitoredAddresses.get(address);
    }
    
    // Create a WebSocket connection for this address
    const ws = new WebSocket(`${this.wsUrl}/address/${address}`);
    
    ws.onopen = () => {
      console.log(`WebSocket connection established for ${address}`);
    };
    
    ws.onmessage = (event) => {
      try {
        const data = JSON.parse(event.data);
        
        // Process the transaction data
        const transaction = {
          txid: data.txid,
          amount: this.calculateAmount(data, address),
          timestamp: Date.now(),
          confirmations: data.status.confirmed ? 1 : 0
        };
        
        // Call the callback with the transaction data
        callback([transaction]);
        
        // Emit a transactions event
        this.emit('transactions', {
          address,
          transactions: [transaction]
        });
      } catch (error) {
        console.error(`Error processing WebSocket message: ${error.message}`);
      }
    };
    
    ws.onerror = (error) => {
      console.error(`WebSocket error for ${address}: ${error.message}`);
    };
    
    ws.onclose = () => {
      console.log(`WebSocket connection closed for ${address}`);
      
      // Attempt to reconnect after a delay
      setTimeout(() => {
        if (this.monitoredAddresses.has(address)) {
          console.log(`Attempting to reconnect WebSocket for ${address}`);
          this.monitorWalletAddress(address, callback);
        }
      }, 5000);
    };
    
    // Store the WebSocket connection
    this.monitoringConnections.set(address, ws);
    
    // Store the monitoring details
    this.monitoredAddresses.set(address, {
      address,
      callback,
      timestamp: Date.now(),
      status: 'active',
      method: 'websocket'
    });
    
    return {
      address,
      status: 'active',
      method: 'websocket'
    };
  } catch (error) {
    console.error(`Failed to monitor address ${address}: ${error.message}`);
    throw new Error(`Failed to monitor address ${address}: ${error.message}`);
  }
}

async broadcastTransaction(txHex, metadata = {}) {
  console.log(`Broadcasting transaction: ${metadata.txid || 'unknown'}`);
  
  try {
    // Use the REST API to broadcast the transaction
    const response = await fetch(`${this.apiUrl}/tx`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ txHex })
    });
    
    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`API error: ${errorData.message || response.statusText}`);
    }
    
    const result = await response.json();
    
    // Emit a transaction event
    this.emit('transaction', {
      txid: result.txid,
      txHex,
      metadata,
      timestamp: Date.now()
    });
    
    return result.txid;
  } catch (error) {
    console.error(`Failed to broadcast transaction: ${error.message}`);
    throw new Error(`Failed to broadcast transaction: ${error.message}`);
  }
}

// In your transceiver configuration
{
  "name": "btc_wallet_1",
  "network": "mainnet",
  "walletAddress": "bc1q...",
  "secretEnvVar": "BTC_WALLET_1_SECRET",
  "transceiver": {
    "method": "callback",
    "module": "./transceivers/bitcoin-websocket-transceiver.js",
    "config": {
      "apiUrl": "https://blockstream.info/api",
      "wsUrl": "wss://blockstream.info/api/ws",
      "autoMonitor": true
    }
  }
}

// In your transceiver's initialize method
async initialize() {
  console.log('Initializing Bitcoin WebSocket Transceiver');
  
  try {
    // If autoMonitor is enabled, start monitoring the wallet address
    if (this.config.autoMonitor && this.config.walletAddress) {
      await this.monitorWalletAddress(this.config.walletAddress, (transactions) => {
        console.log(`Detected ${transactions.length} transactions for ${this.config.walletAddress}`);
        // Process the transactions
      });
    }
    
    console.log('Bitcoin WebSocket Transceiver initialized successfully');
  } catch (error) {
    console.error(`Failed to initialize Bitcoin WebSocket Transceiver: ${error.message}`);
    throw new Error(`Failed to initialize Bitcoin WebSocket Transceiver: ${error.message}`);
  }
}

async stopMonitoringWalletAddress(address) {
  console.log(`Stopping monitoring for wallet address: ${address}`);
  
  try {
    // Check if the address is being monitored
    if (!this.monitoredAddresses.has(address)) {
      console.log(`Address ${address} is not being monitored`);
      return false;
    }
    
    // Get the WebSocket connection
    const ws = this.monitoringConnections.get(address);
    
    // Close the WebSocket connection
    if (ws && ws.readyState !== WebSocket.CLOSED) {
      ws.close();
    }
    
    // Remove the connection from the maps
    this.monitoringConnections.delete(address);
    this.monitoredAddresses.delete(address);
    
    console.log(`Stopped monitoring address ${address}`);
    
    return true;
  } catch (error) {
    console.error(`Failed to stop monitoring address ${address}: ${error.message}`);
    throw new Error(`Failed to stop monitoring address ${address}: ${error.message}`);
  }
}

async cleanup() {
  console.log('Cleaning up Bitcoin WebSocket Transceiver resources');
  
  try {
    // Close all WebSocket connections
    for (const [address, ws] of this.monitoringConnections.entries()) {
      if (ws && ws.readyState !== WebSocket.CLOSED) {
        ws.close();
      }
    }
    
    // Clear all maps
    this.monitoringConnections.clear();
    this.monitoredAddresses.clear();
    
    console.log('Bitcoin WebSocket Transceiver resources cleaned up successfully');
  } catch (error) {
    console.error(`Failed to clean up Bitcoin WebSocket Transceiver resources: ${error.message}`);
    throw new Error(`Failed to clean up Bitcoin WebSocket Transceiver resources: ${error.message}`);
  }
}