console.log("refresh started");

telemetry.emit({
  type: "auth.refresh.started",
  traceId,
  spanId,
  sessionGeneration,
  tabId,
  workerId,
  lockName: "auth-refresh:tenant-42",
  attempt: 1,
  timestamp: Date.now(),
});

type TelemetryEvent = {
  type: string;
  level: "debug" | "info" | "warn" | "error";
  traceId?: string;
  spanId?: string;
  parentSpanId?: string;
  timestamp: number;
  monotonicTime?: number;
  context: RuntimeContext;
  attributes?: Record<string, string | number | boolean | null>;
};

type RuntimeKind =
  | "window"
  | "dedicated-worker"
  | "shared-worker"
  | "service-worker";

type RuntimeContext = {
  kind: RuntimeKind;
  appVersion: string;
  buildHash: string;
  tabId?: string;
  connectionId?: string;
  workerId?: string;
  serviceWorkerVersion?: string;
  sessionGeneration?: number;
  tenantId?: string;
  visibilityState?: DocumentVisibilityState;
  urlPath?: string;
};

type MessageEnvelope<TPayload> = {
  protocol: "browser-orchestrator";
  version: 1;

  kind: string;
  id: string;
  correlationId?: string;

  traceId: string;
  spanId: string;
  parentSpanId?: string;

  source: RuntimeContext;
  target?: {
    kind?: RuntimeKind;
    tabId?: string;
    workerId?: string;
    connectionId?: string;
  };

  createdAt: number;
  deadlineAt?: number;
  sessionGeneration?: number;
  fencingToken?: number;

  payload: TPayload;
};

worker_task_failed_due_to_timeout_for_csv_import

worker.task.failed
attributes.reason = "timeout"
attributes.taskType = "csv.import"

performance.mark("csv-import:start", {
  detail: { traceId, taskId },
});

// work

performance.mark("csv-import:end", {
  detail: { traceId, taskId },
});

performance.measure("csv-import", {
  start: "csv-import:start",
  end: "csv-import:end",
  detail: { traceId, taskId },
});

function observePerformanceEntries() {
  if (!("PerformanceObserver" in globalThis)) return;

  const supported = PerformanceObserver.supportedEntryTypes ?? [];

  if (supported.includes("measure")) {
    const observer = new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) {
        telemetry.emit({
          type: "perf.measure",
          level: "debug",
          timestamp: Date.now(),
          monotonicTime: performance.now(),
          context: runtimeContext,
          attributes: {
            name: entry.name,
            durationMs: entry.duration,
          },
        });
      }
    });

    observer.observe({ entryTypes: ["measure"] });
  }
}

function observeLongTasks() {
  if (!("PerformanceObserver" in globalThis)) return;
  if (!PerformanceObserver.supportedEntryTypes?.includes("longtask")) return;

  const observer = new PerformanceObserver((list) => {
    for (const entry of list.getEntries()) {
      telemetry.emit({
        type: "main.long_task.detected",
        level: "warn",
        timestamp: Date.now(),
        monotonicTime: performance.now(),
        context: runtimeContext,
        attributes: {
          name: entry.name,
          durationMs: entry.duration,
          startTimeMs: entry.startTime,
        },
      });
    }
  });

  observer.observe({ entryTypes: ["longtask"] });
}

type QueueSnapshot = {
  queueName: string;
  depth: number;
  queuedBytes: number;
  inFlight: number;
  oldestAgeMs: number;
};

function emitQueueSnapshot(snapshot: QueueSnapshot) {
  telemetry.emit({
    type: "worker.queue.snapshot",
    level: snapshot.depth > 100 ? "warn" : "debug",
    timestamp: Date.now(),
    monotonicTime: performance.now(),
    context: runtimeContext,
    attributes: snapshot,
  });
}

class RollingCounter {
  private count = 0;
  private lastFlush = performance.now();

  inc() {
    this.count++;
  }

  flushIfDue(name: string, everyMs: number) {
    const now = performance.now();
    if (now - this.lastFlush < everyMs) return;

    telemetry.emit({
      type: "counter.flush",
      level: "debug",
      timestamp: Date.now(),
      monotonicTime: now,
      context: runtimeContext,
      attributes: { name, count: this.count, windowMs: now - this.lastFlush },
    });

    this.count = 0;
    this.lastFlush = now;
  }
}

