server.js

const express = require('express');
const axios = require('axios');
const path = require('path');
const fs = require('fs');

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

// Remote API endpoint
const REMOTE_API = process.env.REMOTE_API;

// In-memory cache with key-based storage (username+mode)
const cache = new Map();
const CACHE_TTL = 60; // seconds

// Serve static files from the 'static' folder
app.use('/static', express.static(path.join(__dirname, 'static'), {
  setHeaders: (res, filepath) => {
    // Only allow PNG files
    if (filepath.endsWith('.png')) {
      res.setHeader('Content-Type', 'image/png');
      res.setHeader('Cache-Control', 'public, max-age=3600'); // Cache for 1 hour
    }
  }
}));

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

// Serve ranks configuration
app.get('/api/ranks', (req, res) => {
  const configPath = path.join(__dirname, 'ranks_config.json');

  if (fs.existsSync(configPath)) {
    const ranks = JSON.parse(fs.readFileSync(configPath, 'utf8'));
    res.json(ranks);
  } else {
    // Return default ranks if config file doesn't exist
    res.json([]);
  }
});


// Proxy endpoint for rank data
app.get('/api/rank', async (req, res) => {
  const username = req.query.username || 'bbraad';
  const mode = req.query.mode || 'squad';
  const now = Date.now() / 1000; // Convert to seconds

  // Create cache key based on username and mode
  const cacheKey = `${username}:${mode}`;
  const cachedEntry = cache.get(cacheKey);

  // Test with local file
  // var obj = JSON.parse(fs.readFileSync('test.json', 'utf8'));
  // return res.json(obj);

  // Serve cached data if still valid
  if (cachedEntry && (now - cachedEntry.timestamp) < CACHE_TTL) {
    console.log(`Cache hit for ${cacheKey}`);
    return res.json(cachedEntry.data);
  }

  try {
    console.log(`Fetching fresh data for ${cacheKey}`);
    const response = await axios.get(`${REMOTE_API}/rank/get`, {
      params: { username, mode },
      timeout: 15000
    });

    const data = response.data;

    // Check if response is empty or indicates player not found
    if (!data || Object.keys(data).length === 0 || data.error || data.points === undefined) {
      console.log(`Player not found: ${cacheKey}`);
      return res.status(404).json({
        error: 'Player not found',
        message: `No data found for player "${username}" in ${mode} mode`
      });
    }

    // Cache the successful response with username+mode key
    cache.set(cacheKey, {
      data: data,
      timestamp: now
    });

    res.json(data);
  } catch (error) {
    // If API is slow or errors, return cached data if available (even if expired)
    if (cachedEntry) {
      console.log(`API error, serving stale cache for ${cacheKey}`);
      return res.json(cachedEntry.data);
    }

    if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
      res.status(504).json({ error: 'Rank API timeout' });
    } else if (error.response && error.response.status === 404) {
      res.status(404).json({
        error: 'Player not found',
        message: `No data found for player "${username}" in ${mode} mode`
      });
    } else {
      console.log(`${REMOTE_API}/rank/get`, { params: { username, mode } });
      res.status(502).json({ error: `Rank API error: ${error.message}` });
    }
  }
});

// Clean up old cache entries periodically (every 5 minutes)
setInterval(() => {
  const now = Date.now() / 1000;
  let cleaned = 0;

  for (const [key, entry] of cache.entries()) {
    if (now - entry.timestamp > CACHE_TTL * 2) {
      cache.delete(key);
      cleaned++;
    }
  }

  if (cleaned > 0) {
    console.log(`Cache cleanup: Removed ${cleaned} expired entries`);
  }
}, 5 * 60 * 1000);


// ----------------- Serve old design ---------------------
app.get('/old', (req, res) => {
  res.sendFile(path.join(__dirname, '/old_design/index.html'));
});

app.use('/old/static', express.static(path.join(__dirname, '/old_design/static'), {
  setHeaders: (res, filepath) => {
    // Only allow PNG files
    if (filepath.endsWith('.png')) {
      res.setHeader('Content-Type', 'image/png');
      res.setHeader('Cache-Control', 'public, max-age=3600'); // Cache for 1 hour
    }
  }
}));

app.get('/api/old/ranks', (req, res) => {
  const configPath = path.join(__dirname, 'old_design/ranks_config.json');

  if (fs.existsSync(configPath)) {
    const ranks = JSON.parse(fs.readFileSync(configPath, 'utf8'));
    res.json(ranks);
  } else {
    // Return default ranks if config file doesn't exist
    res.json([]);
  }
});
// ----------------- Serve old design ---------------------


// ----------------- Serve leaderboard design ---------------------
app.get('/leaderboard', (req, res) => {
  res.sendFile(path.join(__dirname, '/leaderboard/index.html'));
});

