import { SliceItemLegacySchema, SlicesLegacySchema } from "../legacy/slices"
import type { SliceItemLegacy, SlicesLegacy } from "../legacy/slices"
import { SliceItemContentSchema, SlicesContentSchema, SlicesContentType } from "../slices"
import type { SliceItemContent, SlicesContent } from "../slices"
import { type LegacyContentCtx, type LegacyCodec, getFieldCtx } from "./legacyContentCtx"
import { SliceLegacyCodec } from "./slice"

// Item
export const SliceItemLegacyCodec = (
	ctx: LegacyContentCtx,
): LegacyCodec<SliceItemContent, SliceItemLegacy> => ({
	name: "SlicesItemLegacy",

	is(input): input is SliceItemContent {
		return SliceItemContentSchema.safeParse(input).success
	},

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

		const sliceName = parsed.data.key.split("$")[0]
		const itemCtx = getFieldCtx({
			fieldKey: sliceName,
			contentKey: parsed.data.key,
			ctx,
		})
		const result = SliceLegacyCodec(itemCtx).toContent(parsed.data.value)

		if (!result.success) {
			return result
		}

		return {
			success: true,
			data: {
				key: parsed.data.key,
				name: sliceName,
				maybeLabel: parsed.data.label || undefined,
				widget: result.data,
			},
		}
	},

	fromContent(input) {
		const itemCtx = getFieldCtx({
			fieldKey: input.name,
			contentKey: input.key,
			ctx,
		})
		const result = SliceLegacyCodec(itemCtx).fromContent(input.widget)

		if (!result) {
			return {
				content: {
					key: input.key,
					label: input.maybeLabel,
					value: {},
				},
				types: {},
				keys: {},
			}
		}

		return {
			content: {
				key: input.key,
				label: input.maybeLabel,
				value: result.content,
			},
			types: result.types,
			keys: result.keys,
		}
	},
})

// Slices
export const SlicesLegacyCodec = (
	ctx: LegacyContentCtx,
): LegacyCodec<SlicesContent, SlicesLegacy> => ({
	name: "SlicesLegacy",

	is(input): input is SlicesContent {
		return SlicesContentSchema.safeParse(input).success
	},

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

		const value: SlicesContent["value"] = []
		for (let index = 0; index < parsed.data.length; index++) {
			const item = parsed.data[index]
			const result = SliceItemLegacyCodec(ctx).toContent(item)
			if (!result.success) {
				return result
			}
			value.push(result.data)
		}

		return {
			success: true,
			data: { __TYPE__: SlicesContentType, value },
		}
	},

	fromContent(input) {
		const legacy: ReturnType<LegacyCodec<SlicesContent, SlicesLegacy>["fromContent"]> = {
			content: [],
			types: { [ctx.keyOfType]: "Slices" },
			keys: {},
		}

		for (let index = 0; index < input.value.length; index++) {
			const item = input.value[index]
			const result = SliceItemLegacyCodec(ctx).fromContent(item)
			if (!result) continue

			legacy.content.push(result.content)
			legacy.types = { ...legacy.types, ...result.types }
			legacy.keys = { ...legacy.keys, ...result.keys }
		}

		return legacy
	},
})