/**
 * Schema field types used by DataTable, DataPreview, useSchemaField and elementUtils.
 * (The BagelForm form-rendering system was removed — use FormFlow with defineSchema.)
 */
import type { Paths, Get, OmitIndexSignature } from 'type-fest'
import type { ToString } from 'type-fest/source/internal'
import type { LiteralStringUnion } from 'type-fest/source/literal-union'
import type { PathsOptions, DefaultPathsOptions } from 'type-fest/source/paths'
import type { VNode } from 'vue'

// BagelInputShellProps is exported from components/form/inputs/bagelInputShell.ts
// Do not re-export here to avoid duplicate export in src/index.ts
import type { BagelInputShellProps } from '../components/form/inputs/bagelInputShell'

interface Option { label: string, value: any }

// ---------- Path resolution ----------

export type _Path<
	T,
	PO extends PathsOptions = DefaultPathsOptions,
> = ToString<Paths<OmitIndexSignature<T>, PO>>

// Helper type to get paths for index signature properties
type IndexSignaturePaths<T> = {
	[K in keyof T]: T[K] extends { [key: string]: any }
		? `${K & string}.${string}`
		: never
}[keyof T]

// Enhanced Path type that allows flexibility for nested open-ended objects
export type Path<T, PO extends PathsOptions = DefaultPathsOptions>
	= FieldVal<T, _Path<T, PO>> extends Array<any>
		? LiteralStringUnion<_Path<T, PO>>
		: _Path<T, PO> | IndexSignaturePaths<T> | `${keyof T & string}.more_info.${string}`

/** The value type at path P in object T. Falls back to unknown if resolution fails. */
export type FieldVal<T, P extends Path<T>>
	= unknown extends Get<T, P> ? unknown : Get<T, P>

/** Field value type that preserves type information when possible. */
export type SmartFieldVal<T, P extends Path<T>>
	= P extends string
		? P extends keyof T
			? T[P]
			: any
		: FieldVal<T, P>

// ---------- Field callbacks & attributes ----------

export type AttributeValue
	= | string
		| number
		| boolean
		| undefined
		| { [key: string]: any }

export type AttributeFn<T, P extends Path<T>> = (
	field: SmartFieldVal<T, P>,
	row?: T
) => AttributeValue

export interface Attributes<T, P extends Path<T>> {
	[key: string]: AttributeValue | AttributeFn<T, P>
}

export type FieldOptions<T, P extends Path<T>>
	= | string
		| (
			| {
				label?: string
				value: string | number
			}
			| string
			| number
			| boolean
			| { [key: string]: any }
		)[]
		| ((val?: SmartFieldVal<T, P>, rowData?: T) => Option[] | ((query: string) => Promise<Option[]>))
		| ((query: string, val?: SmartFieldVal<T, P>, rowData?: T) => Promise<Option[]>)

export type VIfType<T, P extends Path<T>>
	= | string
		| boolean
		| ((val?: SmartFieldVal<T, P>, rowData?: T) => boolean)

export type ValidationFn<T, P extends Path<T>> = (
	val?: SmartFieldVal<T, P>,
	rowData?: T
) => string | undefined

export type TransformFn<T, P extends Path<T>> = (
	val?: SmartFieldVal<T, P>,
	rowData?: T
) => any

export type UpdateFn<T, P extends Path<T>> = (
	val?: SmartFieldVal<T, P>,
	rowData?: T
) => unknown

// ---------- Schema fields ----------

export type VNodeFn<T, P extends Path<T>> = (props: {
	row?: T
	field: BaseBagelField<T, P>
}) => VNode

export interface ElementField<
	T,
	PO extends PathsOptions = DefaultPathsOptions,
> {
	$el: any
	id?: Path<T, PO> | string
	class?: any
	vIf?: any
	style?: Record<string, any>
	attrs?: Record<string, any>
	onClick?: (val?: any, rowData?: T) => void
	transform?: (val?: any, rowData?: T) => any
	children?: ElementField<T, PO>[]
}

// Helper type to extract all possible BaseBagelField types for valid paths
type ValidBaseBagelField<T, PO extends PathsOptions = DefaultPathsOptions> = {
	[P in Path<T, PO>]: BaseBagelField<T, P, PO>
}[Path<T, PO>]

export type SchemaChild<
	T,
	P extends Path<T, PO>,
	PO extends PathsOptions = DefaultPathsOptions,
> = Field<T, PO> | ElementField<T, PO> | VNode | VNodeFn<T, P> | string | ValidBaseBagelField<T, PO>

export interface BaseBagelField<
	T,
	P extends Path<T, PO>,
	PO extends PathsOptions = DefaultPathsOptions,
> {
	'$el'?: string | any
	'id'?: P
	'label'?: string
	'placeholder'?: string
	'class'?: AttributeValue | AttributeFn<T, P>
	'attrs'?: Attributes<T, P>
	'required'?: boolean
	'disabled'?: boolean
	'helptext'?: string
	'options'?: FieldOptions<T, P>
	'children'?: SchemaChild<T, Path<T, PO>, PO>[]
	'slots'?: { [key: string]: SchemaChild<T, Path<T, PO>, PO>[] }
	'defaultValue'?: any
	'vIf'?: VIfType<T, P>
	'v-if'?: VIfType<T, P>
	'transform'?: TransformFn<T, P>
	'onUpdate'?: UpdateFn<T, P>
	'validate'?: ValidationFn<T, P>
}

export type Field<
	T,
	PO extends PathsOptions = DefaultPathsOptions,
> = ValidBaseBagelField<T, PO>

export type SchemaField<
	T,
	PO extends PathsOptions = DefaultPathsOptions,
> = Field<T, PO> | ElementField<T, PO>

export type BglFormSchemaT<
	T,
	PO extends PathsOptions = DefaultPathsOptions,
> = (SchemaField<T, PO> | BaseBagelField<T, Path<T, PO>, PO>)[]

// ---------- Input component contracts ----------

export interface ValidateInputBaseT {
	validate?: ValidationFn<{ [key: string]: unknown }, string>
	getFormData?: () => any
}

export interface UploadInputProps extends BagelInputShellProps {
	id?: string
	name?: string
	label?: string
	multiple?: boolean
	modelValue?: string | string[]
	width?: string
	height?: string | 'auto'
	dirPath?: string
	fill?: boolean
	oval?: boolean
	theme?: 'dropzone' | 'basic'
	accept?: string
	capture?: boolean | 'user' | 'environment'
	required?: boolean
	disabled?: boolean
	baseURL?: string
	placeholder?: string
	/** Alias for dropzone placeholder text (same as `placeholder` when theme is dropzone). */
	dropPlaceholder?: string
	noFilePlaceholder?: string
	btnPlaceholder?: string
	error?: string
	showIcon?: boolean
	icon?: string
	iconSize?: number | string
	iconMobileSize?: number | string
}