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

const catalog = ril.create()
  .component('email', {
    description: 'Email input',
    propsSchema: z.object({ label: z.string() }),
    renderer: (ctx) => (
      <input
        aria-label={ctx.props.label}
        value={String(ctx.field?.value ?? '')}
        onChange={(e) => ctx.field?.onChange(e.target.value)}
        onBlur={ctx.field?.onBlur}
      />
    ),
  })
  .tool('lookup_company', {
    description: 'Fetch company data by SIREN',
    inputSchema: z.object({ siren: z.string() }),
  })
  .part('text', { renderer: ({ part }) => <p>{(part as { text: string }).text}</p> });

interface ComponentRenderContext<TProps = Record<string, unknown>> {
  readonly id: string;
  readonly props: TProps;
  readonly field?: FieldBinding;       // value, onChange, onBlur, error?, disabled?, isValidating?, touched?
  readonly conditions?: FieldConditions; // visible, disabled, required, readonly
  readonly children?: React.ReactNode;
  readonly meta?: Record<string, unknown>;
}

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

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

when('role').equals('admin').or(when('permissions').contains('write'))
when('address.country').equals('FR')   // nested paths work

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

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

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

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

<Form of={contactForm} defaults={{ email: '' }} onSubmit={save}>
  <Form.Body />
  <Form.Submit />
</Form>

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

const contact = form.create(catalog, 'contact')     // formId optional
  .add({ id: 'email', type: 'email', props: { label: 'Email' } })
  .add(   // multiple fields in one call = one row
    { id: 'firstName', type: 'input', props: { label: 'First' } },
    { id: 'lastName', type: 'input', props: { label: 'Last' } },
  )
  .setValidation({
    mode: 'onTouched',          // when a field FIRST validates (default)
    reValidateMode: 'onChange', // re-validation after an error (default)
    validate: z.object({ password: z.string().min(8), confirmPassword: z.string() })
      .refine((d) => d.password === d.confirmPassword, {
        message: "Passwords don't match",
        path: ['confirmPassword'],   // routed to that field's errors
      }),
  });

import { compileForm, fromSchema, validateSchema, isFormSchema } from '@rilaykit/forms';

const { formConfig, defaultValues } = compileForm(schema, catalog, { bindings });

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

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

// rules: 'required' | 'email' | 'url' | 'number'  (shortcuts)
//        or { type: string; message?: string; params?: Record<string, unknown> }

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

import { Flow } from '@rilaykit/workflow/react';

<Flow of={onboarding} defaults={{ name: '' }} onComplete={(data, meta) => save(data, meta)}>
  <Flow.Progress />
  <Flow.Body />
  <Flow.Back />
  <Flow.Skip />
  <Flow.Next />
</Flow>

import { flow } from '@rilaykit/workflow';

const onboarding = flow.create(catalog, 'onboarding', 'User Onboarding')
  .step({
    id: 'basics',
    title: 'Basics',
    formConfig: basicsForm,
    after: async (step) => {
      const company = await fetchCompany(step.data.siren);
      step.next.prefill({ companyName: company.name });
    },
  })
  .step([
    { title: 'Company', formConfig: companyForm },
    { title: 'Review', formConfig: reviewForm, allowSkip: true },
  ]);

import { compileFlow, validateFlowSchema, isFlowSchema } from '@rilaykit/workflow';

const { workflowConfig } = compileFlow(schema, catalog, { bindings });

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

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

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

interface FieldValidationConfig<T = any> {
  readonly validate?: StandardSchema<T> | StandardSchema<T>[];
  readonly debounceMs?: number; // async cost control; blur/submit validate immediately
}

type FormValidationMode = 'onSubmit' | 'onBlur' | 'onChange' | 'onTouched' | 'all';
type FormReValidateMode = 'onChange' | 'onBlur' | 'onSubmit';

interface FormValidationConfig<T extends Record<string, any> = Record<string, any>> {
  readonly validate?: StandardSchema<T> | StandardSchema<T>[];
  readonly mode?: FormValidationMode;           // default 'onTouched'
  readonly reValidateMode?: FormReValidateMode; // default 'onChange'
  readonly validateOnStepChange?: boolean;
}

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

type ConditionValue =
  | string | number | boolean | null | undefined
  | RegExp | 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 WorkflowCompletionMeta {
  readonly visitedSteps: string[];
  readonly skippedSteps: string[];
  readonly passedSteps: string[];
}

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[];
}