server.js

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

const host = process.env.HOST || '0.0.0.0';
const port = Number(process.env.PORT || 3000);
const publicDir = path.join(__dirname, 'public');
const dataFile = path.join(__dirname, 'data', 'todos.json');

fs.mkdirSync(path.dirname(dataFile), { recursive: true });
if (!fs.existsSync(dataFile)) {
  fs.writeFileSync(dataFile, '[]\n', 'utf8');
}

function sendJson(res, status, payload) {
  res.writeHead(status, {
    'Content-Type': 'application/json; charset=utf-8',
    'Cache-Control': 'no-store'
  });
  res.end(JSON.stringify(payload));
}

function readTodos() {
  try {
    return JSON.parse(fs.readFileSync(dataFile, 'utf8'));
  } catch {
    return [];
  }
}

function writeTodos(todos) {
  fs.writeFileSync(dataFile, JSON.stringify(todos, null, 2) + '\n', 'utf8');
}

function parseBody(req) {
  return new Promise((resolve, reject) => {
    let body = '';
    req.on('data', chunk => {
      body += chunk;
      if (body.length > 1_000_000) {
        reject(new Error('Body too large'));
        req.destroy();
      }
    });
    req.on('end', () => {
      if (!body) return resolve({});
      try {
        resolve(JSON.parse(body));
      } catch {
        reject(new Error('Invalid JSON body'));
      }
    });
    req.on('error', reject);
  });
}

function serveStatic(res, filePath, contentType) {
  try {
    const content = fs.readFileSync(filePath);
    res.writeHead(200, { 'Content-Type': contentType + '; charset=utf-8' });
    res.end(content);
  } catch {
    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
    res.end('Not found');
  }
}

const server = http.createServer(async (req, res) => {
  const url = new URL(req.url, `http://${req.headers.host || `${host}:${port}`}`);

  if (req.method === 'GET' && (url.pathname === '/health' || url.pathname === '/api/health')) {
    return sendJson(res, 200, { ok: true, service: 'todo-prototype', port, host });
  }

  if (req.method === 'GET' && url.pathname === '/api/todos') {
    return sendJson(res, 200, { todos: readTodos() });
  }

  if (req.method === 'POST' && url.pathname === '/api/todos') {
    try {
      const body = await parseBody(req);
      const text = String(body.text || '').trim();
      if (!text) return sendJson(res, 400, { error: 'Todo text is required' });

      const todos = readTodos();
      const todo = {
        id: Date.now().toString(36),
        text,
        completed: false,
        createdAt: new Date().toISOString()
      };
      todos.unshift(todo);
      writeTodos(todos);
      return sendJson(res, 201, { todo, todos });
    } catch (error) {
      return sendJson(res, 400, { error: error.message });
    }
  }

  if (req.method === 'PATCH' && url.pathname.startsWith('/api/todos/')) {
    try {
      const id = url.pathname.split('/').pop();
      const body = await parseBody(req);
      const todos = readTodos();
      const index = todos.findIndex(todo => todo.id === id);
      if (index === -1) return sendJson(res, 404, { error: 'Todo not found' });
      todos[index] = { ...todos[index], completed: Boolean(body.completed) };
      writeTodos(todos);
      return sendJson(res, 200, { todo: todos[index], todos });
    } catch (error) {
      return sendJson(res, 400, { error: error.message });
    }
  }

  if (req.method === 'DELETE' && url.pathname.startsWith('/api/todos/')) {
    const id = url.pathname.split('/').pop();
    const todos = readTodos();
    const nextTodos = todos.filter(todo => todo.id !== id);
    if (nextTodos.length === todos.length) {
      return sendJson(res, 404, { error: 'Todo not found' });
    }
    writeTodos(nextTodos);
    return sendJson(res, 200, { deleted: id, todos: nextTodos });
  }

  if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/index.html')) {
    return serveStatic(res, path.join(publicDir, 'index.html'), 'text/html');
  }

  if (req.method === 'GET' && url.pathname === '/styles.css') {
    return serveStatic(res, path.join(publicDir, 'styles.css'), 'text/css');
  }

  if (req.method === 'GET' && url.pathname === '/app.js') {
    return serveStatic(res, path.join(publicDir, 'app.js'), 'application/javascript');
  }

  res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
  res.end(JSON.stringify({ error: 'Not found' }));
});

server.listen(port, host, () => {
  console.log(`TODO prototype listening on http://${host}:${port}`);
});