loxpress.js

import { net } from 'lib/net.js'
import { Loop } from 'lib/loop.js'
import { RequestParser } from 'lib/pico.js'

const { ptr } = lo
const {
  socket: createSocket, bind: netBind, listen: netListen,
  accept4, setsockopt, send_string, recv2, close: netClose
} = net
const {
  AF_INET, SOCK_STREAM, SOCK_NONBLOCK, SOL_SOCKET, SOCKADDR_LEN,
  O_NONBLOCK, EAGAIN
} = net.constants

const BUF_SIZE = 65536

const STATUS_CODES = {
  200: 'OK',
  201: 'Created',
  204: 'No Content',
  301: 'Moved Permanently',
  302: 'Found',
  304: 'Not Modified',
  400: 'Bad Request',
  401: 'Unauthorized',
  403: 'Forbidden',
  404: 'Not Found',
  405: 'Method Not Allowed',
  409: 'Conflict',
  422: 'Unprocessable Entity',
  429: 'Too Many Requests',
  500: 'Internal Server Error',
  502: 'Bad Gateway',
  503: 'Service Unavailable'
}

// Pre-allocated recv buffer + parser (reused across requests since handling is synchronous)
const recvBuf = ptr(new Uint8Array(BUF_SIZE))
const parser = new RequestParser(recvBuf)

// Pre-allocated handler array (reused per request, cleared before use)
const handlersBuf = []

// Pre-built 404 handler (shared, not created per request)
function notFoundHandler (rq, rs) {
  rs.status(404).send('{"error":"Not Found"}', 'application/json')
}

// --- Route compilation & matching ---

function compileRoute (pattern) {
  if (pattern.indexOf(':') === -1) {
    return { exact: pattern, regex: null, keys: null }
  }
  const keys = []
  const regexStr = pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, key) => {
    keys.push(key)
    return '([^/]+)'
  })
  return { exact: null, regex: new RegExp(`^${regexStr}$`), keys }
}

function matchRoute (compiled, pathname) {
  if (compiled.exact !== null) {
    return pathname === compiled.exact ? {} : null
  }
  const m = compiled.regex.exec(pathname)
  if (!m) return null
  const params = {}
  for (let i = 0; i < compiled.keys.length; i++) {
    params[compiled.keys[i]] = decodeURIComponent(m[i + 1])
  }
  return params
}

// --- Query string parsing ---

const emptyQuery = Object.create(null)

function parseQueryString (qs) {
  if (!qs) return emptyQuery
  const result = Object.create(null)
  const pairs = qs.split('&')
  for (let i = 0; i < pairs.length; i++) {
    const idx = pairs[i].indexOf('=')
    if (idx === -1) {
      result[decodeURIComponent(pairs[i])] = ''
    } else {
      result[decodeURIComponent(pairs[i].slice(0, idx))] =
        decodeURIComponent(pairs[i].slice(idx + 1))
    }
  }
  return result
}

// --- Inline request + response on a reusable object ---

const emptyParams = Object.create(null)

const req = {
  method: '',
  url: '',
  path: '',
  query: emptyQuery,
  headers: null,
  params: emptyParams,
  body: null,
  _parsedBytes: 0,
  _bytesRead: 0
}

// --- Response (writes directly, minimal object) ---

function sendResponse (fd, statusCode, body, contentType) {
  const statusText = STATUS_CODES[statusCode] || 'Unknown'
  const response = contentType
    ? `HTTP/1.1 ${statusCode} ${statusText}\r\ncontent-type: ${contentType}\r\ncontent-length: ${body.length}\r\nconnection: close\r\n\r\n${body}`
    : `HTTP/1.1 ${statusCode} ${statusText}\r\ncontent-length: ${body.length}\r\nconnection: close\r\n\r\n${body}`
  send_string(fd, response)
}

function createResponse (clientFd) {
  let statusCode = 200
  let extraHeaders = null
  let headersSent = false

  const res = {
    status (code) {
      statusCode = code
      return res
    },
    set (name, value) {
      if (!extraHeaders) extraHeaders = []
      extraHeaders.push(name.toLowerCase(), value)
      return res
    },
    header (name, value) {
      return res.set(name, value)
    },
    json (obj) {
      res.send(JSON.stringify(obj), 'application/json')
    },
    send (body, contentType) {
      if (headersSent) return
      headersSent = true
      if (body == null) body = ''
      if (!extraHeaders) {
        sendResponse(clientFd, statusCode, body, contentType)
      } else {
        // Slow path: custom headers
        const statusText = STATUS_CODES[statusCode] || 'Unknown'
        let head = `HTTP/1.1 ${statusCode} ${statusText}\r\n`
        if (contentType) head += `content-type: ${contentType}\r\n`
        for (let i = 0; i < extraHeaders.length; i += 2) {
          head += `${extraHeaders[i]}: ${extraHeaders[i + 1]}\r\n`
        }
        head += `content-length: ${body.length}\r\nconnection: close\r\n\r\n`
        send_string(clientFd, head + body)
      }
    },
    end (body) {
      if (body !== undefined) {
        res.send(body)
      } else if (!headersSent) {
        res.send('')
      }
    }
  }
  return res
}

// --- Body reading (synchronous from initial recv buffer) ---

const decoder = new TextDecoder()

function readBody (r) {
  const contentLength = parseInt(r.headers['content-length'] || '0', 10)
  if (contentLength === 0) return

  const available = r._bytesRead - r._parsedBytes
  if (available <= 0) return

  const n = Math.min(available, contentLength)
  r.body = decoder.decode(recvBuf.subarray(r._parsedBytes, r._parsedBytes + n))

  const ct = r.headers['content-type'] || ''
  if (ct.indexOf('application/json') !== -1) {
    try { r.body = JSON.parse(r.body) } catch (e) {}
  }
}

