const express = require('express');
const rateLimit = require('express-rate-limit');
const path = require('path');
const bodyParser = require('body-parser');
const API = require('./src/js/index.js');
const demoTracker = require('./src/js/demoTracker.js');
const { logger } = require('./src/js/logger.js');
const favicon = require('serve-favicon');
const fs = require('fs');
const app = express();
const port = process.env.PORT || 3512;
const {
  processJsonOutput,
  sanitizeHeaders,
  timeoutPromise,
  ensureLogin,
  handleApiError,
  activeSessions,
} = require('./src/js/serverUtils.js');
require('./src/js/utils.js');

app.set('trust proxy', true);

// Middleware
app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));
app.use(express.static(__dirname));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/images', express.static(path.join(__dirname, 'src/images')));
app.use(favicon(path.join(__dirname, 'src', 'images', 'favicon.ico')));
app.use(
  bodyParser.json({
    limit: '10mb',
    verify: (req, res, buf) => {
      req.rawBody = buf.toString();
    },
  })
);
app.use(demoTracker.demoModeMiddleware);

// Set up demo mode cleanup interval
setInterval(
  () => demoTracker.demoModeRequestTracker.cleanupExpiredEntries(),
  3600000
); // Clean up every hour

app.get('/health', (req, res) => {
  const clientIP =
    req.headers['cf-connecting-ip'] ||
    req.headers['x-forwarded-for']?.split(',')[0] ||
    req.ip ||
    req.connection.remoteAddress;

  const isDemoMode = demoTracker.isDemoModeActive();
  res.json({
    status: 'ok',
    timestamp: global.Utils.toIsoString(new Date()),
    demoMode: isDemoMode,
    requestsRemaining:
      isDemoMode ?
        demoTracker.demoModeRequestTracker.maxRequestsPerHour -
        (demoTracker.demoModeRequestTracker.requests.get(clientIP)?.count || 0)
      : null,
  });
});

// Serve the main HTML file
app.get('/', async (req, res) => {
  // Check demo mode query parameter
  if (req.query.demo === 'true') {
    await demoTracker.initializeDemoMode(true);
  } else if (req.query.demo === 'false') {
    await demoTracker.initializeDemoMode(false);
  }

  res.sendFile(path.join(__dirname, 'src', 'index.html'));
});

// Demo mode route - enables demo mode when visited
app.get('/demo', async (req, res) => {
  const success = await demoTracker.initializeDemoMode(true);

  if (success) {
    logger.info('Demo mode activated via /demo route');
    res.redirect('/?demo=true');
  } else {
    res
      .status(500)
      .send('Failed to enable demo mode. Check server logs for details.');
  }
});

// Demo mode deactivation route
app.get('/demo/disable', async (req, res) => {
  await demoTracker.initializeDemoMode(false);
  logger.info('Demo mode deactivated via /demo/disable route');
  res.redirect('/?demo=false');
});

