import { z } from "zod";
import {
  isDiagnosticToken,
  OBSERVED_COMPARISON_LIMITS,
  OBSERVED_COMPARISON_CONTRASTS,
  validateObservedComparisonRequest,
  runObservedComparison,
  assessObservedComparisonEligibility,
  replayObservedComparison,
  type ObservedComparisonRequest,
} from "@actuarial-ts/core";
import { analysisSnapshotSchema } from "./reviewContracts.js";
import { parseReviewBoundary } from "./reviewBoundary.js";

const token = z.string().refine(isDiagnosticToken, "Expected an explicit nonblank identifier or rationale");
export const observedComparisonLimitsSchema = z
  .object({
    maximumInputCharacters: z.number().int().positive().max(OBSERVED_COMPARISON_LIMITS.maximumInputCharacters),
    maximumSnapshots: z.number().int().positive().max(OBSERVED_COMPARISON_LIMITS.maximumSnapshots),
  })
  .strict();
export const observedComparisonRequestSchema = z
  .object({
    id: token,
    version: token,
    rationale: token,
    axis: z
      .object({
        kind: z.enum(["origin", "age", "calendar", "valuation", "segment", "knowledge"]),
        dimension: token.nullable(),
      })
      .strict(),
    reference: analysisSnapshotSchema,
    compared: analysisSnapshotSchema,
    snapshots: z.array(analysisSnapshotSchema).max(OBSERVED_COMPARISON_LIMITS.maximumSnapshots),
    declarations: z
      .object({
        population: z
          .object({ relationship: z.enum(["same", "disjoint", "overlapping"]), rationale: token })
          .strict()
          .nullable(),
        unknownBasis: z
          .object({ relationship: z.literal("same"), rationale: token })
          .strict()
          .nullable(),
        contrasts: z
          .array(
            z
              .object({
                dimension: z.enum(OBSERVED_COMPARISON_CONTRASTS),
                rationale: token,
                bridge: analysisSnapshotSchema,
              })
              .strict(),
          )
          .max(OBSERVED_COMPARISON_CONTRASTS.length),
      })
      .strict(),
    limits: observedComparisonLimitsSchema,
  })
  .strict();

export function parseObservedComparisonRequest(input: unknown): ObservedComparisonRequest {
  return validateObservedComparisonRequest(parseReviewBoundary(observedComparisonRequestSchema, input));
}
export function runObservedComparisonFromInput(input: unknown) {
  return runObservedComparison(parseObservedComparisonRequest(input));
}
export function assessObservedComparisonEligibilityFromInput(input: unknown) {
  return assessObservedComparisonEligibility(parseObservedComparisonRequest(input));
}
export function replayObservedComparisonFromInput(input: unknown) {
  const raw = parseReviewBoundary(
    z.object({ result: z.unknown(), limits: observedComparisonLimitsSchema }).strict(),
    input,
  );
  return replayObservedComparison(raw as Parameters<typeof replayObservedComparison>[0]);
}