app.use('/leaderboard/static', express.static(path.join(__dirname, '/leaderboard/static'), {
  setHeaders: (res, filepath) => {
    // Only allow PNG files
    if (filepath.endsWith('.png')) {
      res.setHeader('Content-Type', 'image/png');
      res.setHeader('Cache-Control', 'public, max-age=3600'); // Cache for 1 hour
    }
  }
}));
// ----------------- Serve leaderboard design ---------------------


// ----------------- Serve leaderboard design ---------------------
app.get('/hotdrop', (req, res) => {
  res.sendFile(path.join(__dirname, '/hotdrop/index.html'));
});

app.use('/hotdrop/static', express.static(path.join(__dirname, '/hotdrop/static'), {
  setHeaders: (res, filepath) => {
    // Only allow PNG files
    if (filepath.endsWith('.png')) {
      res.setHeader('Content-Type', 'image/png');
      res.setHeader('Cache-Control', 'public, max-age=3600'); // Cache for 1 hour
    }
  }
}));
// ----------------- Serve leaderboard design ---------------------

// Proxy endpoint for rank data
app.get('/api/scrim_hotdrop', async (req, res) => {
  const id = req.query.id;
  const now = Date.now() / 1000; // Convert to seconds

  // Create cache key based on username and mode
  const cacheKey = `scrim_hotdrop:${id}`;
  const cachedEntry = cache.get(cacheKey);

  // Serve cached data if still valid
  if (cachedEntry && (now - cachedEntry.timestamp) < CACHE_TTL) {
    console.log(`Cache hit for ${cacheKey}`);
    return res.json(cachedEntry.data);
  }

  try {
    console.log(`Fetching fresh data for ${cacheKey}`);
    const response = await axios.get(`${REMOTE_API}/scrims/hotdrop`, {
      params: { id },
      timeout: 15000
    });

    const data = response.data;

    if (!data || data.error) {
      return res.status(404).json({
        error: 'Can\'t get selected maps of the scrim',
        message: `Failed to get selected maps of the scrim for ${id}`
      });
    }

    // Cache the successful response with username+mode key
    cache.set(cacheKey, {
      data: data,
      timestamp: now
    });

    res.json(data);
  } catch (error) {
    // If API is slow or errors, return cached data if available (even if expired)
    if (cachedEntry) {
      console.log(`API error, serving stale cache for ${cacheKey}`);
      return res.json(cachedEntry.data);
    }

    if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
      res.status(504).json({ error: 'Rank API timeout' });
    } else if (error.response && error.response.status === 404) {
      res.status(404).json({
        error: 'Can\'t get selected maps of the scrim',
        message: `Failed to get selected maps of the scrim for ${id}`
      });
    } else {
      console.log(`${REMOTE_API}/scrims/hotdrop`, { params: { id } });
      res.status(502).json({ error: `Rank API error: ${error.message}` });
    }
  }
});

// Proxy endpoint for rank data
app.get('/api/scrim_leaderboard', async (req, res) => {
  const id = req.query.id;
  const now = Date.now() / 1000; // Convert to seconds

  // Create cache key based on username and mode
  const cacheKey = `scrim_leaderboard:${id}`;
  const cachedEntry = cache.get(cacheKey);

  // Serve cached data if still valid
  if (cachedEntry && (now - cachedEntry.timestamp) < CACHE_TTL) {
    console.log(`Cache hit for ${cacheKey}`);
    return res.json(cachedEntry.data);
  }

  try {
    console.log(`Fetching fresh data for ${cacheKey}`);
    const response = await axios.get(`${REMOTE_API}/scrims/leaderboard`, {
      params: { id },
      timeout: 15000
    });

    const data = response.data;

    if (!data || data.error) {
      return res.status(404).json({
        error: 'Can\'t get scrim leaderboard',
        message: `Failed to get leaderboard for ${id}`
      });
    }

    // Cache the successful response with username+mode key
    cache.set(cacheKey, {
      data: data,
      timestamp: now
    });

    res.json(data);
  } catch (error) {
    // If API is slow or errors, return cached data if available (even if expired)
    if (cachedEntry) {
      console.log(`API error, serving stale cache for ${cacheKey}`);
      return res.json(cachedEntry.data);
    }

    if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
      res.status(504).json({ error: 'Rank API timeout' });
    } else if (error.response && error.response.status === 404) {
      res.status(404).json({
        error: 'Can\'t get scrim leaderboard',
        message: `Failed to get leaderboard for ${id}`
      });
    } else {
      console.log(`${REMOTE_API}/scrims/leaderboard`, { params: { id } });
      res.status(502).json({ error: `Rank API error: ${error.message}` });
    }
  }
});


// Start server
app.listen(PORT, () => {
  console.log(`\n========================================`);
  console.log(`  Rank Widget Server is running!`);
  console.log(`========================================`);
  console.log(`\n  Local:    http://localhost:${PORT}`);
  console.log(`  Network:  http://127.0.0.1:${PORT}`);
  console.log(`\n  Usage:`);
  console.log(`  http://localhost:${PORT}?username=YourName&mode=squad`);
  console.log(`\n  Available modes: squad, duo, solo`);
  console.log(`========================================\n`);
});