const axios = require('axios');

const endpoint = 'https://nexus.fortiblox.com/rpc';
const apiKey = process.env.FORTIBLOX_API_KEY;

// Get account info
const response = await axios.post(endpoint, {
  jsonrpc: '2.0',
  id: 1,
  method: 'getAccountInfo',
  params: [publicKey.toString(), { encoding: 'base64' }]
}, {
  headers: { 'X-API-Key': apiKey }
});

const accountInfo = response.data.result;

// You make a request...
const slot = await connection.getSlot();

// Behind the scenes, FortiBlox:
// 1. Checks health scores of all endpoints
// 2. Selects the best endpoint using weighted random selection
// 3. Routes your request automatically
// 4. Updates health scores based on response time

Endpoint A: 95% healthy → Gets 47.5% of traffic
Endpoint B: 85% healthy → Gets 42.5% of traffic
Endpoint C: 20% healthy → Gets 10% of traffic
Endpoint D: 0% healthy  → Gets 0% of traffic (excluded)

curl https://nexus.fortiblox.com/rpc/health \
  -H "X-API-Key: $FORTIBLOX_API_KEY"

{
  "success": true,
  "pool": {
    "total_endpoints": 5,
    "healthy_endpoints": 4,
    "enabled_endpoints": 5,
    "avg_health_score": 87.5
  }
}

X-RateLimit-Limit: 50
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1699564800

// ✅ CORRECT - Implement exponential backoff
async function makeRequestWithRetry(method, params, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await connection[method](...params);
      return response;
    } catch (error) {
      if (error.message.includes('429') && i < maxRetries - 1) {
        // Exponential backoff: 1s, 2s, 4s
        const delay = Math.pow(2, i) * 1000;
        console.log(`Rate limited. Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
}

// Usage
const slot = await makeRequestWithRetry('getSlot', []);

HTTP/1.1 200 OK
Content-Type: application/json
X-RPC-Endpoint: http://validator1.internal:8899
X-RPC-Latency-Ms: 42
X-Request-Id: 550e8400-e29b-41d4-a716-446655440000
X-RateLimit-Limit: 50
X-RateLimit-Remaining: 49
X-RateLimit-Reset: 1699564800

{
  "success": false,
  "error": "Invalid API key",
  "error_code": "INVALID_API_KEY"
}

{
  "success": false,
  "error": "Request origin not in allowed domains list",
  "error_code": "DOMAIN_NOT_ALLOWED",
  "allowed_domains": ["https://myapp.com"]
}

{
  "success": false,
  "error": "Rate limit exceeded. Maximum 50 requests per second allowed.",
  "error_code": "RATE_LIMIT_EXCEEDED",
  "limit": 50,
  "retry_after": 1
}

{
  "success": false,
  "error": "No healthy RPC endpoints available. Please try again later.",
  "error_code": "NO_HEALTHY_ENDPOINTS"
}

// For recent data (faster)
const connectionConfirmed = new Connection(url, 'confirmed');

// For finalized data (slower but safer)
const connectionFinalized = new Connection(url, 'finalized');

// ✅ Cache data that doesn't change frequently
const cache = new Map();
const CACHE_TTL = 60000; // 1 minute

async function getAccountInfoCached(publicKey) {
  const cached = cache.get(publicKey.toString());
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }

  const data = await connection.getAccountInfo(publicKey);
  cache.set(publicKey.toString(), { data, timestamp: Date.now() });
  return data;
}

// ❌ DON'T - Multiple individual requests
const balance1 = await connection.getBalance(pubkey1);
const balance2 = await connection.getBalance(pubkey2);
const balance3 = await connection.getBalance(pubkey3);

// ✅ DO - Use getMultipleAccounts
const accounts = await connection.getMultipleAccountsInfo([
  pubkey1, pubkey2, pubkey3
]);

const connection = new Connection(url, {
  commitment: 'confirmed',
  httpHeaders: { 'timeout': '60000' } // 60 seconds
});