import { ril } from '@rilaykit/core';

const rilay = ril.create();

const rilay = ril.create()
  .addComponent('input', {
    name: 'Text Input',
    renderer: InputRenderer,
    defaultProps: { placeholder: 'Enter text...' },
  })
  .addComponent('email', {
    name: 'Email Input',
    renderer: EmailRenderer,
    validation: {
      validate: email(),
      validateOnBlur: true,
    },
  });

const rilay = ril.create()
  .addComponent('input', { name: 'Input', renderer: InputRenderer })
  .configure({
    rowRenderer: CustomRowRenderer,
    bodyRenderer: CustomBodyRenderer,
    submitButtonRenderer: CustomSubmitButton,
    fieldRenderer: CustomFieldRenderer,
    stepperRenderer: CustomStepper,
    nextButtonRenderer: CustomNextButton,
    previousButtonRenderer: CustomPreviousButton,
    skipButtonRenderer: CustomSkipButton,
  });

const config = rilay.getComponent('input');

interface AsyncValidationResult {
  isValid: boolean;
  errors: string[];
  warnings?: string[];
}

const stats = rilay.getStats();
// {
//   total: number;
//   byType: Record<string, number>;
//   hasCustomRenderers: {
//     row: boolean;
//     body: boolean;
//     submitButton: boolean;
//     field: boolean;
//     stepper: boolean;
//     workflowNextButton: boolean;
//     workflowPreviousButton: boolean;
//     workflowSkipButton: boolean;
//   };
// }

interface ComponentRenderProps<T = any> {
  id: string;
  props: T;
  value?: any;
  onChange?: (value: any) => void;
  onBlur?: () => void;
  disabled?: boolean;
  error?: ValidationError[];
  isValidating?: boolean;
  [key: string]: any;
}

type ComponentRenderer<T = any> = (
  props: ComponentRenderProps<T>
) => React.ReactElement;

import {
  required, email, url, minLength, maxLength,
  pattern, number, min, max, custom, async, combine,
} from '@rilaykit/core';

import { when } from '@rilaykit/core';

const condition = when('accountType').equals('business');

// Boolean check
when('isVerified').equals(true)

// Combining conditions
when('role').equals('admin')
  .or(when('permissions').contains('write'))

// Nested field paths
when('address.country').equals('FR')

import { onChange } from '@rilaykit/core';

onChange('country', async (value, { setValue, setProps }) => {
  setValue('city', '');
  setProps('city', { options: await fetchCities(value) });
});

interface FieldEffectContext {
  readonly setValue: (fieldId: string, value: unknown) => void;
  readonly setProps: (fieldId: string, props: Record<string, unknown>) => void;
  readonly getValues: () => Record<string, unknown>;
  readonly getFieldValue: (fieldId: string) => unknown;
}

type FieldEffectHandler = (
  newValue: unknown,
  context: FieldEffectContext
) => void | Promise<void>;

interface FieldEffect {
  readonly trigger: 'change';
  readonly watchFieldId: string;
  readonly handler: FieldEffectHandler;
}

type FieldEffects = readonly FieldEffect[];

import { RilayError, ValidationError, DuplicateIdError } from '@rilaykit/core';

import { Form } from '@rilaykit/forms';

<Form
  formConfig={myForm}
  onSubmit={handleSubmit}
  defaultValues={{ name: '', email: '' }}
  onFieldChange={(fieldId, value, formData) => {}}
  className="my-form"
>
  {children}
</Form>

<Form formConfig={myForm} onSubmit={handleSubmit}>
  <FormBody />
</Form>

<FormField fieldId="email" disabled={false} className="mb-4" />

// Single field -- own row
builder.add({ id: 'name', type: 'input', props: { label: 'Name' } });

// Multiple fields -- same row
builder.add(
  { id: 'firstName', type: 'input', props: { label: 'First' } },
  { id: 'lastName', type: 'input', props: { label: 'Last' } },
);

