import { type OmpErrors, OmpTypeError } from "./errors";
import { type EmbeddableSchema, embed, type IR, IR_BRAND, type PropIR } from "./ir";
import { type NarrowContext, type Type, type } from "./type";

interface OptionalSchemaMarker {
	readonly _optional: true;
}

interface RefineOptions {
	message?: string;
	error?: string;
}

interface Decoratable<out Out> extends EmbeddableSchema {
	(value: unknown): Out | OmpErrors;
	narrow(predicate: (value: Out, context: NarrowContext) => unknown): Decoratable<Out>;
	pipe<Next>(transform: (value: Out, context: NarrowContext) => Next): Decoratable<Exclude<Next, OmpErrors>>;
	or(def: unknown): Decoratable<unknown>;
	describe(description: string): Decoratable<Out>;
	default(value: Out | (() => Out)): Decoratable<Out>;
}

export interface SuperRefineIssue {
	code?: string;
	path?: PropertyKey[];
	message: string;
	actual?: unknown;
}

export interface SuperRefineContext {
	addIssue(issue: SuperRefineIssue): void;
}

export interface ZodLikeIssue {
	path: PropertyKey[];
	message: string;
}

export type ZodLikeSafeParseResult<Out> =
	| { success: true; data: Out }
	| { success: false; error: { message: string; issues: ZodLikeIssue[] } };

/** A callable omptype schema carrying the Zod-v4-style fluent surface. */
export interface ZodLikeSchema<out Out> extends Type<Out, unknown> {
	readonly _output: Out;
	/** @internal Used while composing object property IR. */
	readonly isOptional: boolean;
	parse(value: unknown): Out;
	safeParse(value: unknown): ZodLikeSafeParseResult<Out>;
	min(bound: number): ZodLikeSchema<Out>;
	max(bound: number): ZodLikeSchema<Out>;
	int(): ZodLikeSchema<Out>;
	positive(): ZodLikeSchema<Out>;
	nonnegative(): ZodLikeSchema<Out>;
	regex(expression: RegExp, message?: string): ZodLikeSchema<Out>;
	url(): ZodLikeSchema<Out>;
	optional(): ZodLikeSchema<Out | undefined> & OptionalSchemaMarker;
	nullable(): ZodLikeSchema<Out | null>;
	default(value: Exclude<Out, undefined> | (() => Exclude<Out, undefined>)): ZodLikeSchema<Exclude<Out, undefined>>;
	describe(description: string): ZodLikeSchema<Out>;
	refine(predicate: (value: Out) => unknown, messageOrOptions?: string | RefineOptions): ZodLikeSchema<Out>;
	superRefine(refinement: (value: Out, ctx: SuperRefineContext) => void): ZodLikeSchema<Out>;
	trim(): ZodLikeSchema<Out>;
	transform<Next>(transformer: (value: Out) => Next): ZodLikeSchema<Next>;
	catch(fallback: Out | (() => Out)): ZodLikeSchema<Out>;
	strict(): ZodLikeSchema<Out>;
	passthrough(): ZodLikeSchema<Out & Record<string, unknown>>;
	strip(): ZodLikeSchema<Out>;
	partial(): Out extends object ? ZodLikeSchema<Partial<Out>> : ZodLikeSchema<Out>;
}

function schemaFromIR<Out>(ir: IR): Decoratable<Out> {
	const embedded: EmbeddableSchema = {
		[IR_BRAND]: true,
		ir,
		hasSteps: false,
		hasDefault: false,
		run: value => value,
	};
	return type.raw(embedded) as unknown as Decoratable<Out>;
}

function restrictBase<Out>(source: Decoratable<Out>, ir: IR): Decoratable<Out> {
	let next = source.hasSteps
		? schemaFromIR<Out>({ k: "morph", input: ir, fn: value => source(value) })
		: schemaFromIR<Out>(ir);
	if (source.ir.desc !== undefined) next = next.describe(source.ir.desc);
	if (source.hasDefault) next = next.default(source.defaultValue as Out | (() => Out));
	return next;
}

function lengthBound(kind: "min" | "max", schema: Decoratable<unknown>, bound: number): void {
	if (schema.ir.k !== "string" && schema.ir.k !== "array") return;
	if (!Number.isSafeInteger(bound) || bound < 0) {
		throw new OmpTypeError(`${kind} length must be a nonnegative safe integer`);
	}
}

