const express = require('express');
const http = require('http');
const WebSocket = require('ws');
const { WS402, MockPaymentProvider } = require('ws402');

const app = express();
const server = http.createServer(app);
const wss = new WebSocket.Server({ server });

// Initialize payment provider (mock for development)
const paymentProvider = new MockPaymentProvider();

// Create WS402 instance
const ws402 = new WS402(
  {
    updateInterval: 3000,      // Send updates every 3 seconds
    pricePerSecond: 10,        // Price per second in wei
    currency: 'wei',
    maxSessionDuration: 600,   // Max 10 minutes per session
    
    onPaymentVerified: (session) => {
      console.log(`✅ Payment verified: ${session.sessionId}`);
    },
    
    onRefundIssued: (session, refund) => {
      console.log(`💰 Refund issued: ${refund.amount} wei`);
    },
    
    onSessionEnd: (session) => {
      console.log(`🔚 Session ended: ${session.sessionId}`);
    },
  },
  paymentProvider
);

// Attach to WebSocket server
ws402.attach(wss);

// Serve WS402 schema
app.get('/ws402/schema/:resourceId', (req, res) => {
  const schema = ws402.generateSchema(
    req.params.resourceId,
    300 // estimated duration in seconds
  );
  res.json(schema);
});

server.listen(4028);

// 1. Fetch WS402 schema
const response = await fetch('/ws402/schema/my-resource?duration=300');
const schema = await response.json();

// 2. Make payment (using blockchain or other method)
// ... payment process ...

// 3. Connect to WebSocket
const ws = new WebSocket(`wss://your-server.com?userId=alice`);

// 4. Send payment proof
ws.onopen = () => {
  ws.send(JSON.stringify({
    type: 'payment_proof',
    proof: {
      txHash: '0x123...', // Blockchain transaction hash
      reference: schema.paymentDetails.reference,
      senderAddress: '0xYourAddress...',
      amount: schema.pricing.totalPrice,
    }
  }));
};

// 5. Receive usage updates
ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  
  if (data.type === 'session_started') {
    console.log('✅ Session active!', data.sessionId);
  }
  
  if (data.type === 'usage_update') {
    console.log(`⏱️  Time: ${data.elapsedSeconds}s`);
    console.log(`💰 Remaining: ${data.remainingBalance} wei`);
  }
  
  if (data.type === 'balance_exhausted') {
    console.log('⚠️  Balance exhausted');
  }
};

// 6. Disconnect to trigger automatic refund
ws.close();

const { WS402, BasePaymentProvider } = require('ws402');

const baseProvider = new BasePaymentProvider({
  rpcEndpoint: 'https://mainnet.base.org',
  merchantWallet: '0xYourWalletAddress',
  merchantPrivateKey: process.env.MERCHANT_PRIVATE_KEY, // For automatic refunds
  network: 'base', // 'base' | 'base-goerli' | 'base-sepolia'
  autoRefund: true,
});

const ws402 = new WS402(config, baseProvider);

const { WS402, SolanaPaymentProvider } = require('ws402');

const solanaProvider = new SolanaPaymentProvider({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  merchantWallet: 'YourSolanaPublicKey',
  merchantPrivateKey: [1, 2, 3, ...], // Array from wallet JSON
  network: 'mainnet-beta',
  conversionRate: 1, // 1:1 lamports
  label: 'WS402 Payment',
  message: 'Pay for WebSocket access',
  autoRefund: true,
});

const ws402 = new WS402(config, solanaProvider);

// From base58 string (Phantom export)
const privateKey = bs58.decode('4p8Qsp4esg...');

// Or from JSON array
const privateKey = [1, 2, 3, ..., 64];

// Use in provider
const solanaProvider = new SolanaPaymentProvider({
  // ...other config
  merchantPrivateKey: Array.from(privateKey),
});

