import { z } from "zod/mini"

import { BooleanContentType } from "../boolean"
import { EmbedContentType } from "../embed"
import { EmptyContentType } from "../empty"
import { FieldContentType } from "../field"
import { GeoPointContentType } from "../geopoint"
import { ImageContentType } from "../image"
import { IntegrationFieldContentType } from "../integrationField"
import type { NestableLegacy } from "../legacy/nestable"
import { LinkContentType } from "../link"
import type { NestableContent } from "../nestable"
import { NestableContentSchema } from "../nestable"
import { RepeatableContentType } from "../repeatable"
import { RichTextContentType } from "../richText"
import { SeparatorContentType } from "../separator"
import { TableContentType } from "../table"
import { BooleanLegacyCodec } from "./boolean"
import { EmbedLegacyCodec } from "./embed"
import { EmptyLegacyCodec } from "./empty"
import {
	ColorLegacyCodec,
	DateLegacyCodec,
	NumberLegacyCodec,
	RangeLegacyCodec,
	SelectLegacyCodec,
	TextLegacyCodec,
	TimestampLegacyCodec,
} from "./field"
import { GeoPointLegacyCodec } from "./geopoint"
import { ImageLegacyCodec } from "./image"
import { IntegrationFieldLegacyCodec } from "./integrationField"
import type { LegacyCodec, LegacyContentCtx } from "./legacyContentCtx"
import { LinkLegacyCodec } from "./link"
import { RepeatableLegacyCodec } from "./repeatable"
import { RichTextLegacyCodec } from "./richText"
import { SeparatorLegacyCodec } from "./separator"
import { TableLegacyCodec } from "./table"

const UnsupportedNestableLegacySchema = z.never()

export const NestableLegacyCodec = (
	ctx: LegacyContentCtx,
): LegacyCodec<NestableContent, NestableLegacy, true> => ({
	name: "NestableLegacy",

	is(input): input is NestableContent {
		return NestableContentSchema.safeParse(input).success
	},

	toContent(input) {
		if (!ctx.fieldType) {
			return UnsupportedNestableLegacySchema.safeParse(
				input,
			) as z.core.util.SafeParseError<NestableLegacy>
		}

		const empty = EmptyLegacyCodec(ctx).toContent(input)
		if (empty.success) {
			return {
				success: true,
				data: empty.data,
			}
		}

		switch (ctx.fieldType) {
			case "Text":
				return TextLegacyCodec(ctx).toContent(input)
			case "Color":
				return ColorLegacyCodec(ctx).toContent(input)
			case "Date":
				return DateLegacyCodec(ctx).toContent(input)
			case "Timestamp":
				return TimestampLegacyCodec(ctx).toContent(input)
			case "Number":
				return NumberLegacyCodec(ctx).toContent(input)
			case "Range":
				return RangeLegacyCodec(ctx).toContent(input)
			case "Select":
				return SelectLegacyCodec(ctx).toContent(input)
			case "GeoPoint":
				return GeoPointLegacyCodec(ctx).toContent(input)
			case "StructuredText":
				return RichTextLegacyCodec(ctx).toContent(input)
			case "Boolean":
				return BooleanLegacyCodec(ctx).toContent(input)
			case "Embed":
				return EmbedLegacyCodec(ctx).toContent(input)
			case "Image":
				return ImageLegacyCodec(ctx).toContent(input)
			case "IntegrationFields":
				return IntegrationFieldLegacyCodec(ctx).toContent(input)
			case "Link":
				return LinkLegacyCodec(ctx).toContent(input)
			case "Separator":
				return SeparatorLegacyCodec(ctx).toContent(input)
			case "Table":
				return TableLegacyCodec(ctx).toContent(input)
			case "Repeatable.Link":
				return RepeatableLegacyCodec(ctx, "Link").toContent(input)
			default:
				return UnsupportedNestableLegacySchema.safeParse(
					input,
				) as z.core.util.SafeParseError<NestableLegacy>
		}
	},

	fromContent(input) {
		switch (input.__TYPE__) {
			case FieldContentType: {
				if (input.type === "Text") return TextLegacyCodec(ctx).fromContent(input)
				if (input.type === "Color") return ColorLegacyCodec(ctx).fromContent(input)
				if (input.type === "Range") return RangeLegacyCodec(ctx).fromContent(input)
				if (input.type === "Date") return DateLegacyCodec(ctx).fromContent(input)
				if (input.type === "Number") return NumberLegacyCodec(ctx).fromContent(input)
				if (input.type === "Timestamp") return TimestampLegacyCodec(ctx).fromContent(input)
				if (input.type === "Select") return SelectLegacyCodec(ctx).fromContent(input)
				return undefined
			}
			case GeoPointContentType:
				return GeoPointLegacyCodec(ctx).fromContent(input)
			case RichTextContentType:
				return RichTextLegacyCodec(ctx).fromContent(input)
			case EmbedContentType:
				return EmbedLegacyCodec(ctx).fromContent(input)
			case BooleanContentType:
				return BooleanLegacyCodec(ctx).fromContent(input)
			case ImageContentType:
				return ImageLegacyCodec(ctx).fromContent(input)
			case IntegrationFieldContentType:
				return IntegrationFieldLegacyCodec(ctx).fromContent(input)
			case LinkContentType:
				return LinkLegacyCodec(ctx).fromContent(input)
			case SeparatorContentType:
				return SeparatorLegacyCodec(ctx).fromContent(input)
			case TableContentType:
				return TableLegacyCodec(ctx).fromContent(input)
			case RepeatableContentType:
				return RepeatableLegacyCodec(ctx, input.type).fromContent(input)

			case EmptyContentType:
			default:
				return undefined
		}
	},
})