function refinementMessage(messageOrOptions: string | RefineOptions | undefined): string {
	if (typeof messageOrOptions === "string") return messageOrOptions;
	return messageOrOptions?.message ?? messageOrOptions?.error ?? "valid (refinement failed)";
}

function isStringKeyIR(ir: IR): boolean {
	switch (ir.k) {
		case "string":
			return true;
		case "lit":
			return typeof ir.v === "string";
		case "union":
			return ir.members.length > 0 && ir.members.every(isStringKeyIR);
		case "sub":
			return isStringKeyIR(ir.schema.ir);
		default:
			return false;
	}
}

function decorate<Out>(schema: Decoratable<Out>, optional = false): ZodLikeSchema<Out> {
	const next = (inner: Decoratable<Out>, nextOptional = optional): ZodLikeSchema<Out> => decorate(inner, nextOptional);
	const withObjectExtras = (extras: "keep" | "reject" | "delete"): ZodLikeSchema<Out> => {
		if (schema.ir.k !== "object") throw new OmpTypeError("object mode requires an object schema");
		return next(restrictBase(schema, { ...schema.ir, extras }));
	};
	Object.defineProperty(schema, "isOptional", { value: optional, enumerable: false });

	return Object.assign(schema, {
		parse(value: unknown): Out {
			const result = schema(value);
			if (result instanceof type.errors) throw new Error(result.summary);
			return result;
		},
		safeParse(value: unknown): ZodLikeSafeParseResult<Out> {
			const result = schema(value);
			if (!(result instanceof type.errors)) return { success: true, data: result };
			return {
				success: false,
				error: {
					message: result.summary,
					issues: result.map(issue => ({ path: [...issue.path], message: issue.problem })),
				},
			};
		},
		min(bound: number): ZodLikeSchema<Out> {
			const ir = schema.ir;
			if (ir.k === "string" || ir.k === "array") {
				lengthBound("min", schema, bound);
				const min = ir.min === undefined ? bound : Math.max(ir.min, bound);
				return next(restrictBase(schema, { ...ir, min }));
			}
			if (ir.k === "number") {
				if (Number.isNaN(bound)) throw new OmpTypeError("number min must not be NaN");
				if (ir.min !== undefined && ir.min >= bound) return next(restrictBase(schema, ir));
				return next(restrictBase(schema, { ...ir, min: bound, xmin: false }));
			}
			if (
				ir.k === "morph" &&
				!schema.hasSteps &&
				ir.out !== undefined &&
				(ir.out.k === "string" || ir.out.k === "array")
			) {
				if (!Number.isSafeInteger(bound) || bound < 0)
					throw new OmpTypeError("min length must be a nonnegative safe integer");
				const out = { ...ir.out, min: ir.out.min === undefined ? bound : Math.max(ir.out.min, bound) };
				return next(restrictBase(schema, { ...ir, out }));
			}
			if (ir.k === "morph" && (schema.hasSteps || ir.out === undefined)) {
				if (!Number.isSafeInteger(bound) || bound < 0)
					throw new OmpTypeError("min length must be a nonnegative safe integer");
				return next(
					schema.narrow((value, ctx) => {
						if (typeof value === "string" || Array.isArray(value)) {
							return value.length >= bound || ctx.mustBe(`at least ${bound} characters`);
						}
						return ctx.mustBe("a string or array");
					}),
				);
			}
			throw new OmpTypeError(`cannot apply min to ${ir.k}`);
		},
		max(bound: number): ZodLikeSchema<Out> {
			const ir = schema.ir;
			if (ir.k === "string" || ir.k === "array") {
				lengthBound("max", schema, bound);
				const max = ir.max === undefined ? bound : Math.min(ir.max, bound);
				return next(restrictBase(schema, { ...ir, max }));
			}
			if (ir.k === "number") {
				if (Number.isNaN(bound)) throw new OmpTypeError("number max must not be NaN");
				if (ir.max !== undefined && ir.max <= bound) return next(restrictBase(schema, ir));
				return next(restrictBase(schema, { ...ir, max: bound, xmax: false }));
			}
			if (
				ir.k === "morph" &&
				!schema.hasSteps &&
				ir.out !== undefined &&
				(ir.out.k === "string" || ir.out.k === "array")
			) {
				if (!Number.isSafeInteger(bound) || bound < 0)
					throw new OmpTypeError("max length must be a nonnegative safe integer");
				const out = { ...ir.out, max: ir.out.max === undefined ? bound : Math.min(ir.out.max, bound) };
				return next(restrictBase(schema, { ...ir, out }));
			}
			if (ir.k === "morph" && (schema.hasSteps || ir.out === undefined)) {
				if (!Number.isSafeInteger(bound) || bound < 0)
					throw new OmpTypeError("max length must be a nonnegative safe integer");
				return next(
					schema.narrow((value, ctx) => {
						if (typeof value === "string" || Array.isArray(value)) {
							return value.length <= bound || ctx.mustBe(`at most ${bound} characters`);
						}
						return ctx.mustBe("a string or array");
					}),
				);
			}
			throw new OmpTypeError(`cannot apply max to ${ir.k}`);
		},
		int(): ZodLikeSchema<Out> {
			if (schema.ir.k !== "number") throw new OmpTypeError(`cannot apply int to ${schema.ir.k}`);
			return next(restrictBase(schema, { ...schema.ir, int: true }));
		},
		positive(): ZodLikeSchema<Out> {
			if (schema.ir.k !== "number") throw new OmpTypeError(`cannot apply positive to ${schema.ir.k}`);
			const ir = schema.ir;
			if (ir.min !== undefined && ir.min > 0) return next(restrictBase(schema, ir));
			return next(restrictBase(schema, { ...ir, min: 0, xmin: true }));
		},
		nonnegative(): ZodLikeSchema<Out> {
			if (schema.ir.k !== "number") throw new OmpTypeError(`cannot apply nonnegative to ${schema.ir.k}`);
			return this.min(0);
		},
		regex(expression: RegExp, message?: string): ZodLikeSchema<Out> {
			const ir = schema.ir;
			const isStringLike =
				ir.k === "string" ||
				(ir.k === "morph" && (ir.out?.k === "string" || (ir.out === undefined && ir.input.k === "string")));
			if (!isStringLike) throw new OmpTypeError(`cannot apply regex to ${ir.k}`);
			const expectation = message ?? `matching ${expression}`;
			const narrowed = schema.narrow((value, ctx) => {
				if (typeof value !== "string") return ctx.mustBe("a string");
				expression.lastIndex = 0;
				const matches = expression.test(value);
				expression.lastIndex = 0;
				return matches || ctx.mustBe(expectation);
			});
			return next(narrowed);
		},
		url(): ZodLikeSchema<Out> {
			const ir = schema.ir;
			if (ir.k === "string") return next(restrictBase(schema, { ...ir, url: true }));
			if (ir.k === "morph" && !schema.hasSteps && ir.out !== undefined && ir.out.k === "string") {
				return next(restrictBase(schema, { ...ir, out: { ...ir.out, url: true } }));
			}
			if (ir.k === "morph" && (schema.hasSteps || ir.out === undefined)) {
				return next(
					schema.narrow((value, ctx) => {
						if (typeof value !== "string") return ctx.mustBe("a string");
						try {
							new URL(value);
							return true;
						} catch {
							return ctx.mustBe("a valid URL");
						}
					}),
				);
			}
			throw new OmpTypeError(`cannot apply url to ${ir.k}`);
		},
		optional(): ZodLikeSchema<Out | undefined> & OptionalSchemaMarker {
			const widened = schema.or(type.raw("undefined")) as Decoratable<Out | undefined>;
			return decorate(widened, true) as ZodLikeSchema<Out | undefined> & OptionalSchemaMarker;
		},
		nullable(): ZodLikeSchema<Out | null> {
			return decorate(schema.or(type.raw("null")) as Decoratable<Out | null>, optional);
		},
		default(
			value: Exclude<Out, undefined> | (() => Exclude<Out, undefined>),
		): ZodLikeSchema<Exclude<Out, undefined>> {
			type DefaultOut = Exclude<Out, undefined>;
			const widened = schema.or(type.raw("undefined")) as Decoratable<Out | undefined>;
			const piped = widened.pipe(output => {
				if (output !== undefined) return output as DefaultOut;
				return typeof value === "function" ? (value as () => DefaultOut)() : value;
			}) as Decoratable<DefaultOut>;
			return decorate(piped.default(value as DefaultOut | (() => DefaultOut)));
		},
		describe(description: string): ZodLikeSchema<Out> {
			return next(restrictBase(schema, { ...schema.ir, desc: description }).describe(description));
		},
		refine(predicate: (value: Out) => unknown, messageOrOptions?: string | RefineOptions): ZodLikeSchema<Out> {
			const expectation = refinementMessage(messageOrOptions);
			return next(schema.narrow((value, ctx) => Boolean(predicate(value)) || ctx.mustBe(expectation)));
		},
		superRefine(refinement: (value: Out, ctx: SuperRefineContext) => void): ZodLikeSchema<Out> {
			return next(
				schema.narrow((value, ctx) => {
					const proxy: SuperRefineContext = {
						addIssue(issue) {
							ctx.error({
								expected: issue.message,
								path: issue.path ?? [],
								...(issue.actual !== undefined ? { actual: issue.actual } : {}),
							});
						},
					};
					refinement(value, proxy);
					return true;
				}),
			);
		},
		trim(): ZodLikeSchema<Out> {
			const ir = schema.ir;
			if (ir.k === "string" && !schema.hasSteps) {
				let trimmed = schemaFromIR<Out>({
					k: "morph",
					input: { k: "string" },
					fn: v => (v as string).trim(),
					out: ir,
				});
				if (schema.hasDefault) trimmed = trimmed.default(schema.defaultValue as Out | (() => Out));
				return next(trimmed);
			}
			if (ir.k === "morph" || schema.hasSteps) {
				let trimmed = schemaFromIR<Out>({
					k: "morph",
					input: { k: "unknown" },
					fn: v => {
						const r = schema(v);
						if (r instanceof type.errors) return r;
						if (typeof r !== "string") throw new OmpTypeError("trim requires a string output");
						return r.trim();
					},
					out: { k: "string" },
				});
				if (schema.hasDefault) trimmed = trimmed.default(schema.defaultValue as Out | (() => Out));
				return next(trimmed);
			}
			throw new OmpTypeError(`cannot apply trim to ${ir.k}`);
		},
		transform<Next>(transformer: (value: Out) => Next): ZodLikeSchema<Next> {
			return decorate(
				schema.pipe(value => transformer(value)),
				optional,
			);
		},
		catch(fallback: Out | (() => Out)): ZodLikeSchema<Out> {
			const caught = type.unknown.pipe(input => {
				try {
					const result = schema(input);
					if (!(result instanceof type.errors)) return result;
				} catch {
					// A caught schema is deliberately total, including user refinement/transform exceptions.
				}
				return typeof fallback === "function" ? (fallback as () => Out)() : fallback;
			});
			return decorate(caught as Decoratable<Out>, optional);
		},
		strict(): ZodLikeSchema<Out> {
			return withObjectExtras("reject");
		},
		passthrough(): ZodLikeSchema<Out & Record<string, unknown>> {
			return withObjectExtras("keep") as ZodLikeSchema<Out & Record<string, unknown>>;
		},
		strip(): ZodLikeSchema<Out> {
			return withObjectExtras("delete");
		},
		partial(): Out extends object ? ZodLikeSchema<Partial<Out>> : ZodLikeSchema<Out> {
			if (schema.ir.k !== "object") throw new OmpTypeError(`cannot apply partial to ${schema.ir.k}`);
			const props = schema.ir.props.map(prop => ({ ...prop, opt: true }));
			return next(restrictBase(schema, { ...schema.ir, props })) as Out extends object
				? ZodLikeSchema<Partial<Out>>
				: ZodLikeSchema<Out>;
		},
	}) as unknown as ZodLikeSchema<Out>;
}

