/** Fluent JSON Schema builders following the classic Workers schema-builder API. */
const SCHEMA: unique symbol = Symbol("schema");
const KIND: unique symbol = Symbol("kind");
declare const VALUE: unique symbol;

export type StringFormat =
	| "date-time"
	| "date"
	| "time"
	| "duration"
	| "email"
	| "hostname"
	| "ipv4"
	| "ipv6"
	| "uuid";

type Kind = "object" | "value";
type JsonSchema = {
	title?: string;
	description?: string;
} & (
	| {
			type: "string" | "number" | "integer" | "boolean" | "null";
			enum?: readonly (string | number)[];
			format?: StringFormat;
	  }
	| { type: "array"; items: JsonSchema; minItems?: 0 | 1 }
	| {
			type: "object";
			properties: Record<string, JsonSchema>;
			required: string[];
			additionalProperties: false;
	  }
	| { anyOf: JsonSchema[] }
);

export interface SchemaBuilder<T, K extends Kind = Kind> {
	readonly [SCHEMA]: JsonSchema;
	readonly [KIND]: K;
	readonly [VALUE]?: T;
	describe(text: string): SchemaBuilder<T, K>;
	label(text: string): SchemaBuilder<T, K>;
	nullable(): SchemaBuilder<T | null, "value">;
}

export type Infer<S> = S extends SchemaBuilder<infer T> ? T : never;

/** Returns a copy so callers cannot mutate the builder's validation contract. */
export function getSchema(builder: SchemaBuilder<unknown>): JsonSchema {
	if (typeof builder !== "object" || builder === null || !(SCHEMA in builder)) {
		throw new Error("Expected a schema builder; use j.object() for manual inputs");
	}
	return structuredClone(builder[SCHEMA]);
}

function makeBuilder<T, K extends Kind>(schema: JsonSchema, kind: K): SchemaBuilder<T, K> {
	return {
		[SCHEMA]: schema,
		[KIND]: kind,
		describe(description) {
			return makeBuilder<T, K>({ ...schema, description }, kind);
		},
		label(title) {
			return makeBuilder<T, K>({ ...schema, title }, kind);
		},
		nullable() {
			const { title, description, ...inner } = schema;
			return makeBuilder<T | null, "value">(
				{
					anyOf: [inner, { type: "null" }],
					...(title === undefined ? {} : { title }),
					...(description === undefined ? {} : { description }),
				},
				"value",
			);
		},
	};
}

function string(): SchemaBuilder<string, "value"> {
	return makeBuilder({ type: "string" }, "value");
}
function formattedString(format: StringFormat): SchemaBuilder<string, "value"> {
	return makeBuilder({ type: "string", format }, "value");
}

function number(): SchemaBuilder<number, "value"> {
	return makeBuilder({ type: "number" }, "value");
}
function integer(): SchemaBuilder<number, "value"> {
	return makeBuilder({ type: "integer" }, "value");
}
function boolean(): SchemaBuilder<boolean, "value"> {
	return makeBuilder({ type: "boolean" }, "value");
}

function enumBuilder<const T extends string>(first: T, ...rest: T[]): SchemaBuilder<T, "value">;
function enumBuilder<const T extends number>(first: T, ...rest: T[]): SchemaBuilder<T, "value">;
function enumBuilder(
	first: string | number,
	...rest: (string | number)[]
): SchemaBuilder<string | number, "value"> {
	return makeBuilder(
		{ type: typeof first === "string" ? "string" : "number", enum: [first, ...rest] },
		"value",
	);
}

function array<T>(
	items: SchemaBuilder<T>,
	options?: { minItems?: 0 | 1 },
): SchemaBuilder<T[], "value"> {
	return makeBuilder({ type: "array", items: getSchema(items), ...options }, "value");
}

function object<P extends Record<string, SchemaBuilder<unknown>>>(
	properties: P,
): SchemaBuilder<{ -readonly [K in keyof P]: Infer<P[K]> }, "object"> {
	return makeBuilder(
		{
			type: "object",
			properties: Object.fromEntries(
				Object.entries(properties).map(([key, value]) => [key, getSchema(value)]),
			),
			required: Object.keys(properties),
			additionalProperties: false,
		},
		"object",
	);
}

export const j = {
	string,
	number,
	integer,
	boolean,
	enum: enumBuilder,
	array,
	object,
	datetime: () => formattedString("date-time"),
	date: () => formattedString("date"),
	time: () => formattedString("time"),
	duration: () => formattedString("duration"),
	email: () => formattedString("email"),
	hostname: () => formattedString("hostname"),
	ipv4: () => formattedString("ipv4"),
	ipv6: () => formattedString("ipv6"),
	uuid: () => formattedString("uuid"),
};