/**
 * Param / result validation helpers — Zod `safeParse` wrappers returning a
 * tagged result. Callers convert a `false` outcome into a typed error:
 * `SdkValidationError` (input, → 422) or `SdkResultValidationError`
 * (output, → 500).
 */

import type { z } from 'zod'

export type ValidationResult =
  | { ok: true; data: Record<string, unknown> }
  | { ok: false; issues: unknown[] }

export function validateParams(inputSchema: z.ZodType, params: unknown): ValidationResult {
  const result = inputSchema.safeParse(params)
  if (result.success) {
    return { ok: true, data: result.data as Record<string, unknown> }
  }
  return { ok: false, issues: result.error.issues }
}

/**
 * Result of validating a handler's output against its `outputSchema`. Unlike
 * params, an output may be any shape (object, primitive, array), so `data` is
 * `unknown` rather than `Record<string, unknown>`.
 */
export type ResultValidationResult = { ok: true; data: unknown } | { ok: false; issues: unknown[] }

/**
 * Validate a handler's return value against its `outputSchema`. Mirrors the
 * kernel's `validateOutput` (`runtime/.../validation/output.ts`) so deployed
 * domains enforce the same output contract as in-process methods. Returns the
 * parsed `data` (applies Zod `default`/`transform`/coercions) on success.
 */
export function validateResult(outputSchema: z.ZodType, result: unknown): ResultValidationResult {
  const parsed = outputSchema.safeParse(result)
  if (parsed.success) {
    return { ok: true, data: parsed.data }
  }
  return { ok: false, issues: parsed.error.issues }
}