const ws402 = new WS402(
  {
    updateInterval: 3000,          // Update every 3 seconds
    pricePerSecond: 100000,        // 0.0001 SOL per second
    currency: 'lamports',
    maxSessionDuration: 3600,      // 1 hour max
    
    onPaymentVerified: (session) => {
      console.log(`✅ Payment verified: ${session.sessionId}`);
      console.log(`   Amount: ${session.paidAmount / 1e9} SOL`);
    },
    
    onRefundIssued: (session, refund) => {
      console.log(`💰 Refund: ${refund.amount / 1e9} SOL`);
    },
  },
  solanaProvider
);

const { WS402HTTPMiddleware } = require('ws402');

// Initialize HTTP middleware
const httpMiddleware = new WS402HTTPMiddleware(ws402);

// Different resources can have different prices
const RESOURCES = {
  'premium-report': {
    type: 'pdf',
    path: './reports/premium.pdf',
    pricePerSecond: 500000,      // 0.0005 SOL/sec
    estimatedTime: 600,          // 10 minutes
  },
  'basic-guide': {
    type: 'pdf',
    path: './guides/basic.pdf',
    pricePerSecond: 100000,      // 0.0001 SOL/sec
    estimatedTime: 300,          // 5 minutes
  },
};

// Schema endpoint with resource-specific pricing
app.get('/api/resource/:resourceId/schema', (req, res) => {
  const resource = RESOURCES[req.params.resourceId];
  
  const schema = ws402.generateSchema(
    req.params.resourceId,
    resource.estimatedTime,
    resource.pricePerSecond  // Custom price per resource
  );
  
  res.json({ ws402Schema: schema });
});

// Protected resource endpoint
app.get('/api/resource/:resourceId',
  httpMiddleware.protectHTTPResource(),
  (req, res) => {
    const resource = RESOURCES[req.params.resourceId];
    res.sendFile(resource.path);
  }
);

// Register HTTP session after WS402 payment
ws402.on('payment_verified', (session) => {
  const token = httpMiddleware.registerHTTPSession(
    session.sessionId,
    session._resourceId
  );
  
  // Send token to client for HTTP access
  clientWs.send(JSON.stringify({
    type: 'http_access_granted',
    httpToken: token,
    resourceUrl: `/api/resource/${session._resourceId}?token=${token}`,
  }));
});

// 1. Get schema
const response = await fetch('/ws402/schema/my-resource?duration=300');
const schema = await response.json();

// 2. Connect to Phantom wallet
if (!window.solana || !window.solana.isPhantom) {
  alert('Please install Phantom wallet');
  return;
}

await window.solana.connect();
const provider = window.solana;

// 3. Create payment transaction
const { Connection, PublicKey, Transaction, SystemProgram } = window.solanaWeb3;

const connection = new Connection('https://api.mainnet-beta.solana.com');
const { blockhash } = await connection.getLatestBlockhash();

const transaction = new Transaction({
  feePayer: provider.publicKey,
  recentBlockhash: blockhash,
});

// Add transfer instruction
transaction.add(
  SystemProgram.transfer({
    fromPubkey: provider.publicKey,
    toPubkey: new PublicKey(schema.paymentDetails.recipient),
    lamports: schema.paymentDetails.amount,
  })
);

// Add reference as read-only account (for tracking)
transaction.add({
  keys: [{ 
    pubkey: new PublicKey(schema.paymentDetails.reference), 
    isSigner: false, 
    isWritable: false 
  }],
  programId: SystemProgram.programId,
  data: Buffer.alloc(0),
});

// 4. Sign and send transaction
const { signature } = await provider.signAndSendTransaction(transaction);
console.log('Payment sent:', signature);

// 5. Connect to WebSocket
const ws = new WebSocket(schema.websocketEndpoint);