function safePostMessage<T>(
  target: Worker | MessagePort | BroadcastChannel,
  envelope: MessageEnvelope<T>,
  transfer?: Transferable[],
) {
  const start = performance.now();

  try {
    target.postMessage(envelope, transfer ?? []);

    telemetry.emit({
      type: "message.sent",
      level: "debug",
      traceId: envelope.traceId,
      spanId: envelope.spanId,
      timestamp: Date.now(),
      monotonicTime: performance.now(),
      context: runtimeContext,
      attributes: {
        kind: envelope.kind,
        durationMs: performance.now() - start,
        transferCount: transfer?.length ?? 0,
      },
    });
  } catch (error) {
    telemetry.emit({
      type: "message.send_failed",
      level: "error",
      traceId: envelope.traceId,
      spanId: envelope.spanId,
      timestamp: Date.now(),
      monotonicTime: performance.now(),
      context: runtimeContext,
      attributes: {
        kind: envelope.kind,
        errorName: error instanceof Error ? error.name : "UnknownError",
      },
    });

    throw error;
  }
}

window.addEventListener("error", (event) => {
  telemetry.emit({
    type: "runtime.error",
    level: "error",
    timestamp: Date.now(),
    monotonicTime: performance.now(),
    context: runtimeContext,
    attributes: {
      message: event.message,
      filename: event.filename,
      lineno: event.lineno,
      colno: event.colno,
      errorName: event.error?.name ?? null,
    },
  });
});

window.addEventListener("unhandledrejection", (event) => {
  telemetry.emit({
    type: "runtime.unhandled_rejection",
    level: "error",
    timestamp: Date.now(),
    monotonicTime: performance.now(),
    context: runtimeContext,
    attributes: {
      reason: normalizeErrorReason(event.reason),
    },
  });
});

worker.addEventListener("error", (event) => {
  telemetry.emit({
    type: "worker.error",
    level: "error",
    timestamp: Date.now(),
    monotonicTime: performance.now(),
    context: runtimeContext,
    attributes: {
      workerId,
      message: event.message,
      filename: event.filename,
      lineno: event.lineno,
      colno: event.colno,
    },
  });
});

worker.addEventListener("messageerror", () => {
  telemetry.emit({
    type: "worker.messageerror",
    level: "error",
    timestamp: Date.now(),
    monotonicTime: performance.now(),
    context: runtimeContext,
    attributes: { workerId },
  });
});

self.addEventListener("error", (event) => {
  // Send compact error event to owner if possible.
});

self.addEventListener("unhandledrejection", (event) => {
  // Normalize and report.
});

self.addEventListener("fetch", (event) => {
  const start = performance.now();

  event.respondWith(handleFetch(event.request));

  event.waitUntil(
    flushFetchMetricEventually({
      urlKind: classifyUrl(event.request.url),
      durationMs: performance.now() - start,
    }),
  );
});

function instrumentTx<T>(
  name: string,
  run: () => Promise<T>,
): Promise<T> {
  const start = performance.now();

  telemetry.emit({
    type: "idb.tx.started",
    level: "debug",
    timestamp: Date.now(),
    monotonicTime: start,
    context: runtimeContext,
    attributes: { name },
  });

  return run()
    .then((result) => {
      telemetry.emit({
        type: "idb.tx.completed",
        level: "debug",
        timestamp: Date.now(),
        monotonicTime: performance.now(),
        context: runtimeContext,
        attributes: { name, durationMs: performance.now() - start },
      });
      return result;
    })
    .catch((error) => {
      telemetry.emit({
        type: "idb.tx.failed",
        level: "error",
        timestamp: Date.now(),
        monotonicTime: performance.now(),
        context: runtimeContext,
        attributes: {
          name,
          durationMs: performance.now() - start,
          errorName: error instanceof Error ? error.name : "UnknownError",
        },
      });
      throw error;
    });
}

