import { DocumentContentSchema } from "../document"
import type { DocumentContent } from "../document"
import { DocumentLegacySchema } from "../legacy/document"
import type { DocumentLegacy } from "../legacy/document"
import { defaultCtx } from "./legacyContentCtx"
import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
import { WidgetLegacyCodec } from "./widget"

export const DocumentLegacyCodec = (
	ctx: LegacyContentCtx,
): LegacyCodec<DocumentContent, DocumentLegacy> => ({
	name: "DocumentLegacy",

	is(input): input is DocumentContent {
		return DocumentContentSchema.safeParse(input).success
	},

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

		const data: DocumentContent = {}

		for (const [widgetKey, widgetValue] of Object.entries(parsed.data)) {
			const widgetCtx = defaultCtx(widgetKey, ctx.allTypes, ctx.allKeys)
			const result = WidgetLegacyCodec(widgetCtx).toContent(widgetValue)

			if (result.success) {
				data[widgetKey] = result.data
			}
		}

		return { success: true, data }
	},

	fromContent(input) {
		const legacy: ReturnType<LegacyCodec<DocumentContent, DocumentLegacy>["fromContent"]> = {
			content: {},
			types: {},
			keys: {},
		}

		for (const [widgetKey, widgetValue] of Object.entries(input)) {
			const widgetCtx = defaultCtx(widgetKey, ctx.allTypes)
			const result = WidgetLegacyCodec(widgetCtx).fromContent(widgetValue)

			if (!result) {
				continue
			}

			legacy.content[widgetKey] = result.content
			legacy.types = { ...legacy.types, ...result.types }
			legacy.keys = { ...legacy.keys, ...result.keys }
		}

		return legacy
	},
})