// Array syntax -- explicit single row
builder.add([
  { id: 'email', type: 'email', props: { label: 'Email' } },
  { id: 'phone', type: 'phone', props: { label: 'Phone' } },
]);

// Field with effects
builder.add({
  id: 'country',
  type: 'select',
  props: { label: 'Country' },
  effects: [
    onChange('country', async (value, { setValue, setProps }) => {
      setValue('city', '');
      setProps('city', { options: await fetchCities(value) });
    })
  ],
});

// Many fields -- all in one row
builder.add(field1, field2, field3, field4);

builder.addSeparateRows([
  { type: 'input', props: { label: 'Field 1' } },
  { type: 'input', props: { label: 'Field 2' } },
]);

builder.setValidation({
  validate: z.object({
    password: z.string().min(8),
    confirmPassword: z.string(),
  }).refine(data => data.password === data.confirmPassword, {
    message: "Passwords don't match",
    path: ['confirmPassword'],
  }),
  validateOnSubmit: true,
});

builder.addFieldConditions('phone', {
  visible: when('contactMethod').equals('phone').build(),
  required: when('contactMethod').equals('phone').build(),
});

builder.updateField('email', {
  props: { placeholder: 'Enter your email' },
});

const stats = builder.getStats();
// { totalFields, totalRows, averageFieldsPerRow, maxFieldsInRow, minFieldsInRow }

interface FieldState {
  value: unknown;
  errors: ValidationError[];
  validationState: ValidationState; // 'idle' | 'validating' | 'valid' | 'invalid'
  touched: boolean;
  dirty: boolean;
}

interface FieldConditions {
  visible: boolean;
  disabled: boolean;
  required: boolean;
  readonly: boolean;
}

interface UseFieldActionsResult {
  setValue: (value: unknown) => void;
  setTouched: () => void;
  setErrors: (errors: ValidationError[]) => void;
  clearErrors: () => void;
  setValidationState: (state: ValidationState) => void;
}

interface UseFormActionsResult {
  setValue: (fieldId: string, value: unknown) => void;
  setTouched: (fieldId: string) => void;
  setErrors: (fieldId: string, errors: ValidationError[]) => void;
  setSubmitting: (isSubmitting: boolean) => void;
  reset: (values?: Record<string, unknown>) => void;
  setFieldConditions: (fieldId: string, conditions: FieldConditions) => void;
}

interface FormConfigContextValue {
  formConfig: FormConfiguration;
  conditionsHelpers: { hasConditionalFields, getFieldCondition, isFieldVisible, isFieldDisabled, isFieldRequired, isFieldReadonly };
  validateField: (fieldId: string, value?: unknown) => Promise<ValidationResult>;
  validateForm: () => Promise<ValidationResult>;
  submit: (event?: React.FormEvent) => Promise<boolean>;
}

import { fromSchema } from '@rilaykit/forms';
import type { FormSchema, SchemaRegistry } from '@rilaykit/forms';

const { formConfig, defaultValues } = fromSchema(schema, rilConfig, registry);

interface FormSchemaResult<C extends Record<string, any>> {
  readonly formConfig: FormConfiguration<C>;
  readonly defaultValues?: Record<string, unknown>;
}

import { validateSchema } from '@rilaykit/forms';

validateSchema(schema, rilConfig, registry); // throws on error

import { isFormSchema } from '@rilaykit/forms';

if (isFormSchema(data)) {
  const { formConfig } = fromSchema(data, rilConfig);
}

interface FormSchema {
  readonly version?: 1;
  readonly id: string;
  readonly defaultValues?: Record<string, unknown>;
  readonly fields?: FormSchemaField[];       // flat layout
  readonly rows?: FormSchemaRow[];           // row-based layout
  readonly validation?: FormSchemaValidationConfig;
  readonly submitOptions?: SubmitOptions;
}

interface FormSchemaField {
  readonly id: string;
  readonly type: string;
  readonly props?: Record<string, unknown>;
  readonly validation?: FieldSchemaValidation;
  readonly conditions?: ConditionalBehavior;
  readonly effects?: FieldSchemaEffect[];
}