// --- Middleware / route dispatch ---

function dispatch (r, res, handlers, idx, len) {
  while (idx < len) {
    const handler = handlers[idx]
    let calledNext = false
    handler(r, res, () => { calledNext = true })
    if (!calledNext) return
    idx++
  }
}

// --- Connection handler ---

const rxUnderscore = /_/g

function handleConnection (clientFd, middlewares, mwLen, routes) {
  const bytesRead = recv2(clientFd, recvBuf.ptr, BUF_SIZE, 0)
  if (bytesRead === -1 && lo.errno === EAGAIN) {
    const loop = lo.loop
    loop.add(clientFd, () => {
      loop.remove(clientFd)
      handleConnection(clientFd, middlewares, mwLen, routes)
    }, Loop.Readable)
    return
  }
  if (bytesRead <= 0) {
    netClose(clientFd)
    return
  }

  const parsed = parser.parse(bytesRead)
  if (parsed <= 0) {
    send_string(clientFd,
      'HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 11\r\n\r\nBad Request')
    netClose(clientFd)
    return
  }

  // Populate reusable req object
  const fullPath = parser.path
  const qIdx = fullPath.indexOf('?')
  req.method = parser.method
  req.url = fullPath
  req.path = qIdx === -1 ? fullPath : fullPath.slice(0, qIdx)
  req.query = qIdx === -1 ? emptyQuery : parseQueryString(fullPath.slice(qIdx + 1))
  req.params = emptyParams
  req.body = null
  req._parsedBytes = parsed
  req._bytesRead = bytesRead

  // Copy headers (picohttp uses underscores)
  const picoHeaders = parser.headers
  const headers = Object.create(null)
  for (const key in picoHeaders) {
    headers[key.replace(rxUnderscore, '-')] = picoHeaders[key]
  }
  req.headers = headers

  const res = createResponse(clientFd)

  const method = req.method
  if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
    readBody(req)
  }

  // Build handler chain into pre-allocated array
  let hLen = 0
  for (let i = 0; i < mwLen; i++) {
    const mw = middlewares[i]
    if (mw.path === null || req.path.startsWith(mw.path)) {
      handlersBuf[hLen++] = mw.handler
    }
  }

  const methodRoutes = routes[method]
  if (methodRoutes) {
    const rLen = methodRoutes.length
    for (let i = 0; i < rLen; i++) {
      const route = methodRoutes[i]
      const params = matchRoute(route.compiled, req.path)
      if (params !== null) {
        req.params = params
        handlersBuf[hLen++] = route.handler
        break
      }
    }
  }

  handlersBuf[hLen++] = notFoundHandler

  dispatch(req, res, handlersBuf, 0, hLen)

  netClose(clientFd)
}

// --- Accept handler ---

function onServerReadable (serverFd, middlewares, mwLen, routes) {
  while (true) {
    const clientFd = accept4(serverFd, 0, 0, O_NONBLOCK)
    if (clientFd <= 0) break
    handleConnection(clientFd, middlewares, mwLen, routes)
  }
}

// --- Server startup ---

function startServer (port, address, middlewares, routes, callback) {
  if (!lo.loop) {
    lo.loop = new Loop()
  }

  const fd = createSocket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0)
  if (fd < 0) throw new Error(`socket failed: errno=${lo.errno}`)

  if (setsockopt && net.on) {
    setsockopt(fd, SOL_SOCKET, net.SO_REUSEADDR || 2, net.on.ptr, 4)
  }

  const addr = ptr(new Uint8Array(16))
  const adv = new DataView(addr.buffer)
  adv.setInt16(0, AF_INET, true)
  adv.setUint16(2, port & 0xffff)
  const parts = address.split('.').map(v => parseInt(v, 10) & 0xff)
  adv.setUint32(4, (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3])

  const rc = netBind(fd, addr.ptr, SOCKADDR_LEN)
  if (rc !== 0) throw new Error(`bind ${address}:${port} failed: errno=${lo.errno}`)

  const rc2 = netListen(fd, 128)
  if (rc2 !== 0) throw new Error(`listen failed: errno=${lo.errno}`)

  if (callback) callback()

  // Cache middleware length for inner loop
  const mwLen = middlewares.length
  const loop = lo.loop
  loop.add(fd, () => onServerReadable(fd, middlewares, mwLen, routes), Loop.Readable)

  while (loop.poll() > 0) {}
}

// --- App factory ---

function loxpress () {
  const middlewares = []
  const routes = {}

  function addRoute (method, pattern, handler) {
    if (!routes[method]) routes[method] = []
    routes[method].push({
      pattern,
      compiled: compileRoute(pattern),
      handler
    })
    return app
  }

  const app = {
    use (pathOrHandler, handler) {
      if (typeof pathOrHandler === 'function') {
        middlewares.push({ path: null, handler: pathOrHandler })
      } else {
        middlewares.push({ path: pathOrHandler, handler })
      }
      return app
    },
    get (pattern, handler) { return addRoute('GET', pattern, handler) },
    post (pattern, handler) { return addRoute('POST', pattern, handler) },
    put (pattern, handler) { return addRoute('PUT', pattern, handler) },
    delete (pattern, handler) { return addRoute('DELETE', pattern, handler) },
    patch (pattern, handler) { return addRoute('PATCH', pattern, handler) },
    listen (port = 3000, addressOrCallback, callback) {
      let address = '0.0.0.0'
      if (typeof addressOrCallback === 'function') {
        callback = addressOrCallback
      } else if (typeof addressOrCallback === 'string') {
        address = addressOrCallback
      }
      startServer(port, address, middlewares, routes, callback)
      return app
    }
  }

  return app
}

export { loxpress }