import type { Pipeline } from "corvos";
import type { StandardSchemaV1 } from "corvos/deps/standard_schema.ts";

import { type } from "arktype";
import { Page, PipelineStageError } from "corvos";
import { Severity } from "corvos/core/error.ts";
import { replaceExtension } from "corvos/core/utils/path.ts";

import { ContentImage } from "$/ui/objects/ContentImage.tsx";

export enum HeadingBlockLevel {
	L1 = 1,
	L2 = 2,
	L3 = 3,
	L4 = 4,
	L5 = 5,
	L6 = 6,
}

export const fileAttributeSchema = type({
	"alternativeText?": "string | null",
	"caption?": "string | null",
	"createdAt": "string",
	"documentId": "string",
	"ext": "string",
	"formats?": "Record<string, unknown> | null",
	"hash": "string",
	"height?": "number | null",
	"mime": "string",
	"name": "string",
	"previewUrl?": "string | null",
	"provider": "string",
	"provider_metadata?": "unknown",
	"size": "number",
	"updatedAt": "string",
	"url": "string",
	"width?": "number | null",
});

export type FileAttribute = typeof fileAttributeSchema.infer;

export const imageAttributeSchema = fileAttributeSchema.narrow(
	(o): o is Omit<typeof o, "width" | "height"> & { width: number; height: number } =>
		!!o.width && !!o.height,
);

export type ImageAttribute = typeof imageAttributeSchema.infer;

const blocksAttributeScope = type
	.scope({
		codeBlockNode: {
			"children": "defaultInlineNode[]",
			"language?": "string",
			"type": "'code'",
		},

		defaultInlineNode: "textInlineNode | linkInlineNode",

		headingBlockNode: {
			children: "defaultInlineNode[]",
			level: "1 | 2 | 3 | 4 | 5 | 6",
			type: "'heading'",
		},

		imageBlockNode: {
			children: type({
				text: "string",
				type: "'text'",
			}).array(),
			image: fileAttributeSchema.omit("documentId"),
			type: "'image'",
		},

		linkInlineNode: {
			children: "textInlineNode[]",
			type: "'link'",
			url: "string",
		},

		listBlockNode: {
			children: "(listItemInlineNode | listBlockNode)[]",
			format: "'ordered' | 'unordered'",
			type: "'list'",
		},

		listItemInlineNode: {
			children: "defaultInlineNode[]",
			type: "'list-item'",
		},

		node: "rootNode | nonTextInlineNode",

		nonTextInlineNode: "linkInlineNode | listItemInlineNode",

		paragraphBlockNode: {
			children: "defaultInlineNode[]",
			type: "'paragraph'",
		},

		quoteBlockNode: {
			children: "defaultInlineNode[]",
			type: "'quote'",
		},

		rootNode:
			"paragraphBlockNode | quoteBlockNode | codeBlockNode | headingBlockNode | listBlockNode | imageBlockNode",

		textInlineNode: {
			"bold?": "boolean",
			"code?": "boolean",
			"italic?": "boolean",
			"strikethrough?": "boolean",
			"text": "string",
			"type": "'text'",
			"underline?": "boolean",
		},
	})
	.export();

export const defaultInlineNodeSchema = blocksAttributeScope.defaultInlineNode;

export type DefaultInlineNode = typeof defaultInlineNodeSchema.infer;

export const nodeSchema = blocksAttributeScope.node;

export type Node = typeof nodeSchema.infer;

export const strapiItemSchema = type({
	"[string]": "unknown",
	"documentId": "string",
	"publishedAt": "string.date.parse | null",
	"updatedAt": "string.date.parse",
});

export type StrapiItem = typeof strapiItemSchema.infer;

export function walkBlocks(
	content: (Node | DefaultInlineNode)[],
	fn: (_: Node | DefaultInlineNode) => unknown,
): void {
	for (const node of content) {
		fn(node);

		switch (node.type) {
			case "heading":
			case "code":
			case "quote":
			case "paragraph":
			case "list":
			case "list-item":
			case "link": {
				return walkBlocks(node.children, fn);
			}
		}
	}
}

function blocksNodeToTSX(node: Node | DefaultInlineNode) {
	switch (true) {
		case node.type === "heading": {
			switch (node.level) {
				case 1:
					return <h1>{blocksToTSX(node.children)}</h1>;
				case 2:
					return <h2>{blocksToTSX(node.children)}</h2>;
				case 3:
					return <h3>{blocksToTSX(node.children)}</h3>;
				case 4:
					return <h4>{blocksToTSX(node.children)}</h4>;
				case 5:
					return <h5>{blocksToTSX(node.children)}</h5>;
				default:
					return <h6>{blocksToTSX(node.children)}</h6>;
			}
		}

		case node.type === "image" && !!node.image.caption: {
			return (
				<figure>
					<ContentImage src={node.image.url} alt={node.image.alternativeText ?? undefined} />
					<figcaption>{node.image.caption}</figcaption>
				</figure>
			);
		}

		case node.type === "image": {
			return <ContentImage src={node.image.url} alt={node.image.alternativeText ?? undefined} />;
		}

		case node.type === "code": {
			return (
				<pre>
					<code>{blocksToTSX(node.children)}</code>
				</pre>
			);
		}

		case node.type === "quote": {
			return <blockquote>{blocksToTSX(node.children)}</blockquote>;
		}

		case node.type === "paragraph" &&
			node.children.length === 1 &&
			node.children[0]?.type === "text" &&
			node.children[0].text === "---": {
			return <hr />;
		}

		case node.type === "paragraph": {
			return <p>{blocksToTSX(node.children)}</p>;
		}

		case node.type === "list" && node.format === "ordered": {
			return <ol>${blocksToTSX(node.children)}</ol>;
		}

		case node.type === "list": {
			return <ul>${blocksToTSX(node.children)}</ul>;
		}

		case node.type === "list-item": {
			return <li>${blocksToTSX(node.children)}</li>;
		}

		case node.type === "link": {
			return <a href={node.url}>{blocksToTSX(node.children)}</a>;
		}

		case node.type === "text": {
			return [
				node.bold ? "strong" : undefined,
				node.code ? "code" : undefined,
				node.italic ? "em" : undefined,
				node.strikethrough ? "del" : undefined,
				node.underline ? "u" : undefined,
			].reduce((res: JSX.Element, Tag) => (Tag ? <Tag>{res}</Tag> : res), node.text);
		}
	}
}

