import { LinkLegacySchema } from "../legacy/link"
import { RepeatableLegacySchema } from "../legacy/repeatable"
import type { RepeatableLegacy } from "../legacy/repeatable"
import { RepeatableContentSchema, RepeatableContentType } from "../repeatable"
import type { RepeatableContent } from "../repeatable"
import type { LegacyCodec, LegacyContentCtx } from "./legacyContentCtx"
import { LinkLegacyCodec, linkLegacyToContent } from "./link"

export const RepeatableLegacyCodec = (
	ctx: LegacyContentCtx,
	fieldType: "Link",
): LegacyCodec<RepeatableContent, RepeatableLegacy> => ({
	name: "RepeatableLegacy",

	is(input): input is RepeatableContent {
		return RepeatableContentSchema.safeParse(input).success
	},

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

		return {
			success: true,
			data: {
				__TYPE__: RepeatableContentType,
				type: fieldType,
				value: parsed.data.flatMap((item) => {
					try {
						switch (fieldType) {
							case "Link":
								return [linkLegacyToContent(LinkLegacySchema.parse(item))]
							default:
								return []
						}
					} catch {
						return []
					}
				}),
			},
		}
	},

	fromContent(input) {
		const legacy: ReturnType<LegacyCodec<RepeatableContent, RepeatableLegacy>["fromContent"]> = {
			content: [],
			types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
			keys: {},
		}

		for (const item of input.value) {
			try {
				switch (fieldType) {
					case "Link":
						const result = LinkLegacyCodec(ctx).fromContent(item)
						legacy.content.push(result.content)
						legacy.keys = { ...legacy.keys, ...result.keys }
						break
				}
			} catch {
				// noop, continue
			}
		}
		return legacy
	},
})