import { z } from "zod/mini"

import {
	EmptyDocumentLinkLegacyValueSchema,
	EmptyImageLinkLegacyValueSchema,
	FilledDocumentLinkLegacyValueSchema,
	FilledFileLinkLegacyValueSchema,
	FilledImageLinkLegacyValueSchema,
	EmptyMediaLinkLegacyValueSchema,
	FilledExternalLinkLegacyValueSchema,
	EmptyExternalLinkLegacyValueSchema,
	AnyLinkLegacySchema,
	LinkType,
	EmptyFileLinkLegacyValueSchema,
} from "./legacy/link"

// Image
const FilledImageLinkContentValueSchema = z.extend(FilledImageLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.Image),
})

const EmptyImageLinkContentValueSchema = z.extend(EmptyImageLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.Image),
})

// File
const FilledFileLinkContentValueSchema = z.extend(FilledFileLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.File),
})

const EmptyFileLinkContentValueSchema = z.extend(EmptyFileLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.File),
})

// Media
const EmptyMediaLinkContentValueSchema = z.extend(EmptyMediaLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.Media),
})

// Document
const FilledDocumentLinkContentValueSchema = z.extend(FilledDocumentLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.Document),
})

const EmptyDocumentLinkContentValueSchema = z.extend(EmptyDocumentLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.Document),
})

// External
const FilledExternalLinkContentValueSchema = z.extend(FilledExternalLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.External),
})

const EmptyExternalLinkContentValueSchema = z.extend(EmptyExternalLinkLegacyValueSchema, {
	__TYPE__: z.literal(LinkType.External),
})

// Any
const AnyLinkContentValueSchema = z.extend(AnyLinkLegacySchema, {
	__TYPE__: z.literal(LinkType.Any),
})

// All

// Used by content/richText
export const FilledLinkContentValueSchema: z.ZodMiniType<FilledLinkContentValue> = z.union([
	FilledImageLinkContentValueSchema,
	FilledFileLinkContentValueSchema,
	FilledDocumentLinkContentValueSchema,
	FilledExternalLinkContentValueSchema,
])

// Used by content/legacy/link
type FilledImageLinkContentValue = z.infer<typeof FilledImageLinkContentValueSchema>
type FilledFileLinkContentValue = z.infer<typeof FilledFileLinkContentValueSchema>
type FilledDocumentLinkContentValue = z.infer<typeof FilledDocumentLinkContentValueSchema>
type FilledExternalLinkContentValue = z.infer<typeof FilledExternalLinkContentValueSchema>
export type FilledLinkContentValue =
	| FilledImageLinkContentValue
	| FilledFileLinkContentValue
	| FilledDocumentLinkContentValue
	| FilledExternalLinkContentValue

const EmptyLinkContentValueSchema: z.ZodMiniType<EmptyLinkContentValue> = z.union([
	EmptyImageLinkContentValueSchema,
	EmptyFileLinkContentValueSchema,
	EmptyMediaLinkContentValueSchema,
	EmptyDocumentLinkContentValueSchema,
	EmptyExternalLinkContentValueSchema,
	AnyLinkContentValueSchema,
])

// Used by content/codec/link
type EmptyImageLinkContentValue = z.infer<typeof EmptyImageLinkContentValueSchema>
type EmptyFileLinkContentValue = z.infer<typeof EmptyFileLinkContentValueSchema>
type EmptyMediaLinkContentValue = z.infer<typeof EmptyMediaLinkContentValueSchema>
type EmptyDocumentLinkContentValue = z.infer<typeof EmptyDocumentLinkContentValueSchema>
type EmptyExternalLinkContentValue = z.infer<typeof EmptyExternalLinkContentValueSchema>
type AnyLinkContentValue = z.infer<typeof AnyLinkContentValueSchema>
export type EmptyLinkContentValue =
	| EmptyImageLinkContentValue
	| EmptyFileLinkContentValue
	| EmptyMediaLinkContentValue
	| EmptyDocumentLinkContentValue
	| EmptyExternalLinkContentValue
	| AnyLinkContentValue

const LinkContentValueSchema: z.ZodMiniType<LinkContentValue> = z.union([
	FilledLinkContentValueSchema,
	EmptyLinkContentValueSchema,
])

// Used by content/codec/link
export type LinkContentValue = FilledLinkContentValue | EmptyLinkContentValue

// Content
export const LinkContentType = "LinkContent" as const

const getLinkContentSchema = <TValue extends LinkContentValue>(value: z.ZodMiniType<TValue>) =>
	z.object({
		__TYPE__: z.literal(LinkContentType),
		key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
		// We cannot use z.extend here because we're working with unions.
		// z.intersection wouldn't work also for the same reason.
		value: z.pipe(
			z.pipe(
				z.pipe(
					z.record(z.string(), z.unknown()),
					z.transform(
						({
							text,
							variant,
							...value
						}): {
							text?: unknown
							variant?: unknown
							value: Record<string, unknown>
						} => ({ text, variant, value }),
					),
				),
				z.object({
					text: z.optional(z.string()),
					variant: z.optional(z.string()),
					value: value as z.ZodMiniType<TValue, Record<string, unknown>>,
				}),
			),
			z.transform(({ text, variant, value }) => ({
				...(text ? { text } : {}),
				...(variant ? { variant } : {}),
				...value,
			})),
		),
	})

export const FilledLinkContentSchema = getLinkContentSchema(FilledLinkContentValueSchema)

export type FilledLinkContent = z.infer<typeof FilledLinkContentSchema>

export const EmptyLinkContentSchema = getLinkContentSchema(EmptyLinkContentValueSchema)

export type EmptyLinkContent = z.infer<typeof EmptyLinkContentSchema>

export const LinkContentSchema = getLinkContentSchema(LinkContentValueSchema)

export type LinkContent = z.infer<typeof LinkContentSchema>