/**
 * Universal reconciler for Solid custom renderers.
 *
 * Vendored from OpenTUI (MIT): https://github.com/miunau/opentui
 * packages/solid/src/renderer/universal.js
 *
 * Rewritten for Solid 2.0's two-phase createRenderEffect(compute, apply):
 *   - Reactive reads (signal access) happen in compute (tracked)
 *   - Tree mutations (insertNode, removeNode, etc.) happen in apply (untracked)
 *   - No accidental dependency tracking from mutation side-effects
 *   - mergeProps -> merge
 *
 * Converted to TypeScript with proper types.
 */
import {
	createComponent,
	createMemo,
	createRenderEffect,
	createRoot,
	merge,
	untrack,
} from "solid-js";

export interface RendererOptions<N> {
	createElement(tag: string): N;
	createSlotNode(): N;
	createTextNode(value: string): N;
	getFirstChild(node: N): N | undefined;
	getNextSibling(node: N): N | undefined;
	getParentNode(node: N): N | undefined;
	insertNode(parent: N, node: N, anchor?: N): void;
	isTextNode(node: N): boolean;
	removeNode(parent: N, node: N): void;
	replaceText(textNode: N, value: string): void;
	setProperty<T>(node: N, name: string, value: T, prev?: T): void;
}

export interface Renderer<N> {
	// biome-ignore lint: matches solid-js's createComponent signature
	createComponent<T extends Record<string, any>>(
		Comp: (props: T) => unknown,
		props: T,
	): unknown;
	createElement(tag: string): N;
	createTextNode(value: string): N;
	effect: typeof createRenderEffect;
	insert(
		parent: N,
		accessor: (() => unknown) | unknown,
		marker?: N | null,
		initial?: unknown,
	): void;
	insertNode(parent: N, node: N, anchor?: N): void;
	memo<T>(fn: () => T, equal: boolean): () => T;
	mergeProps: typeof merge;
	ref(getter: () => unknown, node: N): void;
	render(code: () => unknown, node: N): () => void;
	setProp<T>(node: N, name: string, value: T, prev?: T): T;
	spread(
		node: N,
		accessor: (() => unknown) | unknown,
		skipChildren?: boolean,
	): void;
	use<A, T>(fn: (element: N, arg: A) => T, element: N, arg: A): T;
}

// Internal value type — the reconciler handles strings, numbers, arrays,
// functions, nodes, null, undefined, and booleans.
type Val = unknown;

const memo = <T>(fn: () => T) => createMemo(() => fn());

