// error/types.ts
import type { DomainError } from "./domain-error";
import type { LogLevel, UxAction } from "./registry";
 
export type ErrorReporter = {
  report: (error: DomainError, level: LogLevel) => void;
};
 
export type ErrorPresenter = {
  present: (error: DomainError, action: UxAction) => void;
};

// error/reporter.server.ts
import * as Sentry from "@sentry/nextjs";
import type { ErrorReporter } from "./types";
 
export const serverReporter: ErrorReporter = {
  report: (error, level) => {
    if (level === "error") {
      console.error("[handleError:server]", error);
      Sentry.captureException(error, {
        extra: { code: error.code, details: error.details },
      });
    } else if (level === "warning") {
      console.warn("[handleError:server]", error);
    } else if (level === "info") {
      console.info("[handleError:server]", error);
    }
  },
};
 
// error/presenter.server.ts
import type { ErrorPresenter } from "./types";
 
export const serverPresenter: ErrorPresenter = {
  present: () => {}, // 서버에서는 UX 부수효과 없음
};

// error/reporter.client.ts
import * as Sentry from "@sentry/nextjs";
import type { ErrorReporter } from "./types";
 
export const clientReporter: ErrorReporter = {
  report: (error, level) => {
    if (level === "error") {
      console.error("[handleError:client]", error);
      Sentry.captureException(error, {
        extra: { code: error.code, details: error.details },
      });
    } else if (level === "warning") {
      console.warn("[handleError:client]", error);
    } else if (level === "info") {
      console.info("[handleError:client]", error);
    }
  },
};
 
// error/presenter.client.ts
import { toast } from "sonner";
import type { ErrorPresenter } from "./types";
 
export const clientPresenter: ErrorPresenter = {
  present: (error, action) => {
    if (action === "toast") toast.error(error.message);
    else if (action === "alert") alert(error.message);
  },
};

// error/handler.ts
import { ERROR_REGISTRY, type UxAction, type LogLevel } from "./registry";
import {
  isDomainError,
  isSerializedError,
  type DomainError,
} from "./domain-error";
import { makeError } from "./make-error";
import { getRuntime } from "./runtime";
import type { ErrorReporter, ErrorPresenter } from "./types";
 
type HandleErrorOptions = {
  ux?: UxAction;
  log?: LogLevel;
  fallbackMessage?: string;
};
 
type HandleErrorDeps = {
  reporter: ErrorReporter;
  presenter: ErrorPresenter;
};
 
/**
 * handleError 인스턴스를 생성하는 팩토리 함수.
 * 서버에서는 이 팩토리로 명시적 인스턴스를 생성하여
 * 모듈 스코프의 가변 상태를 피합니다.
 */
export const createHandleError = (deps: HandleErrorDeps) => {
  /**
   * 모든 에러의 단일 처리기.
   *
   * 1. Normalize — 입력을 DomainError로 정규화
   * 2. Report — 주입된 reporter로 로깅
   * 3. Present — 주입된 presenter로 UX 피드백
   *
   * @returns 정규화된 DomainError. 호출부에서 추가 UI 처리에 활용.
   * @sideeffect 정책에 따라 로깅, Toast 등의 부수효과가 발생합니다.
   */
  return (error: unknown, options: HandleErrorOptions = {}): DomainError => {
    // ── 1. Normalize ──
    const domainError = isDomainError(error)
      ? error
      : isSerializedError(error)
        ? makeError({
            code: error.code,
            details: error.details,
            message: error.message,
          })
        : makeError({
            code:
              getRuntime() === "server"
                ? "UNKNOWN_SERVER_ERROR"
                : "UNKNOWN_CLIENT_ERROR",
            details: null,
            message:
              options.fallbackMessage ?? "예상치 못한 오류가 발생했습니다.",
            cause: error,
          });
 
    const meta = ERROR_REGISTRY[domainError.code];
    const log = options.log ?? meta.log;
    const ux = options.ux ?? meta.ux;
 
    // ── 2. Report ──
    if (log !== "none") {
      deps.reporter.report(domainError, log);
    }
 
    // ── 3. Present ──
    if (ux !== "none") {
      deps.presenter.present(domainError, ux);
    }
 
    return domainError;
  };
};
 
// ── 클라이언트 싱글턴 (init 패턴) ──
// 서버에서는 createHandleError로 직접 생성하세요.
let _handleError: ReturnType<typeof createHandleError> = createHandleError({
  // 초기화 전 폴백: console만 사용
  reporter: {
    report: (error, level) => {
      if (level === "error") console.error("[handleError:fallback]", error);
      else if (level === "warning")
        console.warn("[handleError:fallback]", error);
    },
  },
  presenter: { present: () => {} },
});
 
/** 클라이언트 엔트리에서 reporter/presenter를 주입합니다. */
export const initHandleError = (deps: HandleErrorDeps) => {
  _handleError = createHandleError(deps);
};
 
/** 클라이언트에서 사용하는 handleError 싱글턴. */
export const handleError: ReturnType<typeof createHandleError> = (
  error,
  options,
) => _handleError(error, options);

// error/handler.server.ts
// 서버 전용 handleError 인스턴스.
// safeServerAction, DAL 등 서버 코드에서 이 인스턴스를 import합니다.
import { createHandleError } from "./handler";
import { serverReporter } from "./reporter.server";
import { serverPresenter } from "./presenter.server";
 
export const handleServerError = createHandleError({
  reporter: serverReporter,
  presenter: serverPresenter,
});

// components/ErrorHandlerInit.tsx
"use client";
import { useEffect } from "react";
import { initHandleError } from "@/error/handler";
import { clientReporter } from "@/error/reporter.client";
import { clientPresenter } from "@/error/presenter.client";
 
export const ErrorHandlerInit = () => {
  useEffect(() => {
    initHandleError({
      reporter: clientReporter,
      presenter: clientPresenter,
    });
  }, []);
  return null;
};
 
// app/layout.tsx에서 <ErrorHandlerInit /> 배치

// VALIDATION (ux: "none", log: "none") → 부수효과 제로
const error = handleError(result.error);
if (error.code === "VALIDATION") {
  setFieldErrors(error.details.fieldErrors);
}
 
// NETWORK_ERROR (ux: "toast", log: "warning") → Toast 자동
handleError(result.error);
 
// AUTH_REQUIRED (ux: "redirect", log: "info") → 반환값으로 redirect
const error = handleError(result.error);
if (error.code === "AUTH_REQUIRED") {
  redirect("/login");
}