import { z } from "zod";
import { AnalysisReviewError, DiagnosticValidationError, canonicalJson, compileDiagnosticDefinition, isDiagnosticPlainRecord, isDiagnosticToken, sameMaturity, sameMaturityCompact, commonMaturity, commonMaturityCompact, type CompiledDiagnosticDefinition, type DiagnosticDefinition, type DiagnosticDeepReadonly, type DiagnosticEmergencePoint, type CommonMaturityResult } from "@actuarial-ts/core";
import { parseReviewBoundary } from "./reviewBoundary.js";
import { diagnosticExecutionRequestSchema, DIAGNOSTIC_EXECUTION_LIMITS, diagnosticExecutionLimit, ownDiagnosticGatewayRequest, type DiagnosticExecutionRequest } from "./diagnosticExecutionContracts.js";
import { runMetricDiagnosticsFromInput, runMetricDiagnosticsCompactFromInput, type ValidatedMetricDiagnosticsOutcome, type CompactMetricDiagnosticsOutcome } from "./diagnosticInput.js";

export interface DiagnosticDefinitionRequest { readonly definition: DiagnosticDefinition; readonly limits: { readonly maximumInputCharacters: number } }
export const diagnosticDefinitionRequestSchema: z.ZodType<DiagnosticDefinitionRequest> = z.object({
  definition: z.custom<DiagnosticDefinition>(isDiagnosticPlainRecord),
  limits: z.object({ maximumInputCharacters: z.number().int().positive().max(DIAGNOSTIC_EXECUTION_LIMITS.maximumInputCharacters) }).strict(),
}).strict();
export function parseDiagnosticDefinitionRequest(input: unknown): DiagnosticDefinitionRequest {
  const request = parseReviewBoundary(diagnosticDefinitionRequestSchema, input);
  if (canonicalJson(request).length > request.limits.maximumInputCharacters) diagnosticExecutionLimit("$.limits.maximumInputCharacters", "Diagnostic definition exceeds its declared input budget");
  return ownDiagnosticGatewayRequest(request);
}
/** Compiles the existing native definition and returns its original owned result. */
export function compileDiagnosticDefinitionFromInput(input: unknown): CompiledDiagnosticDefinition {
  const request = parseDiagnosticDefinitionRequest(input);
  try { return compileDiagnosticDefinition(request.definition); }
  catch (error) {
    if (!(error instanceof DiagnosticValidationError)) throw error;
    throw new AnalysisReviewError(error.issues.map((issue) => ({ code: issue.code, path: `$.definition${issue.path.startsWith("$") ? issue.path.slice(1) : `.${issue.path}`}`, message: issue.message, remedies: ["Resolve the native definition's units, references, expressions and period-axis requirements"] })));
  }
}

export interface DiagnosticMaturityRequest {
  readonly execution: DiagnosticExecutionRequest;
  readonly storage: "eager" | "compact";
  readonly developmentAge: number;
  readonly outputGroups?: readonly string[];
}
export interface DiagnosticCommonMaturityRequest {
  readonly execution: DiagnosticExecutionRequest;
  readonly storage: "eager" | "compact";
  readonly outputGroups: readonly string[];
}
const groups = z.array(z.string().refine(isDiagnosticToken));
export const diagnosticMaturityRequestSchema: z.ZodType<DiagnosticMaturityRequest> = z.object({ execution: diagnosticExecutionRequestSchema, storage: z.enum(["eager", "compact"]), developmentAge: z.number().int().nonnegative().safe(), outputGroups: groups.optional() }).strict();
export const diagnosticCommonMaturityRequestSchema: z.ZodType<DiagnosticCommonMaturityRequest> = z.object({ execution: diagnosticExecutionRequestSchema, storage: z.enum(["eager", "compact"]), outputGroups: groups }).strict();
function viewRequest<T extends DiagnosticMaturityRequest | DiagnosticCommonMaturityRequest>(schema: z.ZodType<T>, input: unknown): T {
  const request = parseReviewBoundary(schema, input);
  if (canonicalJson(request).length > request.execution.limits.maximumInputCharacters) diagnosticExecutionLimit("$.execution.limits.maximumInputCharacters", "The complete diagnostic view request exceeds its declared input budget");
  return ownDiagnosticGatewayRequest(request);
}
export function parseDiagnosticMaturityRequest(input: unknown): DiagnosticMaturityRequest { return viewRequest(diagnosticMaturityRequestSchema, input); }
export function parseDiagnosticCommonMaturityRequest(input: unknown): DiagnosticCommonMaturityRequest { return viewRequest(diagnosticCommonMaturityRequestSchema, input); }
type DiagnosticOwnedRun = { readonly storage: "eager"; readonly run: ValidatedMetricDiagnosticsOutcome } | { readonly storage: "compact"; readonly run: CompactMetricDiagnosticsOutcome };
export type DiagnosticMaturityView = DiagnosticOwnedRun & { readonly request: DiagnosticMaturityRequest; readonly points: readonly DiagnosticDeepReadonly<DiagnosticEmergencePoint>[] | null };
export type DiagnosticCommonMaturityView = DiagnosticOwnedRun & { readonly request: DiagnosticCommonMaturityRequest; readonly view: DiagnosticDeepReadonly<CommonMaturityResult> | null };

function execute<T>(operation: () => T): T {
  try { return operation(); }
  catch (error) {
    if (!(error instanceof AnalysisReviewError)) throw error;
    throw new AnalysisReviewError(error.findings.map((finding) => ({ ...finding, path: `$.execution${finding.path.slice(1)}` })));
  }
}
function select<T>(operation: () => T): T {
  try { return operation(); }
  catch (error) {
    if (!(error instanceof DiagnosticValidationError)) throw error;
    throw new AnalysisReviewError(error.issues.map((issue) => ({ code: issue.code, path: issue.path, message: issue.message, remedies: ["Select actual output groups and an explicit native-axis development age"] })));
  }
}
/** Recalculates the declared diagnostic run before selecting its actual maturity view. */
export function sameMaturityDiagnosticsFromInput(input: unknown): DiagnosticMaturityView {
  const request = parseDiagnosticMaturityRequest(input);
  if (request.storage === "compact") {
    const run = execute(() => runMetricDiagnosticsCompactFromInput(request.execution));
    return Object.freeze({ request, storage: "compact", run, points: run.status === "completed" ? Object.freeze(select(() => sameMaturityCompact(run.result, request.developmentAge, request.outputGroups))) : null });
  }
  const run = execute(() => runMetricDiagnosticsFromInput(request.execution));
  return Object.freeze({ request, storage: "eager", run, points: run.status === "completed" ? Object.freeze(select(() => sameMaturity(run.result, request.developmentAge, request.outputGroups))) : null });
}
/** A blocked run has no authorized selected view, even if its metric-stage evidence exists. */
export function commonMaturityDiagnosticsFromInput(input: unknown): DiagnosticCommonMaturityView {
  const request = parseDiagnosticCommonMaturityRequest(input);
  if (request.storage === "compact") {
    const run = execute(() => runMetricDiagnosticsCompactFromInput(request.execution));
    return Object.freeze({ request, storage: "compact", run, view: run.status === "completed" ? select(() => commonMaturityCompact(run.result, request.outputGroups)) : null });
  }
  const run = execute(() => runMetricDiagnosticsFromInput(request.execution));
  return Object.freeze({ request, storage: "eager", run, view: run.status === "completed" ? select(() => commonMaturity(run.result, request.outputGroups)) : null });
}