export function createRenderer<N>(opts: RendererOptions<N>): Renderer<N> {
	const {
		createElement,
		createTextNode,
		createSlotNode,
		isTextNode,
		replaceText,
		insertNode,
		removeNode,
		setProperty,
		getParentNode,
		getFirstChild,
		getNextSibling,
	} = opts;

	function insert(parent: N, accessor: Val, marker?: N | null, initial?: Val) {
		if (marker !== undefined && !initial) initial = [];
		if (typeof accessor !== "function")
			return insertExpression(parent, accessor, initial, marker);
		let current = initial;
		createRenderEffect(
			() => (accessor as () => Val)(),
			(value: Val) => {
				current = insertExpression(parent, value, current, marker);
			},
		);
	}

	function insertExpression(
		parent: N,
		value: Val,
		current: Val,
		marker?: N | null,
		unwrapArray?: boolean,
	): Val {
		while (typeof current === "function") current = (current as () => Val)();
		if (value === current) return current;
		const t = typeof value;
		const multi = marker !== undefined;
		if (t === "string" || t === "number") {
			if (t === "number") value = String(value);
			if (multi) {
				let node = (current as N[])[0];
				if (node && isTextNode(node)) {
					replaceText(node, value as string);
				} else node = createTextNode(value as string);
				current = cleanChildren(parent, current as N[], marker, node);
			} else {
				if (current !== "" && typeof current === "string") {
					current = value;
					replaceText(getFirstChild(parent) as N, current as string);
				} else {
					cleanChildren(
						parent,
						current,
						marker,
						createTextNode(value as string),
					);
					current = value;
				}
			}
		} else if (value == null || t === "boolean") {
			current = cleanChildren(parent, current, marker);
		} else if (t === "function") {
			createRenderEffect(
				() => {
					let v: Val = (value as () => Val)();
					while (typeof v === "function") v = (v as () => Val)();
					return v;
				},
				(v: Val) => {
					current = insertExpression(parent, v, current, marker);
				},
			);
			return () => current;
		} else if (Array.isArray(value)) {
			const array: N[] = [];
			if (normalizeIncomingArray(array, value, unwrapArray)) {
				createRenderEffect(
					() => array.slice(),
					() => {
						current = insertExpression(parent, array, current, marker, true);
					},
				);
				return () => current;
			}
			if (array.length === 0) {
				const replacement = cleanChildren(parent, current, marker);
				if (multi) {
					current = replacement;
					return current;
				}
			} else {
				if (Array.isArray(current)) {
					if (current.length === 0) {
						appendNodes(parent, array, marker);
					} else reconcileArrays(parent, current as N[], array);
				} else if (current == null || current === "") {
					appendNodes(parent, array);
				} else {
					reconcileArrays(
						parent,
						(multi && (current as N[])) || [getFirstChild(parent) as N],
						array,
					);
				}
			}
			current = array;
		} else {
			if (Array.isArray(current)) {
				if (multi) {
					current = cleanChildren(parent, current, marker, value as N);
					return current;
				}
				cleanChildren(parent, current, null, value as N);
			} else if (current == null || current === "" || !getFirstChild(parent)) {
				insertNode(parent, value as N);
			} else replaceNode(parent, value as N, getFirstChild(parent) as N);
			current = value;
		}
		return current;
	}

	function normalizeIncomingArray(
		normalized: N[],
		array: Val[],
		unwrap?: boolean,
	): boolean {
		let dynamic = false;
		for (let i = 0, len = array.length; i < len; i++) {
			let item: Val = array[i];
			if (item == null || item === true || item === false) {
				// skip
			} else if (Array.isArray(item)) {
				dynamic = normalizeIncomingArray(normalized, item) || dynamic;
			} else if (typeof item === "string" || typeof item === "number") {
				normalized.push(createTextNode(String(item)));
			} else if (typeof item === "function") {
				if (unwrap) {
					while (typeof item === "function") item = (item as () => Val)();
					dynamic =
						normalizeIncomingArray(
							normalized,
							Array.isArray(item) ? item : [item],
						) || dynamic;
				} else {
					normalized.push(item as N);
					dynamic = true;
				}
			} else normalized.push(item as N);
		}
		return dynamic;
	}

	// Array index access helper — indices in reconcileArrays are always
	// valid (guarded by loop bounds), avoids non-null assertions throughout.
	function at(arr: N[], i: number): N {
		return arr[i] as N;
	}

	function reconcileArrays(parentNode: N, a: N[], b: N[]) {
		const bLength = b.length;
		let aEnd = a.length;
		let bEnd = bLength;
		let aStart = 0;
		let bStart = 0;
		const after = getNextSibling(at(a, aEnd - 1));
		let map: Map<N, number> | null = null;
		while (aStart < aEnd || bStart < bEnd) {
			if (a[aStart] === b[bStart]) {
				aStart++;
				bStart++;
				continue;
			}
			while (a[aEnd - 1] === b[bEnd - 1]) {
				aEnd--;
				bEnd--;
			}
			if (aEnd === aStart) {
				const node =
					bEnd < bLength
						? bStart
							? getNextSibling(at(b, bStart - 1))
							: b[bEnd - bStart]
						: after;
				while (bStart < bEnd)
					insertNode(parentNode, at(b, bStart++), node as N);
			} else if (bEnd === bStart) {
				while (aStart < aEnd) {
					if (!map?.has(at(a, aStart))) removeNode(parentNode, at(a, aStart));
					aStart++;
				}
			} else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
				const node = getNextSibling(at(a, --aEnd));
				insertNode(
					parentNode,
					at(b, bStart++),
					getNextSibling(at(a, aStart++)) as N,
				);
				insertNode(parentNode, at(b, --bEnd), node as N);
				a[aEnd] = at(b, bEnd);
			} else {
				if (!map) {
					map = new Map();
					let i = bStart;
					while (i < bEnd) {
						map.set(at(b, i), i);
						i++;
					}
				}
				const index = map.get(at(a, aStart));
				if (index != null) {
					if (bStart < index && index < bEnd) {
						let i = aStart;
						let sequence = 1;
						while (++i < aEnd && i < bEnd) {
							const t = map.get(at(a, i));
							if (t == null || t !== index + sequence) break;
							sequence++;
						}
						if (sequence > index - bStart) {
							const node = at(a, aStart);
							while (bStart < index)
								insertNode(parentNode, at(b, bStart++), node);
						} else replaceNode(parentNode, at(b, bStart++), at(a, aStart++));
					} else aStart++;
				} else removeNode(parentNode, at(a, aStart++));
			}
		}
	}

	function cleanChildren(
		parent: N,
		current: Val,
		marker?: N | null,
		replacement?: N,
	): Val {
		if (marker === undefined) {
			let removed = getFirstChild(parent);
			while (removed) {
				removeNode(parent, removed);
				removed = getFirstChild(parent);
			}
			if (replacement) insertNode(parent, replacement);
			return replacement ?? "";
		}
		const node = replacement || createSlotNode();
		if (Array.isArray(current) && current.length) {
			let inserted = false;
			for (let i = current.length - 1; i >= 0; i--) {
				const el = current[i] as N;
				if (node !== el) {
					const hasParent = getParentNode(el) === parent;
					if (!inserted && !i)
						hasParent
							? replaceNode(parent, node, el)
							: insertNode(parent, node, marker as N);
					else if (hasParent) removeNode(parent, el);
				} else inserted = true;
			}
		} else insertNode(parent, node, marker as N);
		return [node];
	}

	function appendNodes(parent: N, array: N[], marker?: N | null) {
		for (let i = 0, len = array.length; i < len; i++)
			insertNode(parent, at(array, i), marker as N | undefined);
	}

	function replaceNode(parent: N, newNode: N, oldNode: N) {
		insertNode(parent, newNode, oldNode);
		removeNode(parent, oldNode);
	}

	type Props = Record<string, unknown>;

	function spreadExpression(
		node: N,
		props: Props,
		prevProps: Props = {},
		skipChildren?: boolean,
	): Props {
		if (!props) props = {};
		if (!skipChildren) {
			let current = prevProps.children;
			createRenderEffect(
				() => props.children,
				(children: Val) => {
					current = insertExpression(node, children, current);
					prevProps.children = current;
				},
			);
		}
		createRenderEffect(
			() => props.ref,
			(ref: Val) => (ref as ((n: N) => void) | undefined)?.(node),
		);
		createRenderEffect(
			() => {
				const snapshot: Props = {};
				for (const prop in props) {
					if (prop === "children" || prop === "ref") continue;
					snapshot[prop] = props[prop];
				}
				return snapshot;
			},
			(newProps: Props) => {
				for (const prop in newProps) {
					const value = newProps[prop];
					if (value === prevProps[prop]) continue;
					setProperty(node, prop, value, prevProps[prop]);
					prevProps[prop] = value;
				}
			},
		);
		return prevProps;
	}

	return {
		render(code: () => unknown, element: N) {
			let disposer: (() => void) | undefined;
			createRoot((dispose) => {
				disposer = dispose;
				insert(element, code());
			});
			return disposer as unknown as () => void;
		},
		insert,
		spread(node: N, accessor: Val, skipChildren?: boolean) {
			if (typeof accessor === "function") {
				let prev: Props | undefined;
				createRenderEffect(
					() => (accessor as () => Props)(),
					(props: Props) => {
						prev = spreadExpression(node, props, prev, skipChildren);
					},
				);
			} else spreadExpression(node, accessor as Props, undefined, skipChildren);
		},
		createElement,
		createTextNode,
		insertNode,
		setProp<T>(node: N, name: string, value: T, prev?: T): T {
			setProperty(node, name, value, prev);
			return value;
		},
		mergeProps: merge,
		effect: createRenderEffect,
		memo,
		createComponent,
		ref(getter: () => unknown, node: N) {
			const ref = getter();
			if (typeof ref === "function") {
				(ref as (n: N) => void)(node);
			}
		},
		use<A, T>(fn: (element: N, arg: A) => T, element: N, arg: A): T {
			return untrack(() => fn(element, arg));
		},
	};
}