export function blocksToTSX(
	content: (Node | DefaultInlineNode)[],
	filter: (node: Node | DefaultInlineNode) => boolean = () => true,
): JSX.Element {
	return content
		.filter(filter)
		.map(blocksNodeToTSX)
		.filter((s) => s !== undefined);
}

export const strapiCollectionResponseSchema = type({
	data: strapiItemSchema.array(),
	meta: {
		pagination: {
			page: "number",
			pageCount: "number",
			pageSize: "number",
			total: "number",
		},
	},
});

export const strapiItemResponseSchema = type({
	data: strapiItemSchema,
});

async function* loadPaginated(url: URL | string, init?: RequestInit) {
	let pageSize: number | undefined;
	let pages = 1;

	for (let i = 0; i < pages; ++i) {
		const pageUrl = new URL(url);

		if (pageSize) {
			pageUrl.searchParams.set("pagination[page]", `${i + 1}`);
			pageUrl.searchParams.set("pagination[pageSize]", `${pageSize}`);
		}

		const res = await fetch(pageUrl, init);
		const json = await res.json();

		const dec = strapiCollectionResponseSchema(json);

		if (dec instanceof type.errors) {
			throw new Error(dec.summary);
		}

		pages = dec.meta.pagination.pageCount;
		pageSize = dec.meta.pagination.pageSize;

		for (const item of dec.data) {
			yield item;
		}
	}
}

export class StrapiLoader {
	init: RequestInit;

	constructor(
		readonly host: string | URL,
		token: string,
		readonly publicHost = host,
	) {
		this.init = {
			headers: {
				Authorization: `Bearer ${token}`,
			},
			keepalive: true,
		};
	}

	async loadSingle<T>(
		collection: string,
		schema: StandardSchemaV1<unknown, T>,
		query: Record<string, string> = {},
	) {
		const url = new URL(`/api/${collection}`, this.host);
		Object.entries(query).forEach(([key, value]) => {
			url.searchParams.append(key, value);
		});

		const res = await fetch(url, this.init);
		const json = await res.json();

		const dec = strapiItemResponseSchema(json);

		if (dec instanceof type.errors) {
			throw new Error(`Schema mismatch in ${url}:\n${dec.summary}`);
		}

		const dec2 = await schema["~standard"].validate(dec.data);

		if (dec2.issues) {
			throw new Error(`Schema mismatch in ${url}:\n${dec2.issues.join("\n")}`);
		}

		return {
			documentId: dec.data.documentId,
			publishedAt: dec.data.publishedAt,
			updatedAt: dec.data.updatedAt,
			...dec2.value,
		};
	}

	async *loadCollection<T>(
		collection: string,
		schema: StandardSchemaV1<unknown, T>,
		query: Record<string, string> = {},
	) {
		const url = new URL(`/api/${collection}`, this.host);
		Object.entries(query).forEach(([key, value]) => {
			url.searchParams.append(key, value);
		});

		for await (const item of loadPaginated(url, this.init)) {
			const dec = await schema["~standard"].validate(item);

			if (dec.issues) {
				yield new PipelineStageError(
					Severity.ERROR,
					`Schema mismatch in ${url}`,
					dec.issues.join("\n"),
				);
			} else {
				yield {
					documentId: item.documentId,
					publishedAt: item.publishedAt,
					updatedAt: item.updatedAt,
					...dec.value,
				};
			}
		}
	}

	readonly resolvedFileAttributeSchema = fileAttributeSchema.pipe(({ url, previewUrl, ...o }) => ({
		...o,
		url: new URL(url, this.publicHost).href,
		...(previewUrl ? { previewUrl: new URL(previewUrl, this.publicHost).href } : {}),
	}));

	readonly resolvedImageAttributeSchema = imageAttributeSchema.pipe((o) => ({
		...o,
		previewUrl: o.previewUrl ? new URL(o.previewUrl, this.publicHost).href : undefined,
		url: new URL(o.url, this.publicHost).href,
	}));
}

export function strapi() {
	return <Loaders extends string, Out extends { ".strapi": [Node[], {}] }, Helpers extends {}>(
		pipeline: Pipeline<Loaders, Out, Helpers>,
	) =>
		pipeline.process("strapi", ".strapi", function* (page) {
			yield new Page(
				".jsxelement",
				blocksToTSX(page.content),
				page.data as Out[".strapi"][1],
				replaceExtension(page.url, ".jsxelement"),
				page,
			);
		});
}

export const Blocks = ({
	content,
	filter = () => true,
}: {
	content: (Node | DefaultInlineNode)[];
	filter?: (node: Node | DefaultInlineNode) => boolean;
}) => blocksToTSX(content, filter);

const strapiUrl = Deno.env.get("STRAPI_URL") ?? "";
const strapiPublicUrl = Deno.env.get("STRAPI_PUBLIC_URL");
const strapiToken = Deno.env.get("STRAPI_TOKEN") ?? "";

export const strapiLoader = new StrapiLoader(strapiUrl, strapiToken, strapiPublicUrl);