import type {
	EmptyLinkLegacyValue,
	FilledLinkLegacyValue,
	LinkLegacyValue,
	LinkLegacy,
} from "../legacy/link"
import { LinkKind, LinkType, LinkLegacySchema } from "../legacy/link"
import { LinkContentSchema, LinkContentType } from "../link"
import type {
	EmptyLinkContentValue,
	FilledLinkContentValue,
	LinkContent,
	LinkContentValue,
} from "../link"
import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"

// Also used by content/codec/richText
export function linkLegacyToValue(value: FilledLinkLegacyValue): FilledLinkContentValue
export function linkLegacyToValue(value: EmptyLinkLegacyValue): EmptyLinkContentValue
export function linkLegacyToValue(value: LinkLegacyValue): LinkContentValue
export function linkLegacyToValue(
	value: Omit<LinkLegacy, "text" | "variant" | "key">,
): Omit<LinkContent["value"], "text" | "variant"> {
	let content: Omit<LinkContent["value"], "text" | "variant">
	switch (value.kind) {
		case LinkKind.Image:
			content = { __TYPE__: LinkType.Image, ...value }
			break
		case LinkKind.File:
			content = { __TYPE__: LinkType.File, ...value }
			break
		case LinkKind.Document:
			content = { __TYPE__: LinkType.Document, ...value }
			break
		case LinkKind.External:
			content = { __TYPE__: LinkType.External, ...value }
			break
		case LinkKind.Media:
			content = { __TYPE__: LinkType.Media, ...value }
			break
		case LinkKind.Any:
		default:
			content = { __TYPE__: LinkType.Any, ...value }
			break
	}

	return content
}

// Also used by content/codec/repeatable
export function linkLegacyToContent({ key, text, variant, ...legacy }: LinkLegacy): LinkContent {
	return {
		__TYPE__: LinkContentType,
		key,
		value: {
			...(text ? { text } : {}),
			...(variant ? { variant } : {}),
			...linkLegacyToValue(legacy),
		},
	}
}

// Also used by content/codec/richText
export function linkValueToLegacy(value: FilledLinkContentValue): FilledLinkLegacyValue
export function linkValueToLegacy(value: EmptyLinkContentValue): EmptyLinkLegacyValue
export function linkValueToLegacy(value: LinkContentValue): LinkLegacyValue {
	const { __TYPE__, ...legacy } = value
	return legacy
}

function linkContentToLegacy({ key, value }: LinkContent): LinkLegacy {
	const { __TYPE__, ...legacy } = value

	return { key, ...legacy }
}

export const LinkLegacyCodec = (ctx: LegacyContentCtx): LegacyCodec<LinkContent, LinkLegacy> => ({
	name: "LinkLegacy",

	is(input): input is LinkContent {
		return LinkContentSchema.safeParse(input).success
	},

	toContent(input) {
		const parsed = LinkLegacySchema.safeParse(input)
		if (!parsed.success) {
			return parsed
		}

		return {
			success: true,
			data: linkLegacyToContent(parsed.data),
		}
	},

	fromContent(input) {
		return {
			content: linkContentToLegacy(input),
			types: { [ctx.keyOfType]: "Link" },
			keys: {},
		}
	},
})