server.js

const net = require('net');
const http = require('http');
const fs = require('fs');
const path = require('path');
const RESPParser = require('./parser');
const { handleCommand } = require('./commands');

const store = require('./store');

// Stats
const stats = {
    startTime: Date.now(),
    commandsProcessed: 0,
    connections: 0
};

// --- TCP Server ---
const tcpServer = net.createServer((socket) => {
  stats.connections++;
  const parser = new RESPParser();

  socket.on('data', (data) => {
    parser.append(data);
    for (const command of parser.parse()) {
      stats.commandsProcessed++;
      const result = handleCommand(command);
      const resp = encodeRESP(result);
      socket.write(resp);
    }
  });

  socket.on('error', (err) => {
    console.error('Socket error:', err);
  });
  
  socket.on('close', () => {
    stats.connections--;
  });
});

function encodeRESP(data) {
  if (data === null) {
    return '$-1\r\n';
  } else if (data instanceof Error) {
    return `-${data.message}\r\n`;
  } else if (typeof data === 'string') {
    if (data === 'OK' || data === 'PONG') {
        return `+${data}\r\n`;
    }
    return `$${Buffer.byteLength(data)}\r\n${data}\r\n`;
  } else if (typeof data === 'number') {
    return `:${data}\r\n`;
  } else if (Array.isArray(data)) {
      let resp = `*${data.length}\r\n`;
      for(const item of data) {
          resp += encodeRESP(item);
      }
      return resp;
  }
  return '-ERR internal error\r\n';
}

const TCP_PORT = 6379;
tcpServer.listen(TCP_PORT, () => {
  console.log(`Mini Redis TCP server running on port ${TCP_PORT}`);
});

// --- HTTP Server ---
const httpServer = http.createServer((req, res) => {
    if (req.method === 'GET' && req.url === '/stats') {
        const uptime = Math.floor((Date.now() - stats.startTime) / 1000);
        const data = {
            uptime,
            commandsProcessed: stats.commandsProcessed,
            connections: stats.connections,
            keyCount: store.data.size,
            memory: process.memoryUsage().rss
        };
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(data));
        return;
    }

    if (req.method === 'GET') {
        let filePath = path.join(__dirname, 'public', req.url === '/' ? 'index.html' : req.url);
        const extname = path.extname(filePath);
        let contentType = 'text/html';
        
        switch (extname) {
            case '.js': contentType = 'text/javascript'; break;
            case '.css': contentType = 'text/css'; break;
        }

        fs.readFile(filePath, (err, content) => {
            if (err) {
                if(err.code == 'ENOENT') {
                    res.writeHead(404);
                    res.end('404 Not Found');
                } else {
                    res.writeHead(500);
                    res.end('500 Internal Server Error');
                }
            } else {
                res.writeHead(200, { 'Content-Type': contentType });
                res.end(content, 'utf-8');
            }
        });
    } else if (req.method === 'POST' && req.url === '/cmd') {
        let body = '';
        req.on('data', chunk => { body += chunk.toString(); });
        req.on('end', () => {
            try {
                stats.commandsProcessed++;
                const { command } = JSON.parse(body);
                // Naive command parsing: split by spaces, preserving quotes could be added later
                const args = command.trim().split(/\s+/);
                
                // Helper to handle simple quoted strings if needed, 
                // but for now simple split is fine for basic commands.
                
                const result = handleCommand(args);
                
                // Convert Error to simple object for JSON
                if (result instanceof Error) {
                    res.writeHead(200, { 'Content-Type': 'application/json' });
                    res.end(JSON.stringify({ error: result.message }));
                } else {
                    res.writeHead(200, { 'Content-Type': 'application/json' });
                    res.end(JSON.stringify({ result }));
                }
            } catch (e) {
                res.writeHead(400);
                res.end(JSON.stringify({ error: 'Invalid request' }));
            }
        });
    } else {
        res.writeHead(404);
        res.end();
    }
});

const HTTP_PORT = 8080;
httpServer.listen(HTTP_PORT, () => {
    console.log(`Mini Redis Web Interface running at http://localhost:${HTTP_PORT}`);
});