function decorateUnknown(schema: Decoratable<unknown>): ZodLikeSchema<unknown> {
	return decorate(schema);
}

export type infer<T> = T extends { readonly _output: infer Out } ? Out : never;

type SchemaOutput<Schema> = Schema extends { readonly _output: infer Out } ? Out : never;
type Shape = Readonly<Record<string, ZodLikeSchema<unknown>>>;
type ObjectOutput<S extends Shape> = {
	-readonly [K in keyof S as S[K] extends OptionalSchemaMarker ? never : K]: SchemaOutput<S[K]>;
} & {
	-readonly [K in keyof S as S[K] extends OptionalSchemaMarker ? K : never]?: SchemaOutput<S[K]>;
};
type Simplify<T> = { [K in keyof T]: T[K] };
type UnionOutput<Schemas extends readonly ZodLikeSchema<unknown>[]> = SchemaOutput<Schemas[number]>;

function objectSchema<const S extends Shape>(shape: S): ZodLikeSchema<ObjectOutput<S>> {
	const props: PropIR[] = [];
	for (const key in shape) {
		const member = shape[key];
		const prop: PropIR = { key, opt: member.isOptional, val: embed(member) };
		if (member.hasDefault) {
			prop.hasDefault = true;
			prop.def = member.defaultValue;
			prop.defFactory = typeof member.defaultValue === "function";
		}
		props.push(prop);
	}
	return decorateUnknown(schemaFromIR<unknown>({ k: "object", props, extras: "delete" })) as unknown as ZodLikeSchema<
		ObjectOutput<S>
	>;
}

