// Request test tokens via API
async function requestTestTokens() {
  try {
    // Check eligibility first
    const eligibilityResponse = await fetch(
      `https://api.gtxdex.xyz/v1/faucet/eligibility?address=${userAddress}&token=0xC004514803F58b09eee24471BC9EfF3D1087CffF`,
      {
        headers: {
          'Authorization': `Bearer ${apiKey}`
        }
      }
    );
    
    const eligibility = await eligibilityResponse.json();
    
    if (!eligibility.eligible) {
      console.log('Still in cooldown period. Next request available:', eligibility.nextRequestTime);
      return;
    }
    
    // Request tokens
    const requestResponse = await fetch('https://api.gtxdex.xyz/v1/faucet/request', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      },
      body: JSON.stringify({
        token: '0xC004514803F58b09eee24471BC9EfF3D1087CffF', // MUSDC
        recipient: userAddress
      })
    });
    
    const result = await requestResponse.json();
    console.log('Tokens requested:', result.transactionHash);
    console.log('Amount received:', result.amount);
  } catch (error) {
    console.error('Faucet request failed:', error);
  }
}

class TestEnvironment {
  private faucet: GTXFaucet;
  private client: GTXClient;
  
  constructor() {
    this.faucet = new GTXFaucet({
      chainId: ChainId.GTX_DEVNET,
      privateKey: process.env.TEST_PRIVATE_KEY
    });
    
    this.client = new GTXClient({
      chainId: ChainId.GTX_DEVNET,
      privateKey: process.env.TEST_PRIVATE_KEY
    });
  }
  
  async setupTradingTokens() {
    const tokens = [
      { symbol: 'MUSDC', address: '0xC004514803F58b09eee24471BC9EfF3D1087CffF' },
      { symbol: 'mWETH', address: '0xbb66130EED9BD4ea584cf283d34E49E8d4d69e99' },
      { symbol: 'mWBTC', address: '0xdDbe918dcA0F0B876c2Dff6ff3db4FA0C943A293' }
    ];
    
    for (const token of tokens) {
      try {
        await this.faucet.requestTokens({
          token: token.address,
          recipient: await this.client.getAddress()
        });
        
        console.log(`✅ Received ${token.symbol} test tokens`);
        
        // Wait for cooldown between requests
        await new Promise(resolve => setTimeout(resolve, 5000));
      } catch (error) {
        console.error(`❌ Failed to get ${token.symbol}:`, error);
      }
    }
  }
  
  async verifyBalances() {
    const account = await this.client.getAccount();
    
    console.log('📊 Test token balances:');
    account.balances.forEach(balance => {
      if (parseFloat(balance.free) > 0) {
        console.log(`  ${balance.asset}: ${balance.free}`);
      }
    });
  }
}

// Usage
const testEnv = new TestEnvironment();
await testEnv.setupTradingTokens();
await testEnv.verifyBalances();

class FaucetIntegrationTest {
  private faucet: GTXFaucet;
  
  constructor() {
    this.faucet = new GTXFaucet({
      chainId: ChainId.GTX_DEVNET,
      privateKey: process.env.TEST_PRIVATE_KEY
    });
  }
  
  async runTestSuite() {
    console.log('🧪 Running faucet integration tests...');
    
    // Test 1: Request tokens
    await this.testTokenRequest();
    
    // Test 2: Verify cooldown
    await this.testCooldownPeriod();
    
    // Test 3: Check balance updates
    await this.testBalanceUpdates();
    
    console.log('✅ All faucet tests completed');
  }
  
  private async testTokenRequest() {
    try {
      const result = await this.faucet.requestTokens({
        token: '0xC004514803F58b09eee24471BC9EfF3D1087CffF',
        recipient: await this.faucet.getAddress()
      });
      
      console.log('✅ Token request successful:', result.transactionHash);
    } catch (error) {
      console.error('❌ Token request failed:', error);
    }
  }
  
  private async testCooldownPeriod() {
    try {
      // This should fail due to cooldown
      await this.faucet.requestTokens({
        token: '0xC004514803F58b09eee24471BC9EfF3D1087CffF',
        recipient: await this.faucet.getAddress()
      });
      
      console.error('❌ Cooldown test failed - request should have been rejected');
    } catch (error) {
      if (error.message.includes('cooldown')) {
        console.log('✅ Cooldown protection working correctly');
      } else {
        console.error('❌ Unexpected error:', error);
      }
    }
  }
  
  private async testBalanceUpdates() {
    const balanceBefore = await this.faucet.getBalance(
      await this.faucet.getAddress(),
      '0xC004514803F58b09eee24471BC9EfF3D1087CffF'
    );
    
    // Wait for cooldown then request again
    await new Promise(resolve => setTimeout(resolve, 3600000)); // 1 hour
    
    await this.faucet.requestTokens({
      token: '0xC004514803F58b09eee24471BC9EfF3D1087CffF',
      recipient: await this.faucet.getAddress()
    });
    
    const balanceAfter = await this.faucet.getBalance(
      await this.faucet.getAddress(),
      '0xC004514803F58b09eee24471BC9EfF3D1087CffF'
    );
    
    if (balanceAfter > balanceBefore) {
      console.log('✅ Balance updated correctly');
    } else {
      console.error('❌ Balance not updated');
    }
  }
}

try {
  await faucet.requestTokens({
    token: tokenAddress,
    recipient: userAddress
  });
} catch (error) {
  if (error.message.includes('cooldown')) {
    console.log('Please wait for cooldown period');
  } else if (error.message.includes('insufficient')) {
    console.log('Faucet balance too low, try again later');
  } else if (error.message.includes('network')) {
    console.log('Check network connection and retry');
  } else {
    console.error('Unexpected error:', error);
  }
}

// Network configuration for GTX devnet
const gtxDevnet = {
  chainId: 1802,
  chainName: 'GTX Devnet',
  nativeCurrency: {
    name: 'Ethereum',
    symbol: 'ETH',
    decimals: 18
  },
  rpcUrls: ['https://testnet-rpc.gtxdex.xyz'],
  blockExplorerUrls: ['https://testnet-explorer.gtxdex.xyz']
};