require('dotenv').config();

const http = require('node:http');
const { handler } = require('./index');

const DEFAULT_PORT = 3000;
const DEFAULT_BODY_LIMIT_BYTES = 1024 * 1024;

function getCorsHeaders() {
  const origin = process.env.API_CORS_ORIGIN;
  if (!origin) {
    return {};
  }

  return {
    'access-control-allow-origin': origin,
    'access-control-allow-headers': 'content-type, authorization, x-api-token',
    'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS'
  };
}

function buildEvent(request, body) {
  const url = new URL(request.url || '/', `http://${request.headers.host || 'localhost'}`);
  const queryStringParameters = {};

  for (const [key, value] of url.searchParams.entries()) {
    queryStringParameters[key] = value;
  }

  return {
    rawPath: url.pathname,
    path: url.pathname,
    rawQueryString: url.searchParams.toString(),
    queryStringParameters,
    headers: request.headers,
    httpMethod: request.method,
    body: body || undefined,
    isBase64Encoded: false,
    requestContext: {
      http: {
        method: request.method,
        path: url.pathname,
        sourceIp: request.socket.remoteAddress,
        userAgent: request.headers['user-agent']
      }
    }
  };
}

function readBody(request) {
  const limit = Number(process.env.MAX_BODY_BYTES || DEFAULT_BODY_LIMIT_BYTES);

  return new Promise((resolve, reject) => {
    const chunks = [];
    let total = 0;
    let settled = false;

    request.on('data', (chunk) => {
      if (settled) {
        return;
      }

      total += chunk.length;
      if (total > limit) {
        settled = true;
        const error = new Error('Request body is too large.');
        error.statusCode = 413;
        reject(error);
        request.destroy();
        return;
      }

      chunks.push(chunk);
    });

    request.on('end', () => {
      if (!settled) {
        settled = true;
        resolve(Buffer.concat(chunks).toString('utf8'));
      }
    });

    request.on('error', (error) => {
      if (!settled) {
        settled = true;
        reject(error);
      }
    });
  });
}

function writeJson(response, statusCode, body, headers = {}) {
  response.writeHead(statusCode, {
    'content-type': 'application/json',
    ...getCorsHeaders(),
    ...headers
  });
  response.end(JSON.stringify(body));
}

async function handleRequest(request, response) {
  if (request.method === 'OPTIONS' && process.env.API_CORS_ORIGIN) {
    response.writeHead(204, getCorsHeaders());
    response.end();
    return;
  }

  const path = new URL(request.url || '/', `http://${request.headers.host || 'localhost'}`).pathname;
  if (path === '/health') {
    writeJson(response, 200, { ok: true });
    return;
  }

  try {
    const body = await readBody(request);
    const result = await handler(buildEvent(request, body));
    response.writeHead(result.statusCode || 200, {
      ...getCorsHeaders(),
      ...(result.headers || {})
    });
    response.end(result.body || '');
  } catch (error) {
    writeJson(response, error.statusCode || 500, {
      message: error.message || 'Internal Server Error'
    });
  }
}

function startServer() {
  const port = Number(process.env.PORT || DEFAULT_PORT);
  const host = process.env.HOST || '127.0.0.1';
  const server = http.createServer(handleRequest);

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

  return server;
}

if (require.main === module) {
  startServer();
}

module.exports = {
  buildEvent,
  handleRequest,
  startServer
};