#!/usr/bin/env node

// `radial-ui` — the static bundle, on loopback.
//
// This is all that is left of the server that used to be here. The old one rendered pages, held app
// passwords and wrote records; this one hands over files, because everything it used to do now happens
// in the tab (phase6-ui-plan §1): the fold runs in the browser, writes go to the human's own PDS under
// their own OAuth session, and there is no session, no CSRF surface and no origin allowlist to get
// right — a request that arrives here can be answered with a file or not at all.
//
// Two rules do all the work:
//
//   - **Anything that is not a file is `index.html`.** The app is a pure SPA with `fallback: index.html`
//     (`svelte.config.js`), so `/g/<did>/<rkey>` has to resolve to the shell and be routed in the
//     browser. A path that names an extension is a missing asset and 404s, because answering a broken
//     `<script src>` with HTML is how a blank page and a syntax error happen instead of a 404.
//   - **`127.0.0.1`, not `localhost`.** atproto's loopback redirect URI must be an IP, so an OAuth
//     session always lands on `127.0.0.1`; served under the other name the tab would sign in and come
//     back to an origin whose IndexedDB holds nothing (`vite.config.ts` binds the same way, for the
//     same reason).
//
// Any static host serves this bundle just as well. It exists so that `radiald`'s operator has one
// command rather than a paragraph about `python -m http.server`.

import { realpathSync } from 'node:fs'
import { readFile, realpath, stat } from 'node:fs/promises'
import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http'
import { dirname, extname, join, resolve, sep } from 'node:path'
import { fileURLToPath, pathToFileURL } from 'node:url'

const TYPES: Record<string, string> = {
  '.html': 'text/html; charset=utf-8',
  '.js': 'text/javascript; charset=utf-8',
  '.css': 'text/css; charset=utf-8',
  '.json': 'application/json; charset=utf-8',
  '.map': 'application/json; charset=utf-8',
  '.svg': 'image/svg+xml',
  '.png': 'image/png',
  '.jpg': 'image/jpeg',
  '.webp': 'image/webp',
  '.ico': 'image/x-icon',
  '.woff2': 'font/woff2',
  '.txt': 'text/plain; charset=utf-8',
}

/** Hashed filenames never change; the shell must not be cached or a deploy is invisible until a hard reload. */
const cacheControl = (pathname: string): string =>
  pathname.startsWith('/_app/immutable/') ? 'public, max-age=31536000, immutable' : 'no-cache'

interface Served {
  file: string
  status: number
}

/**
 * Which file answers this path — or nothing, when the path names an asset that is not there.
 *
 * The containment check is on the resolved path rather than on the request: `..` is only one way to
 * leave the root, and a symlink or an encoded separator is another.
 */
export async function fileFor(root: string, pathname: string): Promise<Served | undefined> {
  const shell = join(root, 'index.html')
  let decoded: string
  try {
    decoded = decodeURIComponent(pathname)
  } catch {
    return undefined
  }
  if (decoded.includes('\0')) return undefined
  // Resolved, then *realpathed*: `..` is one way to leave the root and a symlink inside the bundle is
  // another, and only the second survives `new URL()` normalising the request.
  const base = await realpath(root).catch(() => root)
  const found = await realpath(resolve(base, `.${decoded}`)).catch(() => undefined)
  if (found !== undefined && (found === base || found.startsWith(base + sep))) {
    const entry = await stat(found)
    if (entry.isFile()) return { file: found, status: 200 }
    if (entry.isDirectory()) {
      const index = join(found, 'index.html')
      if ((await stat(index).catch(() => undefined))?.isFile() === true) return { file: index, status: 200 }
    }
  } else if (found !== undefined) {
    // It exists and it is not in the bundle. Not a route: a route never resolves to a real path.
    return undefined
  }
  if (extname(decoded) !== '') return undefined
  return { file: shell, status: 200 }
}

async function handle(root: string, request: IncomingMessage, response: ServerResponse): Promise<void> {
  const method = request.method ?? 'GET'
  if (method !== 'GET' && method !== 'HEAD') {
    response.statusCode = 405
    response.setHeader('allow', 'GET, HEAD')
    response.end('method not allowed')
    return
  }
  const url = new URL(request.url ?? '/', 'http://127.0.0.1')
  const served = await fileFor(root, url.pathname)
  if (!served) {
    response.statusCode = 404
    response.setHeader('content-type', 'text/plain; charset=utf-8')
    response.end('not found')
    return
  }
  const body = await readFile(served.file)
  response.statusCode = served.status
  response.setHeader('content-type', TYPES[extname(served.file)] ?? 'application/octet-stream')
  response.setHeader('cache-control', cacheControl(url.pathname))
  response.end(method === 'HEAD' ? undefined : body)
}

export function createStaticServer(root: string): Server {
  return createServer((request, response) => {
    handle(root, request, response).catch((error: unknown) => {
      response.statusCode = 500
      response.setHeader('content-type', 'text/plain; charset=utf-8')
      response.end(error instanceof Error ? error.message : String(error))
    })
  })
}

/** The bundle `vite build` wrote, next to this file's package rather than next to the shell's cwd. */
export const buildDir = (): string => resolve(dirname(fileURLToPath(import.meta.url)), '..', 'build')

export function main(): void {
  const root = buildDir()
  const port = Number(process.env.RADIAL_UI_PORT ?? '4321')
  const host = process.env.RADIAL_UI_HOST ?? '127.0.0.1'
  createStaticServer(root).listen(port, host, () => {
    console.log(`Radial UI on http://${host}:${port} — serving ${root}`)
  })
}

const entry = process.argv[1]
if (entry && import.meta.url === pathToFileURL(realpathSync(entry)).href) main()