import { asCid, type Cid } from "@atp/lex/data";
import { z } from "zod";
import type { Def } from "./check.ts";

const cidSchema = z.unknown().transform((obj, ctx): Cid => {
  const cid = asCid(obj);

  if (cid == null) {
    ctx.addIssue({
      code: "custom",
      message: "Not a valid CID",
    });
    return z.NEVER;
  }

  return cid;
});

const carHeader: z.ZodObject<{ version: z.ZodLiteral<1>; roots: z.ZodArray }> =
  z.object({
    version: z.literal(1),
    roots: z.array(cidSchema),
  });
export type CarHeader = z.infer<typeof carHeader>;

export const schema: Record<string, z.ZodTypeAny> = {
  cid: cidSchema,
  carHeader,
  bytes: z.instanceof(Uint8Array),
  string: z.string(),
  array: z.array(z.unknown()),
  map: z.record(z.string(), z.unknown()),
  unknown: z.unknown(),
};

export const def = {
  cid: {
    name: "cid",
    schema: schema.cid,
  } as Def<Cid>,
  carHeader: {
    name: "CAR header",
    schema: schema.carHeader,
  } as Def<CarHeader>,
  bytes: {
    name: "bytes",
    schema: schema.bytes,
  } as Def<Uint8Array>,
  string: {
    name: "string",
    schema: schema.string,
  } as Def<string>,
  map: {
    name: "map",
    schema: schema.map,
  } as Def<Record<string, unknown>>,
  unknown: {
    name: "unknown",
    schema: schema.unknown,
  } as Def<unknown>,
};

export type ArrayEl<A> = A extends readonly (infer T)[] ? T : never;

export type NotEmptyArray<T> = [T, ...T[]];