async function withObservedLock<T>(
  name: string,
  options: LockOptions,
  run: (lock: Lock) => Promise<T>,
): Promise<T> {
  const requestedAt = performance.now();

  telemetry.emit({
    type: "lock.requested",
    level: "debug",
    timestamp: Date.now(),
    monotonicTime: requestedAt,
    context: runtimeContext,
    attributes: { name, mode: options.mode ?? "exclusive" },
  });

  return navigator.locks.request(name, options, async (lock) => {
    const grantedAt = performance.now();

    telemetry.emit({
      type: "lock.granted",
      level: "debug",
      timestamp: Date.now(),
      monotonicTime: grantedAt,
      context: runtimeContext,
      attributes: {
        name,
        waitMs: grantedAt - requestedAt,
        mode: lock.mode,
      },
    });

    try {
      return await run(lock);
    } finally {
      telemetry.emit({
        type: "lock.released",
        level: "debug",
        timestamp: Date.now(),
        monotonicTime: performance.now(),
        context: runtimeContext,
        attributes: {
          name,
          heldMs: performance.now() - grantedAt,
        },
      });
    }
  });
}

type TelemetryBatch = {
  batchId: string;
  createdAt: number;
  events: TelemetryEvent[];
};

function redactAttributes(
  attributes: Record<string, unknown>,
): Record<string, unknown> {
  const blocked = new Set([
    "accessToken",
    "refreshToken",
    "authorization",
    "cookie",
    "password",
    "secret",
  ]);

  const result: Record<string, unknown> = {};

  for (const [key, value] of Object.entries(attributes)) {
    if (blocked.has(key.toLowerCase())) {
      result[key] = "[REDACTED]";
      continue;
    }

    result[key] = value;
  }

  return result;
}

class DebugRing<T> {
  private items: T[] = [];
  private cursor = 0;

  constructor(private readonly capacity: number) {}

  push(item: T) {
    if (this.items.length < this.capacity) {
      this.items.push(item);
      return;
    }

    this.items[this.cursor] = item;
    this.cursor = (this.cursor + 1) % this.capacity;
  }

  snapshot(): T[] {
    return [
      ...this.items.slice(this.cursor),
      ...this.items.slice(0, this.cursor),
    ];
  }
}

if (import.meta.env.DEV) {
  Object.assign(globalThis, {
    __orchestratorDebug: {
      dump: () => debugRing.snapshot(),
    },
  });
}

type OrchestratorSnapshot = {
  timestamp: number;
  context: RuntimeContext;
  tabs?: {
    totalKnown: number;
    visibleKnown: number;
    leaderTabId?: string;
    leaderFencingToken?: number;
  };
  worker?: {
    workerId: string;
    state: string;
    queueDepth: number;
    inFlight: number;
    restartCount: number;
  };
  serviceWorker?: {
    controllerState?: string;
    swVersion?: string;
  };
  storage?: {
    idbOpen: boolean;
    outboxPending: number;
    walPending: number;
  };
};

{
  "leaderTabId": "tab_abc",
  "leaderFencingToken": 104,
  "outboxPending": 19,
  "workerQueueDepth": 300
}

{
  "lastImportedRows": ["full user data here"]
}

type TelemetryLevel = "debug" | "info" | "warn" | "error";

type TelemetryEvent = {
  type: string;
  level: TelemetryLevel;
  timestamp: number;
  monotonicTime: number;
  context: RuntimeContext;
  traceId?: string;
  spanId?: string;
  parentSpanId?: string;
  attributes?: Record<string, unknown>;
};

class TelemetryClient {
  private buffer: TelemetryEvent[] = [];
  private readonly maxBuffer = 500;

  constructor(
    private readonly context: RuntimeContext,
    private readonly sink: (events: TelemetryEvent[]) => Promise<void>,
  ) {}

  emit(event: Omit<TelemetryEvent, "context" | "timestamp" | "monotonicTime">) {
    const normalized: TelemetryEvent = {
      ...event,
      timestamp: Date.now(),
      monotonicTime: performance.now(),
      context: this.context,
      attributes: redactAttributes(event.attributes ?? {}),
    };

    this.buffer.push(normalized);

    if (this.buffer.length > this.maxBuffer) {
      this.dropDebugEvents();
    }
  }

  async flush() {
    if (this.buffer.length === 0) return;

    const batch = this.buffer.splice(0, this.buffer.length);

    try {
      await this.sink(batch);
    } catch {
      // Keep telemetry best-effort. Do not crash application.
      const retryable = batch.filter((event) => event.level !== "debug");
      this.buffer.unshift(...retryable.slice(-this.maxBuffer));
    }
  }

  private dropDebugEvents() {
    this.buffer = this.buffer
      .filter((event) => event.level !== "debug")
      .slice(-this.maxBuffer);
  }
}