export const string = (): ZodLikeSchema<string> => decorate(schemaFromIR(type.string.ir));
export const number = (): ZodLikeSchema<number> => decorate(schemaFromIR(type.number.ir));
export const boolean = (): ZodLikeSchema<boolean> => decorate(schemaFromIR(type.boolean.ir));
export const literal = <const Value>(value: Value): ZodLikeSchema<Value> =>
	decorate(schemaFromIR<Value>(type.enumerated(value).ir));
const enumSchema = <const Values extends readonly [string, ...string[]]>(
	values: Values,
): ZodLikeSchema<Values[number]> => {
	if (values.length === 0) throw new OmpTypeError("enum requires at least one value");
	return decorate(schemaFromIR<Values[number]>(type.enumerated(...values).ir));
};

export { enumSchema as enum };
export const union = <
	const Schemas extends readonly [ZodLikeSchema<unknown>, ZodLikeSchema<unknown>, ...ZodLikeSchema<unknown>[]],
>(
	schemas: Schemas,
): ZodLikeSchema<UnionOutput<Schemas>> =>
	decorate(schemaFromIR({ k: "union", members: schemas.map(schema => embed(schema)) }));
export const array = <Element>(element: ZodLikeSchema<Element>): ZodLikeSchema<Element[]> =>
	decorate(schemaFromIR({ k: "array", el: embed(element) }));