ws.onopen = () => {
  // Send payment proof
  ws.send(JSON.stringify({
    type: 'payment_proof',
    proof: {
      signature: signature,
      reference: schema.paymentDetails.reference,
      senderAddress: provider.publicKey.toBase58(),
      amount: schema.paymentDetails.amount,
    }
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  
  if (data.type === 'session_started') {
    console.log('✅ Session started!');
    console.log('Balance:', data.balance / 1e9, 'SOL');
  }
  
  if (data.type === 'usage_update') {
    console.log('Time:', data.elapsedSeconds, 's');
    console.log('Remaining:', data.remainingBalance / 1e9, 'SOL');
  }
};

// 6. Close to trigger refund
ws.close();

import { useState } from 'react';
import { useWallet } from '@solana/wallet-adapter-react';
import { Connection, Transaction, SystemProgram, PublicKey } from '@solana/web3.js';

function PayPerUseStream() {
  const { publicKey, signTransaction } = useWallet();
  const [session, setSession] = useState(null);
  const [ws, setWs] = useState(null);

  const startSession = async () => {
    // 1. Fetch schema
    const res = await fetch('/ws402/schema/stream?duration=600');
    const schema = await res.json();

    // 2. Create payment
    const connection = new Connection('https://api.mainnet-beta.solana.com');
    const { blockhash } = await connection.getLatestBlockhash();

    const tx = new Transaction({ 
      feePayer: publicKey, 
      recentBlockhash: blockhash 
    });

    tx.add(
      SystemProgram.transfer({
        fromPubkey: publicKey,
        toPubkey: new PublicKey(schema.paymentDetails.recipient),
        lamports: schema.paymentDetails.amount,
      })
    );

    const signed = await signTransaction(tx);
    const signature = await connection.sendRawTransaction(signed.serialize());

    // 3. Connect WebSocket
    const websocket = new WebSocket(schema.websocketEndpoint);
    
    websocket.onopen = () => {
      websocket.send(JSON.stringify({
        type: 'payment_proof',
        proof: {
          signature,
          reference: schema.paymentDetails.reference,
          senderAddress: publicKey.toBase58(),
          amount: schema.paymentDetails.amount,
        }
      }));
    };

    websocket.onmessage = (event) => {
      const data = JSON.parse(event.data);
      if (data.type === 'session_started') {
        setSession(data);
      }
      if (data.type === 'usage_update') {
        setSession(prev => ({ ...prev, ...data }));
      }
    };

    setWs(websocket);
  };

  const endSession = () => {
    if (ws) {
      ws.close(); // Triggers automatic refund
    }
  };

  return (
    <div>
      <button onClick={startSession}>Start Session</button>
      {session && (
        <div>
          <p>Time: {session.elapsedSeconds}s</p>
          <p>Remaining: {session.remainingBalance / 1e9} SOL</p>
          <button onClick={endSession}>End & Refund</button>
        </div>
      )}
    </div>
  );
}

const solanaProvider = new SolanaPaymentProvider({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  merchantWallet: 'YourSolanaPublicKey',
  merchantPrivateKey: privateKeyArray,
  splToken: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC mint
  network: 'mainnet-beta',
  conversionRate: 1000000, // 1 USDC = 1,000,000 units (6 decimals)
});

// ❌ NEVER hardcode private keys
const provider = new SolanaPaymentProvider({
  merchantPrivateKey: [1, 2, 3, ...],
});

// ✅ ALWAYS use environment variables
const provider = new SolanaPaymentProvider({
  merchantPrivateKey: process.env.MERCHANT_PRIVATE_KEY 
    ? JSON.parse(process.env.MERCHANT_PRIVATE_KEY) 
    : undefined,
});

// Verify you're on the correct network
const info = solanaProvider.getConnectionInfo();
console.log('Network:', info.network);
console.log('Auto-refund:', info.autoRefundEnabled);

if (info.network === 'devnet' && process.env.NODE_ENV === 'production') {
  throw new Error('Cannot use devnet in production!');
}

// Monitor merchant wallet balance
const { Connection, LAMPORTS_PER_SOL } = require('@solana/web3.js');

const connection = new Connection(process.env.SOLANA_RPC);
const balance = await connection.getBalance(
  new PublicKey(process.env.MERCHANT_WALLET)
);

console.log('Merchant balance:', balance / LAMPORTS_PER_SOL, 'SOL');

// Alert if balance is low
if (balance < 0.1 * LAMPORTS_PER_SOL) {
  console.warn('⚠️  Low balance! May affect refunds.');
}

ws402.on('refund_error', ({ session, error }) => {
  console.error('Refund failed:', error);
  
  // Log to monitoring service
  monitoringService.logError({
    type: 'refund_failed',
    sessionId: session.sessionId,
    userId: session.userId,
    amount: session.paidAmount - session.consumedAmount,
    error: error.message,
  });
  
  // Queue for manual processing
  refundQueue.add({
    senderWallet: session.paymentProof.senderAddress,
    amount: session.paidAmount - session.consumedAmount,
    reason: 'automatic_refund_failed',
  });
});

// Automatic retry logic (built-in):
// - Max 10 retries
// - 2 second delay between retries
// - Handles network delays and finalization

// Transaction typically confirms in < 1 second
// Provider waits up to 20 seconds for confirmation

ws402.on('refund', ({ session, refund }) => {
  console.log('💰 Refund processing...');
  console.log('   Amount:', refund.amount / 1e9, 'SOL');
  console.log('   Session:', session.sessionId);
  
  // Check on Solscan
  const explorerUrl = `https://solscan.io/tx/${refund.signature}`;
  console.log('   Explorer:', explorerUrl);
});

// Run cleanup periodically
setInterval(() => {
  const cleaned = solanaProvider.cleanupExpiredPayments();
  if (cleaned > 0) {
    console.log(`🧹 Cleaned ${cleaned} expired payments`);
  }
}, 60000); // Every minute

app.get('/health', async (req, res) => {
  const info = solanaProvider.getConnectionInfo();
  const connection = new Connection(info.rpcEndpoint);
  
  try {
    // Check RPC connection
    const blockHeight = await connection.getBlockHeight();
    
    // Check merchant balance
    const balance = await connection.getBalance(
      new PublicKey(info.merchantWallet)
    );
    
    res.json({
      status: 'ok',
      network: info.network,
      blockHeight,
      merchantBalance: balance / LAMPORTS_PER_SOL,
      autoRefund: info.autoRefundEnabled,
      activeSessions: ws402.getActiveSessions().length,
    });
  } catch (error) {
    res.status(503).json({
      status: 'error',
      error: error.message,
    });
  }
});

// Get pending payment info
app.get('/debug/pending/:reference', (req, res) => {
  const pending = solanaProvider.getPendingPayment(req.params.reference);
  if (!pending) {
    return res.status(404).json({ error: 'Payment not found' });
  }
  
  res.json({
    reference: req.params.reference,
    amount: pending.amount,
    amountSOL: pending.amountSOL.toString(),
    recipient: pending.recipient.toBase58(),
    timestamp: new Date(pending.timestamp).toISOString(),
    expiresAt: new Date(pending.timestamp + 300000).toISOString(),
  });
});

const { WS402, ProxyPaymentProvider } = require('ws402');

// WS402 Server (no private keys needed!)
const proxyProvider = new ProxyPaymentProvider({
  gatewayUrl: 'https://payment-gateway.example.com',
  apiKey: process.env.GATEWAY_API_KEY,
  timeout: 30000,
  retryAttempts: 3,
});

const ws402 = new WS402(config, proxyProvider);

// Centralized gateway with private keys
node examples/payment-gateway-server.js

class MyPaymentProvider {
  async generatePaymentDetails(amount) {
    return {
      invoiceUrl: 'https://pay.me/invoice-123',
      amount,
      currency: 'USD',
    };
  }

  async verifyPayment(proof) {
    const isValid = await this.checkWithAPI(proof);
    return {
      valid: isValid,
      amount: proof.amount,
    };
  }

  async issueRefund(proof, amount) {
    await this.refundAPI(proof, amount);
  }
}

new WS402(config: WS402Config, paymentProvider: PaymentProvider)

// ❌ NEVER DO THIS
const provider = new BasePaymentProvider({
  merchantPrivateKey: '0x123abc...'
});

// ✅ ALWAYS USE ENVIRONMENT VARIABLES
const provider = new BasePaymentProvider({
  merchantPrivateKey: process.env.MERCHANT_PRIVATE_KEY
});