server.js

const http = require('http');
const fs = require('fs');
const path = require('path');
const url = require('url');

const DIST_DIR = path.join(__dirname, 'dist');
// Check if IS_PRODUCTION is set to true
const isProduction = process.env.IS_PRODUCTION === 'true';
// In production mode, dist directory must exist
if (isProduction && !fs.existsSync(DIST_DIR)) {
  throw new Error(`Production mode enabled but dist directory does not exist: ${DIST_DIR}`);
}
// Force port 3000 in production, otherwise use PORT environment variable or default to 3000
const PORT = isProduction ? 3000 : (process.env.PORT || 3000);

// Config file path resolution
const CONFIG_PATH_ENV = process.env.CONFIG_PATH || './config.json';
const CONFIG_PATH = path.resolve(__dirname, CONFIG_PATH_ENV);

// Logs directory path
const LOGS_DIR = path.join(__dirname, 'logs');

// MIME types for different file extensions
const mimeTypes = {
  '.html': 'text/html',
  '.js': 'text/javascript',
  '.css': 'text/css',
  '.json': 'application/json',
  '.png': 'image/png',
  '.jpg': 'image/jpeg',
  '.jpeg': 'image/jpeg',
  '.gif': 'image/gif',
  '.svg': 'image/svg+xml',
  '.ico': 'image/x-icon',
  '.woff': 'font/woff',
  '.woff2': 'font/woff2',
  '.ttf': 'font/ttf',
  '.eot': 'application/vnd.ms-fontobject'
};

// Get MIME type based on file extension
function getMimeType(filePath) {
  const ext = path.extname(filePath).toLowerCase();
  return mimeTypes[ext] || 'text/plain';
}

// Serve static files
function serveFile(filePath, res) {
  fs.readFile(filePath, (err, data) => {
    if (err) {
      res.writeHead(404, { 'Content-Type': 'text/plain' });
      res.end('File not found');
      return;
    }

    const mimeType = getMimeType(filePath);
    res.writeHead(200, { 'Content-Type': mimeType });
    res.end(data);
  });
}

// Ensure logs directory exists
function ensureLogsDirectory() {
  if (!fs.existsSync(LOGS_DIR)) {
    try {
      fs.mkdirSync(LOGS_DIR, { recursive: true });
      console.log(`Created logs directory: ${LOGS_DIR}`);
    } catch (error) {
      console.error(`Failed to create logs directory: ${error.message}`);
    }
  }
}

// Write log to file
function writeLog(type, message, callback) {
  const logFile = type === 'activity' ? 'activity.log' : 'debug.log';
  const logPath = path.join(LOGS_DIR, logFile);
  const logLine = `${message}\n`;

  fs.appendFile(logPath, logLine, 'utf8', (error) => {
    if (error) {
      console.error(`Failed to write log to ${logPath}:`, error.message);
    }
    if (callback) {
      callback(error);
    }
  });
}

// Serve config file from external path
function serveConfigFile(req, res) {
  // Resolve the config path (from env var or default)
  const resolvedConfigPath = path.resolve(CONFIG_PATH);

  // Attempt to read the file directly - handle errors appropriately
  fs.readFile(resolvedConfigPath, (err, data) => {
    if (err) {
      // File not found - return 404 so client falls back to default-config.js
      if (err.code === 'ENOENT') {
        res.writeHead(404, { 'Content-Type': 'text/plain' });
        res.end('Config file not found');
        return;
      }
      // Other errors (permissions, I/O issues, etc.) - return 500
      res.writeHead(500, { 'Content-Type': 'text/plain' });
      res.end('Error reading config file');
      return;
    }

    // Success - serve the config file
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(data);
  });
}

// Handle POST requests
function handlePostRequest(req, res, parsedUrl) {
  if (parsedUrl.pathname === '/api/logs') {
    let body = '';

    req.on('data', chunk => {
      body += chunk.toString();
    });

    req.on('end', () => {
      try {
        const data = JSON.parse(body);
        const { type, message } = data;

        // Validate request
        if (typeof type !== 'string' || typeof message !== 'string') {
          res.writeHead(400, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ error: 'Type and message must be strings' }));
          return;
        }

        if (type !== 'activity' && type !== 'debug') {
          res.writeHead(400, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ error: 'Invalid log type. Must be "activity" or "debug"' }));
          return;
        }

        // Write log to file
        writeLog(type, message, (error) => {
          if (error) {
            res.writeHead(500, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: 'Failed to write log' }));
            return;
          }

          res.writeHead(200, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ success: true }));
        });

      } catch (error) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'Invalid JSON' }));
      }
    });
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not found');
  }
}

// Create HTTP server
const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url, true);
  let pathName = parsedUrl.pathname === '/' ? '/index.html' : parsedUrl.pathname;

  // Handle POST requests
  if (req.method === 'POST') {
    handlePostRequest(req, res, parsedUrl);
    return;
  }

  // In production mode, handle config.json requests specially
  if (isProduction && pathName === '/configs/config.json') {
    serveConfigFile(req, res);
    return;
  }

  // In production mode, serve static files from dist directory
  if (isProduction) {
    // Strip leading slashes so path.join/resolve can't ignore DIST_DIR
    let filePath = path.join(DIST_DIR, pathName.replace(/^\/+/, ''));

    // Security check - prevent directory traversal
    const resolvedDistDir = path.resolve(DIST_DIR);
    const resolvedFilePath = path.resolve(filePath);
    const relativePath = path.relative(resolvedDistDir, resolvedFilePath);

    // Reject if path tries to traverse outside the base directory
    if (relativePath.startsWith('..')) {
      res.writeHead(403, { 'Content-Type': 'text/plain' });
      res.end('Forbidden');
      return;
    }

    serveFile(filePath, res);
  } else {
    // Development mode - static files are served by Vite
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not found (development mode - use Vite dev server `npm run start:dev`)');
  }
});

// Start server
server.listen(PORT, () => {
  // Ensure logs directory exists on startup
  ensureLogsDirectory();

  console.log(`Server running at http://localhost:${PORT}`);
  if (isProduction) {
    console.log(`Serving static files from: ${DIST_DIR}`);
    console.log(`Config file path: ${CONFIG_PATH} (from ${CONFIG_PATH_ENV})`);
    // Check if config file exists and log status
    fs.access(CONFIG_PATH, fs.constants.F_OK, (err) => {
      if (err) {
        console.log(`Config file not found at ${CONFIG_PATH} - client will use default-config.js`);
      } else {
        console.log(`Config file found at ${CONFIG_PATH}`);
      }
    });
  } else {
    console.log(`Development mode - static files served by Vite`);
  }
  console.log(`Logging endpoint available at /api/logs`);
  console.log('Press Ctrl+C to stop the server');
});

// Handle server errors
server.on('error', (err) => {
  if (err.code === 'EADDRINUSE') {
    console.error(`Port ${PORT} is already in use. Please try a different port.`);
  } else {
    console.error('Server error:', err);
  }
  process.exit(1);
});

// Graceful shutdown
process.on('SIGINT', () => {
  console.log('\nShutting down server...');
  server.close(() => {
    console.log('Server closed');
    process.exit(0);
  });
});