export const object = <const S extends Shape>(shape: S): ZodLikeSchema<Simplify<ObjectOutput<S>>> =>
	objectSchema(shape);
export function record<Key extends string, Value>(
	keySchema: ZodLikeSchema<Key>,
	valueSchema: ZodLikeSchema<Value>,
): ZodLikeSchema<Record<string, Value>>;
export function record<Value>(valueSchema: ZodLikeSchema<Value>): ZodLikeSchema<Record<string, Value>>;
export function record<Key extends string, Value>(
	keyOrValueSchema: ZodLikeSchema<Key> | ZodLikeSchema<Value>,
	valueSchema?: ZodLikeSchema<Value>,
): ZodLikeSchema<Record<string, Value>> {
	const keySchema = (valueSchema === undefined ? string() : keyOrValueSchema) as ZodLikeSchema<Key>;
	const valSchema = (valueSchema === undefined ? keyOrValueSchema : valueSchema) as ZodLikeSchema<Value>;
	if (!isStringKeyIR(keySchema.ir)) throw new OmpTypeError("record keys must use a string schema");
	const base = schemaFromIR<Record<string, Value>>({
		k: "object",
		props: [],
		index: embed(valSchema),
		extras: "keep",
	});
	const checked = base.narrow((value, ctx: NarrowContext) => {
		for (const key in value) {
			if (keySchema(key) instanceof type.errors) return ctx.mustBe("a record with valid string keys");
		}
		return true;
	});
	return decorate(checked);
}
export const unknown = (): ZodLikeSchema<unknown> => decorate(schemaFromIR(type.unknown.ir));
export const any = (): ZodLikeSchema<unknown> => decorate(schemaFromIR(type.unknown.ir));
const nullSchema = (): ZodLikeSchema<null> => decorate(type.raw("null") as unknown as Decoratable<null>);
const undefinedSchema = (): ZodLikeSchema<undefined> =>
	decorate(type.raw("undefined") as unknown as Decoratable<undefined>);

export { nullSchema as null, undefinedSchema as undefined };

/** Runtime `z.*` facade, merged with the `z.infer` type namespace below. */
export const z = {
	string,
	number,
	boolean,
	literal,
	enum: enumSchema,
	union,
	array,
	object,
	record,
	unknown,
	any,
	null: nullSchema,
	undefined: undefinedSchema,
};

export namespace z {
	export type infer<Schema> = Schema extends { readonly _output: infer Out } ? Out : never;
}