import { z } from "zod";

export const referenceResourceListQuerySchema = z
  .object({
    cursor: z.string().min(1).optional(),
    limit: z.coerce.number().int().min(1).max(100).default(20),
    tags: z
      .preprocess(
        (value) =>
          value === undefined
            ? undefined
            : Array.isArray(value)
              ? value
              : [value],
        z.array(z.string().trim().min(1)),
      )
      .optional(),
  })
  .strict();

export const referenceResourceParamsSchema = z
  .object({
    resourceId: z.string().trim().min(1).max(120),
  })
  .strict();

const referenceResourceDtoSchema = z
  .object({
    id: z.string().min(1),
    name: z.string().min(1),
    createdAt: z.string().datetime().optional(),
  })
  .strict();

const payloadSchemas = {
  ReferenceResourceListPayload: z.array(referenceResourceDtoSchema),
  ReferenceResourcePayload: referenceResourceDtoSchema,
} satisfies Record<string, z.ZodType>;

const requestSchemas = {
  ReferenceResourceListQuery: referenceResourceListQuerySchema,
  NoRequest: z.object({}).strict(),
  CreateReferenceResourceCommand: z
    .object({
      name: z.string().trim().min(1).max(120),
      note: z.string().trim().max(500).optional(),
    })
    .strict(),
} satisfies Record<string, z.ZodType>;

function project(result: z.ZodSafeParseResult<unknown>) {
  return result.success
    ? ({ success: true as const, data: structuredClone(result.data) })
    : ({
        success: false as const,
        issues: result.error.issues.map((issue) => ({
          path: issue.path.join("."),
          code: issue.code,
        })),
      });
}

export function validateReferencePayload(schemaId: string, value: unknown) {
  const schema = payloadSchemas[schemaId as keyof typeof payloadSchemas];
  return schema
    ? project(schema.safeParse(value))
    : { success: false as const, issues: [{ path: "", code: "SCHEMA_NOT_REGISTERED" }] };
}

export function validateReferenceRequest(schemaId: string, value: unknown) {
  const schema = requestSchemas[schemaId as keyof typeof requestSchemas];
  return schema
    ? project(schema.safeParse(value))
    : { success: false as const, issues: [{ path: "", code: "SCHEMA_NOT_REGISTERED" }] };
}