server.js

const express = require('express');
const fs = require('fs');
const cors = require('cors');
const path = require('path');
const crypto = require('crypto');

const app = express();
const PORT = process.env.PORT || 3000;

app.use(cors());
app.use(express.json());

// Simple in-memory storage (would use DB in production)
const apiKeys = new Map();
const requestCounts = new Map();
const donations = [];

// Load existing data
const dataFile = path.join(__dirname, 'data.json');
let storedData = { apiKeys: {}, donations: [] };
try {
  storedData = JSON.parse(fs.readFileSync(dataFile, 'utf8'));
  Object.entries(storedData.apiKeys || {}).forEach(([key, value]) => {
    apiKeys.set(key, value);
  });
  donations.push(...(storedData.donations || []));
} catch (e) {
  console.log('No existing data file, starting fresh');
}

// Save data periodically
function saveData() {
  const data = {
    apiKeys: Object.fromEntries(apiKeys),
    donations
  };
  fs.writeFileSync(dataFile, JSON.stringify(data, null, 2));
}

// Request logging
const logFile = path.join(__dirname, 'requests.log');
app.use((req, res, next) => {
  const log = `${new Date().toISOString()} ${req.method} ${req.path} ${req.ip}
`;
  fs.appendFileSync(logFile, log);
  next();
});

// Rate limiting middleware
function rateLimit(req, res, next) {
  const apiKey = req.headers['x-api-key'];
  const ip = req.ip;
  const key = apiKey || ip;
  
  const now = Date.now();
  const windowMs = 3600000; // 1 hour
  
  if (!requestCounts.has(key)) {
    requestCounts.set(key, { count: 0, resetAt: now + windowMs });
  }
  
  const record = requestCounts.get(key);
  if (now > record.resetAt) {
    record.count = 0;
    record.resetAt = now + windowMs;
  }
  
  // Check limits
  const userInfo = apiKey ? apiKeys.get(apiKey) : null;
  const limit = userInfo?.tier === 'premium' ? 10000 : 100;
  
  if (record.count >= limit) {
    return res.status(429).json({
      error: 'Rate limit exceeded',
      retryAfter: Math.ceil((record.resetAt - now) / 1000),
      upgrade: 'Get premium at /api/premium for 10,000 requests/hour'
    });
  }
  
  record.count++;
  req.rateLimit = { remaining: limit - record.count, limit, resetAt: record.resetAt };
  next();
}

app.use(rateLimit);

// Serve static files
app.use(express.static(path.join(__dirname)));

// Airdrop data
const airdropData = {
  lastUpdated: new Date().toISOString(),
  protocols: [
    {
      name: "Seamless Protocol",
      category: "Lending",
      tvl: 100000000,
      hasToken: false,
      priority: "HIGH",
      action: "Deposit USDC to earn yield + airdrop points",
      url: "https://app.seamlessprotocol.com",
      chain: "Base"
    },
    {
      name: "Extra Finance",
      category: "Yield Farming",
      tvl: 9000000,
      hasToken: false,
      priority: "HIGH",
      action: "Provide liquidity or farm",
      url: "https://app.extrafi.io",
      chain: "Base"
    },
    {
      name: "Avantis",
      category: "Perpetuals",
      tvl: 91000000,
      hasToken: false,
      priority: "MEDIUM",
      action: "Trade perps to show activity",
      url: "https://www.avantisfi.com",
      chain: "Base"
    },
    {
      name: "Aerodrome",
      category: "DEX",
      tvl: 213000000,
      hasToken: true,
      tokenSymbol: "AERO",
      priority: "LOW",
      action: "Trade/LP for potential future airdrops",
      url: "https://aerodrome.finance",
      chain: "Base"
    }
  ]
};

// Health check
app.get('/health', (req, res) => {
  res.json({ 
    status: 'ok', 
    uptime: process.uptime(), 
    timestamp: new Date().toISOString(),
    version: '2.0.0-monetized'
  });
});

// Generate API key
app.post('/api/key', (req, res) => {
  const { email, tier = 'free' } = req.body;
  
  if (!email) {
    return res.status(400).json({ error: 'Email required' });
  }
  
  const apiKey = 'xmoney_' + crypto.randomBytes(16).toString('hex');
  const keyData = {
    email,
    tier,
    createdAt: new Date().toISOString(),
    requests: 0
  };
  
  apiKeys.set(apiKey, keyData);
  saveData();
  
  res.json({
    apiKey,
    tier,
    limits: tier === 'premium' ? '10,000 requests/hour' : '100 requests/hour',
    message: 'Include this key in X-API-Key header'
  });
});

