/**
 * Main types module for Reform
 * Exports all types used throughout the library
 */

import {
  Control,
  FieldPath,
  UseFormRegister,
  UseFormReturn,
  UseFormSetValue,
} from 'react-hook-form';
import { FormErrorsState } from './core/errors/state/types';
import { FormStateManager } from './core/form/form-state';
// import { FormValidation } from './core/validation/base/types';
import { FieldArrayHelpers } from './features/field-array/types';
import { ConditionalFieldsManager } from './features/conditional/types';
import {
  FieldConfig,
  ReformYupIntegration,
  ValidationConfig,
  YupSchemaConfig,
} from './core/validation';
// import { ReformGroupHandler, FormGroup } from "./core/groups/types";
import { FormGroup } from './core/form/form-groups';
import { Maybe, AnyObject } from 'yup';
import { ReformGroupHandler } from './typessss';

/**
 * Main return type for the useReform hook
 * Combines all functionality from various modules
 *
 * @template T - The type of form data
 */
export interface ReformReturn<T extends Record<string, any>>
  extends FormErrorsState,
    FormStateManager<T>,
    // FormHandlers<T>,
    // FormValidation<T>,
    ReformGroupHandler<T>,
    FieldArrayHelpers<T>,
    ConditionalFieldsManager<T> {
  /** React Hook Form methods */
  formMethods: UseFormReturn<{ groups: FormGroup<T>[] }>;

  /** Form configuration */
  config: DynamicFormConfig<T>;

  /** Yup integration utilities */
  yup: ReformYupIntegration<T>;

  /** Get all form groups */
  getGroups: () => FormGroup<T>[];

  /** Get data for a specific group */
  getGroupData: (index: number) => T | undefined;
}

// Utility Types
export type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

export type InferFormData<T> = T & Record<string, unknown>;

// Form Path Types
export type FormDataPath<T> = FieldPath<{ groups: FormGroup<T>[] }>;

// Form Control Types
export type FormControl<T> = Control<{
  groups: FormGroup<T>[];
}>;

// Form State Types
export interface FormState {
  isDirty: boolean;
  touched: boolean;
  submitCount: number;
  isSubmitting: boolean;
}

export interface YupIntegrationConfig<T extends Maybe<AnyObject>> {
  /**
   * Configuration for Yup integration
   */
  yupConfig?: Partial<YupSchemaConfig<T>>;
}

export type DynamicFormConfig<T extends AnyObject> = {
  value?: FormGroup<T>[];
  minGroups?: number;
  maxGroups?: number;
  defaultData?: Partial<T>;
  fields?: {
    [K in keyof T]: FieldConfig<T, K>;
  };
  onChange?: (groups: FormGroup<T>[]) => void;
} & ValidationConfig<T> &
  YupIntegrationConfig<T>;

export interface DynamicFormProps<T extends AnyObject>
  extends DynamicFormConfig<T> {
  disabled?: boolean;
  className?: string;
}

// Field Types
export type FieldKey<T> = keyof T;
export type FieldValue<T, K extends FieldKey<T>> = T[K];
export type FieldData<T> = T;
export type FieldErrorMessage = string;
export type FieldErrors = Record<FieldKey<any>, FieldErrorMessage>;

// Field State
export interface FieldState {
  isDirty: boolean;
  touched: boolean;
  initialValue: any;
}

// Field Render Props
export interface FieldRenderProps<T, K extends keyof T> {
  name: string;
  value: T[K];
  error?: string;
  group: FormGroup<T>;
  index: number;
  onChange: (value: T[K]) => void;
  register: UseFormRegister<{ groups: FormGroup<T>[] }>;
  setValue: UseFormSetValue<{ groups: FormGroup<T>[] }>;
  fieldPath: string;
}