import {
  ErrorBoundary,
  AppError,
  AppValidationError,
  NotFoundError,
  UnauthorizedError,
  ForbiddenError,
  ConflictError,
  RateLimitError,
  TimeoutError,
  getGlobalErrorBoundary,
  resetGlobalErrorBoundary,
} from "bytekit/error-boundary";
// or | o también:
import { ErrorBoundary, AppError /* ... */ } from "bytekit";

const boundary = new ErrorBoundary(config?: ErrorBoundaryConfig);

class AppError extends Error {
  readonly code: string;
  readonly statusCode: number;
  readonly context?: ErrorContext;
  readonly originalError?: Error;

  constructor(code: string, message: string, statusCode?: number, context?: ErrorContext, originalError?: Error);
}

// RateLimitError includes retryAfter in metadata
// RateLimitError incluye retryAfter en metadata
new RateLimitError("Too many requests", 60, { component: "API" });
// → metadata.retryAfter = 60

interface ErrorContext {
  component?: string;    // Component name / Nombre del componente
  context?: string;      // Free-form context / Contexto libre
  userId?: string;       // User identifier / Identificador de usuario
  sessionId?: string;    // Session identifier / Identificador de sesión
  metadata?: Record<string, unknown>; // Extra data / Datos extra
  originalError?: Error; // Original error / Error original
}

import { getGlobalErrorBoundary, resetGlobalErrorBoundary } from "bytekit/error-boundary";

const boundary = getGlobalErrorBoundary({ maxRetries: 5 });
// Subsequent calls return the same instance
// Las llamadas siguientes devuelven la misma instancia

// In tests / En tests:
resetGlobalErrorBoundary();

import { ErrorBoundary, NotFoundError } from "bytekit/error-boundary";

const boundary = new ErrorBoundary({
  maxRetries: 3,
  retryDelay: 1000,
  onError: (error, ctx) => console.error(`[${ctx.component}]`, error.message),
});

// Execute with auto-retry / Ejecutar con reintento automático
const data = await boundary.execute(
  () => fetch("/api/users").then((r) => r.json()),
  { component: "UserService" }
);

// Register a handler that sends errors to a tracking service
// Registrar un manejador que envía errores a un servicio de tracking
const telemetryHandler = async (error, context) => {
  await analytics.trackError({
    code: error instanceof AppError ? error.code : "UNKNOWN",
    message: error.message,
    component: context.component,
  });
};

boundary.addHandler(telemetryHandler);

// Later remove it / Luego removerlo
boundary.removeHandler(telemetryHandler);

// Wrap an async function — returns a new function with built-in error handling
// Envuelve una función async — retorna una nueva función con manejo de errores incluido
const safeFetch = boundary.wrap(
  async (url: string) => {
    const res = await fetch(url);
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
  },
  { component: "HttpClient" }
);

const result = await safeFetch("/api/data");

// Generate a full error report after some operations
// Generar un reporte completo de errores después de algunas operaciones
const report = boundary.createErrorReport();
console.log(report);
// {
//   timestamp: "2026-03-27T12:00:00.000Z",
//   errors: [
//     { code: "NOT_FOUND", message: "User not found", statusCode: 404, timestamp: 1711533600000, ... },
//     ...
//   ]
// }

import { RateLimitError, TimeoutError, AppValidationError } from "bytekit/error-boundary";

throw new RateLimitError("Slow down", 60); // retryAfter = 60s
throw new TimeoutError("Gateway timed out");
throw new AppValidationError("Email is required");