import * as legacy from '../../../core/platform/custom-objects/fields';
import type {
  TextFieldDefinition,
  NumberFieldDefinition,
  RadioFieldDefinition,
} from '../../../core/platform/custom-objects/types';
import { defineComponent, type ComponentDefinition } from './component';
import { Field, type FieldProps } from '../field';
import {
  scopedDefinition,
  type ObjectScoped,
  manifestObject,
  manifestSection,
  trackFieldSection,
  fieldSectionReferences,
  type ObjectReference,
  type SectionReference,
} from './custom-object';

export type DefineFieldProps<TObject extends ObjectReference> = Omit<FieldProps, 'section'> & {
  section: SectionReference<NoInfer<TObject>>;
};

export function defineField<TObject extends ObjectReference>(
  object: TObject,
  props: DefineFieldProps<TObject>,
): ObjectScoped<TObject, Field> {
  const section = manifestSection(object, props.section);
  const field = scopedDefinition(
    object,
    trackFieldSection(new Field(manifestObject(object), { ...props, section }), section),
  );
  return fieldComponent.register(field, object, props);
}

/** Field factories for reusable definitions. Existing standalone factories remain available. */
export const fields: Readonly<
  Omit<typeof legacy, 'text' | 'number'> & { text: typeof text; number: typeof number; choice: typeof choice }
> = Object.freeze({ ...legacy, text, number, choice });

const fieldComponent: ComponentDefinition<typeof defineField> = defineComponent({
  type: 'CUSTOM_OBJECT_FIELD',
  define: defineField,
  references: (definition, object, props) => () => [
    object,
    ...fieldSectionReferences(definition),
    ...(props.summarySpec == null ?
      []
    : [
        props.summarySpec.aggregates,
        props.summarySpec.lookup,
        ...props.summarySpec.filters.map((filter) => filter.field),
      ]),
  ],
});

interface Presentation<TNullable extends boolean, TSection extends string | undefined = string | undefined> {
  label: string;
  description?: string;
  nullable?: TNullable;
  section?: TSection;
}

type Required<TNullable extends boolean> = TNullable extends true ? false : true;

type Rules<TNullable extends boolean> = { readonly nullable: TNullable };

function presentation<TNullable extends boolean, TSection extends string | undefined>(
  props: Presentation<TNullable, TSection>,
) {
  return {
    displayName: props.label,
    description: props.description ?? '',
    required: !props.nullable as Required<TNullable>,
    nullable: (props.nullable ?? false) as TNullable,
    ...(props.section !== undefined ? { section: props.section } : {}),
  };
}

function text<
  const TNullable extends boolean = false,
  const TSection extends string | undefined = string | undefined,
>(
  props: Presentation<TNullable, TSection> & { maxLength?: number; unique?: boolean },
): TextFieldDefinition<Required<TNullable>, TSection> & Rules<TNullable> {
  return legacy.text({ ...props, ...presentation(props) }) as TextFieldDefinition<
    Required<TNullable>,
    TSection
  > &
    Rules<TNullable>;
}

function number<
  const TNullable extends boolean = false,
  const TSection extends string | undefined = string | undefined,
>(
  props: Presentation<TNullable, TSection> & { decimalPlaces?: number },
): NumberFieldDefinition<Required<TNullable>, TSection> & Rules<TNullable> {
  return legacy.number({ ...props, ...presentation(props) }) as NumberFieldDefinition<
    Required<TNullable>,
    TSection
  > &
    Rules<TNullable>;
}

function choice<
  const TOptions extends readonly string[],
  const TNullable extends boolean = false,
  const TSection extends string | undefined = string | undefined,
>(
  props: Presentation<TNullable, TSection> & { options: TOptions },
): Omit<RadioFieldDefinition<Required<TNullable>, TSection>, '__valueType__'> & {
  readonly __valueType__?: TOptions[number];
} & Rules<TNullable> {
  return legacy.radio({ ...props, ...presentation(props) }) as Omit<
    RadioFieldDefinition<Required<TNullable>, TSection>,
    '__valueType__'
  > & { readonly __valueType__?: TOptions[number] } & Rules<TNullable>;
}