import { AsyncLocalStorage } from "node:async_hooks";
import { createMeasure, type MeasureAction } from "measure-fn";
export const measures = {
  http: createMeasure("http"),
  build: createMeasure("build"),
  cliBuild: createMeasure("cli:build"),
  route: createMeasure("route"),
  imports: createMeasure("imports"),
  ssg: createMeasure("ssg"),
} as const;
export const httpMeasure = measures.http;
export const buildMeasure = measures.build;
export const cliBuildMeasure = measures.cliBuild;
export const routeMeasure = measures.route;
export const importMapMeasure = measures.imports;
export const ssgMeasure = measures.ssg;
export type ServerMeasureScope = ReturnType<typeof createMeasure>;
export type ServerMeasureAction<T = unknown> =
  | string
  | {
      label: string;
      result?: (value: T) => unknown;
      maxResultLength?: number;
      budget?: number;
      timeout?: number;
      [metadata: string]: unknown;
    };
const active = new AsyncLocalStorage<boolean>();
function toAction<T>(action: ServerMeasureAction<T>): MeasureAction<T> {
  if (typeof action === "string")
    return { start: () => action, end: () => undefined, maxResultLength: 200 };
  const {
    result,
    maxResultLength = 200,
    budget,
    timeout,
    ...metadata
  } = action;
  return {
    start: () => metadata,
    end: result ?? (() => undefined),
    maxResultLength,
    budget,
    timeout,
  };
}
function toSyncAction<T>(action: ServerMeasureAction<T>) {
  if (typeof action === "string")
    return {
      start: () => action,
      end: (_box: { value: T }) => undefined,
      maxResultLength: 200,
    };
  const {
    result,
    maxResultLength = 200,
    budget,
    timeout: _timeout,
    ...metadata
  } = action;
  return {
    start: () => metadata,
    end: (box: { value: T }) => (result ? result(box.value) : undefined),
    maxResultLength,
    budget,
  };
}
export function measureRequired<T>(
  scope: ServerMeasureScope,
  action: ServerMeasureAction<T>,
  fn: () => T | Promise<T>,
): Promise<T> {
  return scope.measure(toAction(action), () => active.run(true, fn));
}
export function measureRequiredSync<T>(
  scope: ServerMeasureScope,
  action: ServerMeasureAction<T>,
  fn: () => T,
): T {
  const result = scope.measureSync(toSyncAction(action), () => ({
    value: active.run(true, fn),
  }));
  return result.value;
}
export async function measureNote(
  scope: ServerMeasureScope,
  action: ServerMeasureAction,
): Promise<void> {
  scope.measure.note(toAction(action));
}
export function hasActiveMeasurement(): boolean {
  return active.getStore() === true;
}