import { DateFromStringOrNumber, Function } from "@prismicio/types-internal/lib/validators"
import { either } from "fp-ts"
import { pipe } from "fp-ts/function"
import * as t from "io-ts"
import { withFallback } from "io-ts-types"
import { mapOutput } from "io-ts-types/lib/mapOutput"

import { DocumentMetadata } from "./DocumentMetadata"

export const GroupLangId = t.string

const RawApiDocument = t.exact(
	t.intersection([
		t.type({
			id: t.string,
			version: t.string,
			type: t.string,
			groupLangId: GroupLangId,
			tags: t.array(t.string),
			data: t.UnknownRecord,
			language: t.string,
		}),
		t.partial({
			first_publication_date: Function.nullable(DateFromStringOrNumber),
			last_publication_date: Function.nullable(DateFromStringOrNumber),
			metadata: withFallback(Function.nullable(DocumentMetadata.codec), DocumentMetadata.empty),
		}),
	]),
)
export type RawApiDocument = t.TypeOf<typeof RawApiDocument>

const ApiDocument = mapOutput(RawApiDocument, (rawDoc) => {
	return {
		id: rawDoc.id,
		version: rawDoc.version,
		type: rawDoc.type,
		groupLangId: rawDoc.groupLangId,
		tags: rawDoc.tags,
		data: rawDoc.data,
		language: rawDoc.language,
		first_publication_date: rawDoc.first_publication_date?.toISOString(),
		last_publication_date: rawDoc.last_publication_date?.toISOString(),
		metadata: rawDoc.metadata,
	}
})

export type ApiDocument = t.OutputOf<typeof ApiDocument>

export const ApiDocumentCodec = new t.Type<ApiDocument, ApiDocument, unknown>(
	"DocCodec",
	(u): u is ApiDocument => ApiDocument.is(u),
	(u, c) =>
		pipe(
			RawApiDocument.validate(u, c),
			either.chain((s) => {
				return t.success(ApiDocument.encode(s))
			}),
		),
	(doc) => doc,
)

export { DocumentMetadata } from "./DocumentMetadata"
export { DocumentReader } from "./DocumentReader"
export { RelatedDocument } from "./RelatedDocument"