interface FieldSchemaValidation {
  readonly rules?: ValidationDescriptor | ValidationDescriptor[];
  readonly validateOnChange?: boolean;
  readonly validateOnBlur?: boolean;
  readonly debounceMs?: number;
}

type ValidationDescriptor = ValidationShortcut | ValidationDescriptorObject;
type ValidationShortcut = 'required' | 'email' | 'url' | 'number';

interface ValidationDescriptorObject {
  readonly type: string;
  readonly message?: string;
  readonly params?: Record<string, unknown>;
}

interface SchemaRegistry {
  readonly validators?: Record<string, CustomValidatorFactory>;
  readonly effects?: Record<string, SchemaEffectHandler>;
}

type CustomValidatorFactory = (
  params?: Record<string, unknown>,
  message?: string
) => StandardSchema;

type SchemaEffectHandler = (
  newValue: unknown,
  context: FieldEffectContext,
  params?: Record<string, unknown>
) => void | Promise<void>;

class SchemaValidationError extends Error {
  readonly code = 'SCHEMA_VALIDATION_ERROR';
  readonly issues: SchemaIssue[];
}

interface SchemaIssue {
  readonly path: string;
  readonly message: string;
  readonly severity: 'error' | 'warning';
}

import { Workflow, WorkflowBody, WorkflowStepper, WorkflowNextButton } from '@rilaykit/workflow';

<Workflow
  workflowConfig={myWorkflow}
  defaultValues={{ name: '' }}
  defaultStep="step-1"
  onStepChange={(from, to, context) => {}}
  onWorkflowComplete={(data) => {}}
  className="my-workflow"
>
  <WorkflowStepper />
  <WorkflowBody />
  <WorkflowNextButton />
</Workflow>

workflow
  .step({
    id: 'personal-info',
    title: 'Personal Information',
    formConfig: personalForm,
    allowSkip: false,
    metadata: { icon: 'user' },
    onAfterValidation: async (stepData, helper, context) => {
      const company = await fetchCompany(stepData.siren);
      helper.setNextStepFields({ companyName: company.name });
    },
  })
  .step([
    { title: 'Step 2', formConfig: form2 },
    { title: 'Step 3', formConfig: form3, allowSkip: true },
  ]);

interface StepDefinition {
  id?: string;                    // Auto-generated if omitted
  title: string;
  description?: string;
  formConfig: FormConfiguration | form;  // Builder is auto-built
  allowSkip?: boolean;
  conditions?: StepConditionalBehavior;
  metadata?: Record<string, any>;
  onAfterValidation?: (
    stepData: Record<string, any>,
    helper: StepDataHelper,
    context: WorkflowContext,
  ) => void | Promise<void>;
}

workflow.configure({
  analytics: {
    onWorkflowStart: (id, context) => {},
    onStepComplete: (id, duration, data, context) => {},
  },
  persistence: {
    adapter: localStorageAdapter,
    options: { autoPersist: true },
    userId: 'user-123',
  },
});

workflow.use(myPlugin);

workflow.stepConditions('payment', {
  visible: when('hasPayment').equals(true).build(),
  skippable: when('balance').equals(0).build(),
});

const stats = workflow.getStats();
// {
//   totalSteps, totalFields, averageFieldsPerStep,
//   maxFieldsInStep, minFieldsInStep, hasAnalytics
// }

interface UseWorkflowActionsResult {
  setCurrentStep: (stepIndex: number) => void;
  setStepData: (data: Record<string, unknown>, stepId: string) => void;
  setAllData: (data: Record<string, unknown>) => void;
  setFieldValue: (fieldId: string, value: unknown, stepId: string) => void;
  setSubmitting: (isSubmitting: boolean) => void;
  setTransitioning: (isTransitioning: boolean) => void;
  setInitializing: (isInitializing: boolean) => void;
  markStepVisited: (stepId: string) => void;
  markStepPassed: (stepId: string) => void;
  reset: () => void;
  loadPersistedState: (state: Partial<WorkflowStoreState>) => void;
}

