// Request logging middleware for the frontend server
import {
  red,
  green,
  yellow,
  blue,
  magenta,
  cyan,
  gray,
  bold,
  dim,
} from "@std/fmt/colors";

function getStatusColor(status: number): (text: string) => string {
  if (status >= 500) return red;
  if (status >= 400) return yellow;
  if (status >= 300) return cyan;
  if (status >= 200) return green;
  return gray;
}

function getMethodColor(method: string): (text: string) => string {
  switch (method) {
    case "GET":
      return blue;
    case "POST":
      return green;
    case "PUT":
      return yellow;
    case "DELETE":
      return red;
    case "PATCH":
      return magenta;
    default:
      return gray;
  }
}

export function logRequest(
  req: Request,
  start: number,
  response: Response
): void {
  const duration = Date.now() - start;
  const url = new URL(req.url);
  const method = req.method;
  const status = response.status;
  const userAgent = req.headers.get("user-agent") || "-";
  const referer = req.headers.get("referer") || "-";

  const methodColored = getMethodColor(method)(method);
  const statusColored = getStatusColor(status)(status.toString());
  const pathColored = bold(`${url.pathname}${url.search}`);
  const durationColored =
    duration > 1000
      ? red(`${duration}ms`)
      : duration > 500
      ? yellow(`${duration}ms`)
      : dim(`${duration}ms`);

  console.log(
    `${methodColored} ${pathColored} ${statusColored} ${durationColored} ${gray(
      `- ${userAgent} - ${referer}`
    )}`
  );
}

export function createLoggingHandler(
  handler: (req: Request) => Response | Promise<Response>
) {
  return async function loggingHandler(req: Request): Promise<Response> {
    const start = Date.now();

    try {
      const response = await handler(req);
      logRequest(req, start, response);
      return response;
    } catch (error) {
      const duration = Date.now() - start;
      const url = new URL(req.url);
      const message = error instanceof Error ? error.message : String(error);
      const methodColored = getMethodColor(req.method)(req.method);
      const pathColored = bold(`${url.pathname}${url.search}`);
      const errorColored = red("ERROR");
      const durationColored = red(`${duration}ms`);

      console.error(
        `${methodColored} ${pathColored} ${errorColored} ${durationColored} ${red(
          `- ${message}`
        )}`
      );

      // Return a generic 500 error
      const response = new Response("Internal Server Error", { status: 500 });
      logRequest(req, start, response);
      return response;
    }
  };
}