// API endpoint to fetch stats
app.post('/api/stats', async (req, res) => {
  logger.debug('Received request for /api/stats');
  logger.debug(
    `Request IP: ${
      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
    }`
  );
  logger.debug(
    `Request JSON: ${JSON.stringify({
      username: req.body.username,
      platform: req.body.platform,
      game: req.body.game,
      apiCall: req.body.apiCall,
      sanitize: req.body.sanitize,
      replaceKeys: req.body.replaceKeys,
    })}`
  );

  try {
    let { username, ssoToken, platform, game, apiCall, sanitize, replaceKeys } =
      req.body;

    const defaultToken = demoTracker.getDefaultSsoToken();
    if (!ssoToken && defaultToken) {
      ssoToken = defaultToken;
      logger.info('Using default SSO token for demo mode');
    } else if (!ssoToken) {
      return res.status(200).json({
        status: 'error',
        message: 'SSO Token is required',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    /*
    logger.debug(
      `Request details - Username: ${username}, Platform: ${platform}, Game: ${game}, API Call: ${apiCall}`
    );

    logger.debug("=== STATS REQUEST ===");
    logger.debug(`Username: ${username || 'Not provided'}`);
    logger.debug(`Platform: ${platform}`);
    logger.debug(`Game: ${game}`);
    logger.debug(`API Call: ${apiCall}`);
    logger.debug(`Processing Options - Sanitize: ${sanitize}, Replace Keys: ${replaceKeys}`);
    logger.debug("====================="); */

    /*
    if (!ssoToken) {
      return res.status(400).json({ error: 'SSO Token is required' });
    } */

    // For mapList, username is not required
    if (apiCall !== 'mapList' && !username) {
      return res.status(400).json({ error: 'Username is required' });
    }

    // Clear previous session if it exists
    if (activeSessions.has(ssoToken)) {
      logger.debug('Clearing previous session');
      activeSessions.delete(ssoToken);
    }

    // Login with the provided SSO token
    try {
      await ensureLogin(ssoToken);
    } catch (loginError) {
      logger.error('Login error:', loginError);
      return res.status(200).json({
        status: 'error',
        error_type: 'LoginError',
        message: 'SSO token login failed',
        details: loginError.message || 'Unknown login error',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    // Create a wrapped function for each API call to handle timeout
    const fetchWithTimeout = async (apiFn) => {
      return Promise.race([
        apiFn(),
        timeoutPromise(30000), // 30 second timeout
      ]);
    };

    // Check if the platform is valid for the game
    const requiresUno = ['mw2', 'wz2', 'mw3', 'wzm'].includes(game);
    if (requiresUno && platform !== 'uno' && apiCall !== 'mapList') {
      logger.warn(`${game} requires Uno ID`);
      return res.status(200).json({
        status: 'error',
        message: `${game} requires Uno ID (numerical ID)`,
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    try {
      logger.debug(
        `Attempting to fetch ${game} data for ${username} on ${platform}`
      );
      let data;

      if (apiCall === 'fullData') {
        // Fetch lifetime stats based on game
        switch (game) {
          case 'mw':
            data = await fetchWithTimeout(() =>
              API.ModernWarfare.fullData(username, platform)
            );
            break;
          case 'wz':
            data = await fetchWithTimeout(() =>
              API.Warzone.fullData(username, platform)
            );
            break;
          case 'mw2':
            data = await fetchWithTimeout(() =>
              API.ModernWarfare2.fullData(username)
            );
            break;
          case 'wz2':
            data = await fetchWithTimeout(() =>
              API.Warzone2.fullData(username)
            );
            break;
          case 'mw3':
            data = await fetchWithTimeout(() =>
              API.ModernWarfare3.fullData(username)
            );
            break;
          case 'cw':
            data = await fetchWithTimeout(() =>
              API.ColdWar.fullData(username, platform)
            );
            break;
          case 'vg':
            data = await fetchWithTimeout(() =>
              API.Vanguard.fullData(username, platform)
            );
            break;
          case 'wzm':
            data = await fetchWithTimeout(() =>
              API.WarzoneMobile.fullData(username)
            );
            break;
          default:
            return res.status(200).json({
              status: 'error',
              message: 'Invalid game selected',
              timestamp: global.Utils.toIsoString(new Date()),
            });
        }
      } else if (apiCall === 'combatHistory') {
        // Fetch recent match history based on game
        switch (game) {
          case 'mw':
            data = await fetchWithTimeout(() =>
              API.ModernWarfare.combatHistory(username, platform)
            );
            break;
          case 'wz':
            data = await fetchWithTimeout(() =>
              API.Warzone.combatHistory(username, platform)
            );
            break;
          case 'mw2':
            data = await fetchWithTimeout(() =>
              API.ModernWarfare2.combatHistory(username)
            );
            break;
          case 'wz2':
            data = await fetchWithTimeout(() =>
              API.Warzone2.combatHistory(username)
            );
            break;
          case 'mw3':
            data = await fetchWithTimeout(() =>
              API.ModernWarfare3.combatHistory(username)
            );
            break;
          case 'cw':
            data = await fetchWithTimeout(() =>
              API.ColdWar.combatHistory(username, platform)
            );
            break;
          case 'vg':
            data = await fetchWithTimeout(() =>
              API.Vanguard.combatHistory(username, platform)
            );
            break;
          case 'wzm':
            data = await fetchWithTimeout(() =>
              API.WarzoneMobile.combatHistory(username)
            );
            break;
          default:
            return res.status(200).json({
              status: 'error',
              message: 'Invalid game selected',
              timestamp: global.Utils.toIsoString(new Date()),
            });
        }
      } else if (apiCall === 'mapList') {
        // Fetch map list (only valid for MW)
        if (game === 'mw') {
          data = await fetchWithTimeout(() =>
            API.ModernWarfare.mapList(platform)
          );
        } else {
          return res.status(200).json({
            status: 'error',
            message: 'Map list is only available for Modern Warfare',
            timestamp: global.Utils.toIsoString(new Date()),
          });
        }
      }

      logger.debug('Data fetched successfully');
      logger.debug(`Response Size: ~${JSON.stringify(data).length / 1024} KB`);
      logger.debug(`Response Time: ${global.Utils.toIsoString(new Date())}`);

      // Safely handle the response data
      if (!data) {
        logger.warn('No data returned from API');
        return res.json({
          status: 'partial_success',
          message: 'No data returned from API, but no error thrown',
          data: null,
          timestamp: global.Utils.toIsoString(new Date()),
        });
      }

      // logger.debug("Returning data to client");

      const { sanitize, replaceKeys } = req.body;

      demoTracker.incrementDemoCounter(req, ssoToken);

      return res.json({
        // status: "success",
        data: processJsonOutput(data, { sanitize, replaceKeys }),
        timestamp: global.Utils.toIsoString(new Date()),
      });
    } catch (apiError) {
      return handleApiError(apiError, res);
    }
  } catch (serverError) {
    logger.error('Server Error:', serverError);

    // Return a structured error response even for unexpected errors
    return res.status(200).json({
      status: 'server_error',
      message: 'The server encountered an unexpected error',
      error_details: serverError.message || 'Unknown server error',
      timestamp: global.Utils.toIsoString(new Date()),
    });
  }
});

// API endpoint to fetch recent matches
app.post('/api/matches', async (req, res) => {
  logger.debug('Received request for /api/matches');
  logger.debug(
    `Request IP: ${
      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
    }`
  );
  logger.debug(
    `Request JSON: ${JSON.stringify({
      username: req.body.username,
      platform: req.body.platform,
      game: req.body.game,
      sanitize: req.body.sanitize,
      replaceKeys: req.body.replaceKeys,
    })}`
  );

  try {
    let { username, ssoToken, platform, game, sanitize, replaceKeys } =
      req.body;

    /*
    logger.debug(
       `Request details - Username: ${username}, Platform: ${platform}, Game: ${game}`
    );

    logger.debug("=== MATCHES REQUEST ===");
    logger.debug(`Username: ${username}`);
    logger.debug(`Platform: ${platform}`);
    logger.debug(`Game: ${game}`);
    logger.debug(`Processing Options - Sanitize: ${sanitize}, Replace Keys: ${replaceKeys}`);
    logger.debug("========================"); */

    const defaultToken = demoTracker.getDefaultSsoToken();
    if (!ssoToken && defaultToken) {
      ssoToken = defaultToken;
      logger.info('Using default SSO token for demo mode');
    } else if (!ssoToken) {
      return res.status(200).json({
        status: 'error',
        message: 'SSO Token is required',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    if (!username) {
      return res.status(400).json({ error: 'Username is required' });
    }

    if (!username || !ssoToken) {
      return res
        .status(400)
        .json({ error: 'Username and SSO Token are required' });
    }

    try {
      await ensureLogin(ssoToken);
    } catch (loginError) {
      return res.status(200).json({
        status: 'error',
        error_type: 'LoginError',
        message: 'SSO token login failed',
        details: loginError.message || 'Unknown login error',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    // Create a wrapped function for each API call to handle timeout
    const fetchWithTimeout = async (apiFn) => {
      return Promise.race([
        apiFn(),
        timeoutPromise(30000), // 30 second timeout
      ]);
    };

    try {
      logger.debug(
        `Attempting to fetch combat history for ${username} on ${platform}`
      );
      let data;

      // Check if the platform is valid for the game
      const requiresUno = ['mw2', 'wz2', 'mw3', 'wzm'].includes(game);
      if (requiresUno && platform !== 'uno') {
        return res.status(200).json({
          status: 'error',
          message: `${game} requires Uno ID (numerical ID)`,
          timestamp: global.Utils.toIsoString(new Date()),
        });
      }

      // Fetch combat history based on game
      switch (game) {
        case 'mw':
          data = await fetchWithTimeout(() =>
            API.ModernWarfare.combatHistory(username, platform)
          );
          break;
        case 'wz':
          data = await fetchWithTimeout(() =>
            API.Warzone.combatHistory(username, platform)
          );
          break;
        case 'mw2':
          data = await fetchWithTimeout(() =>
            API.ModernWarfare2.combatHistory(username)
          );
          break;
        case 'wz2':
          data = await fetchWithTimeout(() =>
            API.Warzone2.combatHistory(username)
          );
          break;
        case 'mw3':
          data = await fetchWithTimeout(() =>
            API.ModernWarfare3.combatHistory(username)
          );
          break;
        case 'cw':
          data = await fetchWithTimeout(() =>
            API.ColdWar.combatHistory(username, platform)
          );
          break;
        case 'vg':
          data = await fetchWithTimeout(() =>
            API.Vanguard.combatHistory(username, platform)
          );
          break;
        case 'wzm':
          data = await fetchWithTimeout(() =>
            API.WarzoneMobile.combatHistory(username)
          );
          break;
        default:
          return res.status(200).json({
            status: 'error',
            message: 'Invalid game selected',
            timestamp: global.Utils.toIsoString(new Date()),
          });
      }

      const { sanitize, replaceKeys } = req.body;

      demoTracker.incrementDemoCounter(req, ssoToken);

      return res.json({
        // status: "success",
        data: processJsonOutput(data, { sanitize, replaceKeys }),
        timestamp: global.Utils.toIsoString(new Date()),
      });
    } catch (apiError) {
      return handleApiError(apiError, res);
    }
  } catch (serverError) {
    return res.status(200).json({
      status: 'server_error',
      message: 'The server encountered an unexpected error',
      error_details: serverError.message || 'Unknown server error',
      timestamp: global.Utils.toIsoString(new Date()),
    });
  }
});

// API endpoint to fetch match info
app.post('/api/matchInfo', async (req, res) => {
  logger.debug('Received request for /api/matchInfo');
  logger.debug(
    `Request IP: ${
      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
    }`
  );
  logger.debug(
    `Request JSON: ${JSON.stringify({
      matchId: req.body.matchId,
      platform: req.body.platform,
      game: req.body.game,
      sanitize: req.body.sanitize,
      replaceKeys: req.body.replaceKeys,
    })}`
  );

  try {
    let { matchId, ssoToken, platform, game, sanitize, replaceKeys } = req.body;

    /*
    logger.debug(
      `Request details - Match ID: ${matchId}, Platform: ${platform}, Game: ${game}`
    );

    logger.debug("=== MATCH INFO REQUEST ===");
    logger.debug(`Match ID: ${matchId}`);
    logger.debug(`Platform: ${platform}`);
    logger.debug(`Game: ${game}`);
    logger.debug(`Processing Options - Sanitize: ${sanitize}, Replace Keys: ${replaceKeys}`);
    logger.debug("=========================="); */

    const defaultToken = demoTracker.getDefaultSsoToken();
    if (!ssoToken && defaultToken) {
      ssoToken = defaultToken;
      logger.info('Using default SSO token for demo mode');
    } else if (!ssoToken) {
      return res.status(200).json({
        status: 'error',
        message: 'SSO Token is required',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    if (!matchId) {
      return res.status(400).json({ error: 'Match ID is required' });
    }

    if (!matchId || !ssoToken) {
      return res
        .status(400)
        .json({ error: 'Match ID and SSO Token are required' });
    }

    try {
      await ensureLogin(ssoToken);
    } catch (loginError) {
      return res.status(200).json({
        status: 'error',
        error_type: 'LoginError',
        message: 'SSO token login failed',
        details: loginError.message || 'Unknown login error',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    // Create a wrapped function for each API call to handle timeout
    const fetchWithTimeout = async (apiFn) => {
      return Promise.race([
        apiFn(),
        timeoutPromise(30000), // 30 second timeout
      ]);
    };

    try {
      logger.debug(`Attempting to fetch match info for match ID: ${matchId}`);
      let data;

      // Fetch match info based on game
      switch (game) {
        case 'mw':
          data = await fetchWithTimeout(() =>
            API.ModernWarfare.matchInfo(matchId, platform)
          );
          break;
        case 'wz':
          data = await fetchWithTimeout(() =>
            API.Warzone.matchInfo(matchId, platform)
          );
          break;
        case 'mw2':
          data = await fetchWithTimeout(() =>
            API.ModernWarfare2.matchInfo(matchId)
          );
          break;
        case 'wz2':
          data = await fetchWithTimeout(() => API.Warzone2.matchInfo(matchId));
          break;
        case 'mw3':
          data = await fetchWithTimeout(() =>
            API.ModernWarfare3.matchInfo(matchId)
          );
          break;
        case 'cw':
          data = await fetchWithTimeout(() =>
            API.ColdWar.matchInfo(matchId, platform)
          );
          break;
        case 'vg':
          data = await fetchWithTimeout(() =>
            API.Vanguard.matchInfo(matchId, platform)
          );
          break;
        case 'wzm':
          data = await fetchWithTimeout(() =>
            API.WarzoneMobile.matchInfo(matchId)
          );
          break;
        default:
          return res.status(200).json({
            status: 'error',
            message: 'Invalid game selected',
            timestamp: global.Utils.toIsoString(new Date()),
          });
      }

      const { sanitize, replaceKeys } = req.body;

      demoTracker.incrementDemoCounter(req, ssoToken);

      return res.json({
        // status: "success",
        data: processJsonOutput(data, { sanitize, replaceKeys }),
        timestamp: global.Utils.toIsoString(new Date()),
      });
    } catch (apiError) {
      return handleApiError(apiError, res);
    }
  } catch (serverError) {
    return res.status(200).json({
      status: 'server_error',
      message: 'The server encountered an unexpected error',
      error_details: serverError.message || 'Unknown server error',
      timestamp: global.Utils.toIsoString(new Date()),
    });
  }
});

// API endpoint for user-related API calls
app.post('/api/user', async (req, res) => {
  logger.debug('Received request for /api/user');
  logger.debug(
    `Request IP: ${
      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
    }`
  );
  logger.debug(
    `Request JSON: ${JSON.stringify({
      username: req.body.username,
      platform: req.body.platform,
      userCall: req.body.userCall,
      sanitize: req.body.sanitize,
      replaceKeys: req.body.replaceKeys,
    })}`
  );

  try {
    let { username, ssoToken, platform, userCall, sanitize, replaceKeys } =
      req.body;

    /*
    logger.debug(
      `Request details - Username: ${username}, Platform: ${platform}, User Call: ${userCall}`
    );

    logger.debug("=== USER DATA REQUEST ===");
    logger.debug(`Username: ${username || 'Not provided'}`);
    logger.debug(`Platform: ${platform}`);
    logger.debug(`User Call: ${userCall}`);
    logger.debug(`Processing Options - Sanitize: ${sanitize}, Replace Keys: ${replaceKeys}`);
    logger.debug("========================="); */

    const defaultToken = demoTracker.getDefaultSsoToken();
    if (!ssoToken && defaultToken) {
      ssoToken = defaultToken;
      logger.info('Using default SSO token for demo mode');
    } else if (!ssoToken) {
      return res.status(200).json({
        status: 'error',
        message: 'SSO Token is required',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    // For eventFeed and identities, username is not required
    if (
      !username &&
      userCall !== 'eventFeed' &&
      userCall !== 'friendFeed' &&
      userCall !== 'identities'
    ) {
      return res
        .status(400)
        .json({ error: 'Username is required for this API call' });
    }

    try {
      await ensureLogin(ssoToken);
    } catch (loginError) {
      return res.status(200).json({
        status: 'error',
        error_type: 'LoginError',
        message: 'SSO token login failed',
        details: loginError.message || 'Unknown login error',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    // Create a wrapped function for each API call to handle timeout
    const fetchWithTimeout = async (apiFn) => {
      return Promise.race([
        apiFn(),
        timeoutPromise(30000), // 30 second timeout
      ]);
    };

    try {
      logger.debug(`Attempting to fetch user data for ${userCall}`);
      let data;

      // Fetch user data based on userCall
      switch (userCall) {
        case 'codPoints':
          data = await fetchWithTimeout(() =>
            API.Me.codPoints(username, platform)
          );
          break;
        case 'connectedAccounts':
          data = await fetchWithTimeout(() =>
            API.Me.connectedAccounts(username, platform)
          );
          break;
        case 'eventFeed':
          data = await fetchWithTimeout(() => API.Me.eventFeed());
          break;
        case 'friendFeed':
          data = await fetchWithTimeout(() =>
            API.Me.friendFeed(username, platform)
          );
          break;
        case 'identities':
          data = await fetchWithTimeout(() => API.Me.loggedInIdentities());
          break;
        case 'friendsList':
          data = await fetchWithTimeout(() => API.Me.friendsList());
          break;
        // case "settings":
        //   data = await fetchWithTimeout(() =>
        //     API.Me.settings(username, platform)
        //   );
        //   break;
        default:
          return res.status(200).json({
            status: 'error',
            message: 'Invalid user API call selected',
            timestamp: global.Utils.toIsoString(new Date()),
          });
      }

      const { sanitize, replaceKeys } = req.body;

      demoTracker.incrementDemoCounter(req, ssoToken);

      return res.json({
        // status: "success",
        data: processJsonOutput(data, { sanitize, replaceKeys }),
        timestamp: global.Utils.toIsoString(new Date()),
      });
    } catch (apiError) {
      return handleApiError(apiError, res);
    }
  } catch (serverError) {
    return res.status(200).json({
      status: 'server_error',
      message: 'The server encountered an unexpected error',
      error_details: serverError.message || 'Unknown server error',
      timestamp: global.Utils.toIsoString(new Date()),
    });
  }
});

// API endpoint for fuzzy search
app.post('/api/search', async (req, res) => {
  logger.debug('Received request for /api/search');
  logger.debug(
    `Request IP: ${
      req.headers['x-forwarded-for'] || req.ip || req.connection.remoteAddress
    }`
  );
  logger.debug(
    `Request JSON: ${JSON.stringify({
      username: req.body.username,
      platform: req.body.platform,
      sanitize: req.body.sanitize,
      replaceKeys: req.body.replaceKeys,
    })}`
  );

  try {
    let { username, ssoToken, platform, sanitize, replaceKeys } = req.body;

    /*
    logger.debug(
      `Request details - Match ID: ${matchId}, Platform: ${platform}, Game: ${game}`
    );

    logger.debug("=== MATCH INFO REQUEST ===");
    logger.debug(`Match ID: ${matchId}`);
    logger.debug(`Platform: ${platform}`);
    logger.debug(`Game: ${game}`);
    logger.debug(`Processing Options - Sanitize: ${sanitize}, Replace Keys: ${replaceKeys}`);
    logger.debug("=========================="); */

    const defaultToken = demoTracker.getDefaultSsoToken();
    if (!ssoToken && defaultToken) {
      ssoToken = defaultToken;
      logger.info('Using default SSO token for demo mode');
    } else if (!ssoToken) {
      return res.status(200).json({
        status: 'error',
        message: 'SSO Token is required',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    if (!username) {
      return res.status(400).json({ error: 'Username is required' });
    }

    if (!username || !ssoToken) {
      return res
        .status(400)
        .json({ error: 'Username and SSO Token are required' });
    }

    try {
      await ensureLogin(ssoToken);
    } catch (loginError) {
      return res.status(200).json({
        status: 'error',
        error_type: 'LoginError',
        message: 'SSO token login failed',
        details: loginError.message || 'Unknown login error',
        timestamp: global.Utils.toIsoString(new Date()),
      });
    }

    // Create a wrapped function for each API call to handle timeout
    const fetchWithTimeout = async (apiFn) => {
      return Promise.race([
        apiFn(),
        timeoutPromise(30000), // 30 second timeout
      ]);
    };

    try {
      logger.debug(
        `Attempting fuzzy search for ${username} on platform ${platform}`
      );
      const data = await fetchWithTimeout(() =>
        API.Misc.search(username, platform)
      );

      const { sanitize, replaceKeys } = req.body;

      demoTracker.incrementDemoCounter(req, ssoToken);

      return res.json({
        // status: "success",
        data: processJsonOutput(data, { sanitize, replaceKeys }),
        timestamp: global.Utils.toIsoString(new Date()),
        // link: "Stats pulled using codtracker.rimmyscorner.com",
      });
    } catch (apiError) {
      return handleApiError(apiError, res);
    }
  } catch (serverError) {
    return res.status(200).json({
      status: 'server_error',
      message: 'The server encountered an unexpected error',
      error_details: serverError.message || 'Unknown server error',
      timestamp: global.Utils.toIsoString(new Date()),
    });
  }
});

// Improved logging endpoint
app.post('/api/log', (req, res) => {
  const clientIP =
    req.headers['cf-connecting-ip'] ||
    req.headers['x-forwarded-for']?.split(',')[0] ||
    req.ip ||
    req.connection.remoteAddress;
  const userAgent = req.headers['user-agent'];
  const referer = req.headers['referer'];
  const origin = req.headers['origin'];
  let logData;

  try {
    // Handle data whether it comes as already parsed JSON or as a string
    if (typeof req.body === 'string') {
      logData = JSON.parse(req.body);
    } else if (req.body && typeof req.body === 'object') {
      logData = req.body;
    } else {
      // If no parsable data found, create a basic log entry
      logData = {
        eventType: 'unknown',
        timestamp: global.Utils.toIsoString(new Date()),
      };
    }

    // Enrich log with server-side data
    const enrichedLog = {
      ...logData,
      meta: {
        clientIP,
        userAgent,
        referer,
        origin,
        requestHeaders: sanitizeHeaders(req.headers),
        serverTimestamp: global.Utils.toIsoString(new Date()),
        requestId: req.id || Math.random().toString(36).substring(2, 15),
      },
    };

    // Use the dedicated user activity logger
    logger.userActivity(enrichedLog.eventType || 'unknown', enrichedLog);
  } catch (error) {
    logger.error('Error processing log data', {
      error: error.message,
      rawBody: typeof req.body === 'object' ? '[Object]' : req.body,
    });
  }

  // Always return 200 to avoid client-side errors
  res.status(200).send();
});

// Database storage function
/*
function storeLogInDatabase(logData) {
  // Example with MongoDB
  db.collection('user_logs').insertOne(logData)
    .catch(err => logger.error('Failed to store log in database:', err));
}
*/

// Start the server
app.listen(port, () => {
  logger.info(`Server running on http://localhost:${port}`);
});