import {
	GroupContentSchema,
	GroupContentType,
	GroupItemContentSchema,
	GroupItemContentType,
	NestableAndGroupContentSchema,
} from "../group"
import type { GroupContent, GroupItemContent, NestableAndGroupContent } from "../group"
import { GroupItemLegacySchema, GroupLegacySchema } from "../legacy/group"
import type { GroupItemLegacy, GroupLegacy, NestableAndGroupLegacy } from "../legacy/group"
import { type LegacyContentCtx, type LegacyCodec, getFieldCtx } from "./legacyContentCtx"
import { NestableLegacyCodec } from "./nestable"

export const GroupItemLegacyCodec = (
	ctx: LegacyContentCtx,
	index: number,
): LegacyCodec<GroupItemContent, GroupItemLegacy> => ({
	name: "GroupItemLegacy",

	is(input): input is GroupItemContent {
		return GroupItemContentSchema.safeParse(input).success
	},

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

		const groupItemCtx = ctx.withContentKey(index.toString())

		const value: GroupItemContent["value"] = []
		for (const [key, legacy] of Object.entries(parsed.data)) {
			const itemCtx = getFieldCtx({
				fieldKey: key,
				contentKey: key,
				ctx: groupItemCtx,
			})

			const result = NestableAndGroupLegacyCodec(itemCtx).toContent(legacy)
			if (result.success) {
				value.push([key, result.data])
			}
		}

		return {
			success: true,
			data: {
				__TYPE__: GroupItemContentType,
				key: groupItemCtx.fieldContentKey,
				value,
			},
		}
	},

	fromContent(input) {
		const groupItemCtx = ctx.withContentKey(index.toString())

		const legacy: ReturnType<LegacyCodec<GroupItemContent, GroupItemLegacy>["fromContent"]> = {
			content: {},
			types: {},
			keys: { [groupItemCtx.keyOfKey]: input.key },
		}

		for (const [key, content] of input.value) {
			const itemCtx = getFieldCtx({ fieldKey: key, ctx })

			const result = NestableAndGroupLegacyCodec(itemCtx).fromContent(content)
			if (result) {
				legacy.content[key] = result.content
				legacy.types = { ...legacy.types, ...result.types }
				legacy.keys = { ...legacy.keys, ...result.keys }
			}
		}

		return legacy
	},
})

export const GroupLegacyCodec = (
	ctx: LegacyContentCtx,
): LegacyCodec<GroupContent, GroupLegacy> => ({
	name: "GroupLegacy",

	is(input): input is GroupContent {
		return GroupContentSchema.safeParse(input).success
	},

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

		const value: GroupContent["value"] = []
		for (let index = 0; index < parsed.data.length; index++) {
			const item = parsed.data[index]

			// Replace null items with empty GroupItemContent
			if (!item) {
				value.push({
					__TYPE__: GroupItemContentType,
					key: ctx.withContentKey(index.toString()).fieldContentKey,
					value: [],
				})
				continue
			}

			const result = GroupItemLegacyCodec(ctx, index).toContent(item)
			if (!result.success) {
				return result
			}

			value.push(result.data)
		}

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

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

		for (let index = 0; index < input.value.length; index++) {
			const item = input.value[index]
			const result = GroupItemLegacyCodec(ctx, index).fromContent(item)

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

		return legacy
	},
})

export const NestableAndGroupLegacyCodec = (
	ctx: LegacyContentCtx,
): LegacyCodec<NestableAndGroupContent, NestableAndGroupLegacy, true> => ({
	name: "NestableAndGroupLegacy",

	is(input): input is NestableAndGroupContent {
		return NestableAndGroupContentSchema.safeParse(input).success
	},

	toContent(input) {
		return ctx.fieldType === "Group"
			? GroupLegacyCodec(ctx).toContent(input)
			: NestableLegacyCodec(ctx).toContent(input)
	},

	fromContent(input) {
		return input.__TYPE__ === GroupContentType
			? GroupLegacyCodec(ctx).fromContent(input)
			: NestableLegacyCodec(ctx).fromContent(input)
	},
})