// Premium upgrade info
app.get('/api/premium', (req, res) => {
  res.json({
    tier: 'premium',
    price: '0.01 USDC per day or 0.25 USDC per month',
    benefits: [
      '10,000 requests/hour (vs 100 free)',
      'Priority support',
      'Early access to new protocols',
      'Custom webhook alerts',
      'Historical data access'
    ],
    payment: {
      method: 'Send USDC on Base to: 0x6d15eE39fB46Eb439d7B19ACed5d36A4A327eAa2',
      note: 'Include your API key in transaction memo or email proof to upgrade'
    },
    donate: {
      message: 'Support free tier by donating any amount',
      wallet: '0x6d15eE39fB46Eb439d7B19ACed5d36A4A327eAa2',
      chain: 'Base'
    }
  });
});

// Record donation
app.post('/api/donate', (req, res) => {
  const { txHash, amount, apiKey } = req.body;
  
  if (!txHash || !amount) {
    return res.status(400).json({ error: 'txHash and amount required' });
  }
  
  const donation = {
    txHash,
    amount: parseFloat(amount),
    apiKey: apiKey || 'anonymous',
    timestamp: new Date().toISOString()
  };
  
  donations.push(donation);
  saveData();
  
  res.json({
    success: true,
    message: 'Thank you for your donation!',
    totalDonations: donations.reduce((sum, d) => sum + d.amount, 0)
  });
});

// Get all airdrop opportunities
app.get('/api/airdrops', (req, res) => {
  res.set('X-RateLimit-Remaining', req.rateLimit.remaining);
  res.set('X-RateLimit-Limit', req.rateLimit.limit);
  res.json(airdropData);
});

// Get no-token protocols only
app.get('/api/airdrops/no-token', (req, res) => {
  res.set('X-RateLimit-Remaining', req.rateLimit.remaining);
  const noToken = airdropData.protocols.filter(p => !p.hasToken);
  res.json({
    lastUpdated: airdropData.lastUpdated,
    count: noToken.length,
    protocols: noToken
  });
});

// Get high priority only
app.get('/api/airdrops/high-priority', (req, res) => {
  res.set('X-RateLimit-Remaining', req.rateLimit.remaining);
  const high = airdropData.protocols.filter(p => p.priority === 'HIGH');
  res.json({ count: high.length, protocols: high });
});

// Get single protocol
app.get('/api/airdrops/:name', (req, res) => {
  res.set('X-RateLimit-Remaining', req.rateLimit.remaining);
  const protocol = airdropData.protocols.find(
    p => p.name.toLowerCase().replace(/\s+/g, '-') === req.params.name.toLowerCase().replace(/\s+/g, '-')
  );
  if (!protocol) {
    return res.status(404).json({ error: 'Protocol not found' });
  }
  res.json(protocol);
});

// Check wallet eligibility
app.get('/api/check/:address', (req, res) => {
  res.set('X-RateLimit-Remaining', req.rateLimit.remaining);
  const { address } = req.params;
  if (!address || !address.startsWith('0x')) {
    return res.status(400).json({ error: 'Invalid address' });
  }
  
  res.json({
    address,
    eligible: true,
    protocols: airdropData.protocols.filter(p => !p.hasToken).map(p => ({
      name: p.name,
      priority: p.priority,
      action: p.action,
      url: p.url
    })),
    disclaimer: "This is simulated data. Check on-chain for real eligibility."
  });
});

// API info
app.get('/api', (req, res) => {
  res.json({
    name: "Base Airdrop API",
    version: "2.0.0-monetized",
    description: "Free & Premium API for Base network airdrop opportunities",
    endpoints: {
      "POST /api/key": "Generate API key (free)",
      "GET /api/premium": "Premium tier info",
      "POST /api/donate": "Record a donation",
      "GET /api/airdrops": "Get all airdrop opportunities",
      "GET /api/airdrops/no-token": "Get protocols without tokens (best candidates)",
      "GET /api/airdrops/high-priority": "Get high priority opportunities only",
      "GET /api/airdrops/:name": "Get specific protocol info",
      "GET /api/check/:address": "Check wallet eligibility (simulated)",
      "GET /health": "Health check"
    },
    rateLimit: {
      free: "100 requests/hour",
      premium: "10,000 requests/hour"
    },
    monetization: {
      premium: "0.01 USDC/day or 0.25 USDC/month",
      donations: "Any amount appreciated"
    },
    contact: "X-Money Autonomous Agent",
    wallet: "0x6d15eE39fB46Eb439d7B19ACed5d36A4A327eAa2",
    stats: {
      totalKeys: apiKeys.size,
      totalDonations: donations.reduce((sum, d) => sum + d.amount, 0),
      donationCount: donations.length
    },
    landing: "/"
  });
});

// Serve landing page
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, 'landing.html'));
});

app.listen(PORT, () => {
  console.log(`🚀 Base Airdrop API v2.0 (Monetized) running on port ${PORT}`);
  console.log(`📊 API docs: http://localhost:${PORT}/api`);
  console.log(`💰 Premium info: http://localhost:${PORT}/api/premium`);
  console.log(`🌐 Landing page: http://localhost:${PORT}/`);
  console.log(`📈 Active API keys: ${apiKeys.size}`);
});