interface UseStepMetadataReturn {
  current: Record<string, any> | undefined;
  getByStepId: (stepId: string) => Record<string, any> | undefined;
  getByStepIndex: (stepIndex: number) => Record<string, any> | undefined;
  hasCurrentKey: (key: string) => boolean;
  getCurrentValue: <T>(key: string, defaultValue?: T) => T;
  getAllStepsMetadata: () => Array<{ id, title, index, metadata }>;
  findStepsByMetadata: (predicate) => string[];
}

interface ValidationResult {
  readonly isValid: boolean;
  readonly errors: ValidationError[];
  readonly value?: any;
}

interface ValidationError {
  readonly message: string;
  readonly code?: string;
  readonly path?: string;
}

type ValidationState = 'idle' | 'validating' | 'valid' | 'invalid';

interface FieldValidationConfig<T = any> {
  readonly validate?: StandardSchemaV1<T> | StandardSchemaV1<T>[];
  readonly validateOnChange?: boolean;
  readonly validateOnBlur?: boolean;
  readonly debounceMs?: number;
}

interface FormValidationConfig<T extends Record<string, any> = Record<string, any>> {
  readonly validate?: StandardSchemaV1<T> | StandardSchemaV1<T>[];
  readonly validateOnSubmit?: boolean;
  readonly validateOnStepChange?: boolean;
}

interface ConditionConfig {
  field: string;
  operator: ConditionOperator;
  value?: ConditionValue;
  conditions?: ConditionConfig[];
  logicalOperator?: 'and' | 'or';
}

type ConditionOperator =
  | 'equals' | 'notEquals'
  | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual'
  | 'contains' | 'notContains'
  | 'in' | 'notIn'
  | 'matches'
  | 'exists' | 'notExists';

type ConditionValue = string | number | boolean | null | undefined | Array<string | number | boolean>;

interface ConditionalBehavior {
  readonly visible?: ConditionConfig;
  readonly disabled?: ConditionConfig;
  readonly required?: ConditionConfig;
  readonly readonly?: ConditionConfig;
}

interface StepConditionalBehavior {
  readonly visible?: ConditionConfig;
  readonly skippable?: ConditionConfig;
}

interface FieldConditions {
  readonly visible: boolean;
  readonly disabled: boolean;
  readonly required: boolean;
  readonly readonly: boolean;
}

interface FieldState {
  readonly value: unknown;
  readonly errors: ValidationError[];
  readonly validationState: ValidationState;
  readonly touched: boolean;
  readonly dirty: boolean;
}

interface WorkflowAnalytics {
  readonly onWorkflowStart?: (workflowId: string, context: WorkflowContext) => void;
  readonly onWorkflowComplete?: (workflowId: string, duration: number, data: any) => void;
  readonly onWorkflowAbandon?: (workflowId: string, currentStep: string, data: any) => void;
  readonly onStepStart?: (stepId: string, timestamp: number, context: WorkflowContext) => void;
  readonly onStepComplete?: (stepId: string, duration: number, data: any, context: WorkflowContext) => void;
  readonly onStepSkip?: (stepId: string, reason: string, context: WorkflowContext) => void;
  readonly onError?: (error: Error, context: WorkflowContext) => void;
}

interface WorkflowPlugin {
  readonly name: string;
  readonly version?: string;
  readonly install: (workflow: any) => void;
  readonly dependencies?: string[];
}

interface MonitoringConfig {
  readonly enabled: boolean;
  readonly enablePerformanceTracking?: boolean;
  readonly enableErrorTracking?: boolean;
  readonly enableMemoryTracking?: boolean;
  readonly performanceThresholds?: PerformanceThresholds;
  readonly sampleRate?: number;
  readonly bufferSize?: number;
  readonly flushInterval?: number;
  readonly onEvent?: (event: MonitoringEvent) => void;
  readonly onBatch?: (events: MonitoringEvent[]) => void;
  readonly onError?: (error: Error) => void;
}