import type * as S from 'sanity'
export type {
  Rule as RuleType,
  CustomValidator,
  SlugOptions,
  PreviewConfig,
  PortableTextBlock,
  SchemaValidationValue,
} from 'sanity'

// Utility types
export type ToggleProp<T> = T | false

export type FieldExtensions = {
  name?: string
  required?: boolean
}

export type BaseOmittedKeys = 'type' | 'name'
export type SchemaToolField<T> = Omit<T, BaseOmittedKeys | 'validation'> &
  FieldExtensions &
  S.FieldDefinitionBase & {
    validation?: S.SchemaValidationValue
  }

export type IntrinsicDefinitionsUnion = Partial<
  S.IntrinsicDefinitions[keyof S.IntrinsicDefinitions]
>

export type ValidationReturn = S.ValidationBuilder<S.RuleDef<any, any>, any>

// Base type
export type FieldProps = IntrinsicDefinitionsUnion &
  FieldExtensions &
  S.FieldDefinitionBase & {
    validation?: S.SchemaValidationValue
  }
export type FieldReturn = ReturnType<typeof S.defineField>

// Group type
export type GroupProps = Omit<S.FieldGroupDefinition, 'name'>
export type GroupReturn = S.FieldGroupDefinition

// Fieldset type
export type FieldsetProps = Omit<S.FieldsetDefinition, 'name'> & {
  collapsible?: boolean
  collapsed?: boolean
}
export type FieldsetReturn = S.FieldsetDefinition

// Preview type
export type PreviewPrepare = Pick<S.PreviewConfig, 'prepare'>
export type PreviewReturn = S.PreviewConfig
export type PreviewProps = PreviewPrepare & {
  title?: string
  media?: string
  [key: string]: string | undefined | PreviewPrepare['prepare']
}

export type LinkPreviewProps = S.PreviewConfig & {
  prefix?: string
}

// Default field types
export type ArrayField = SchemaToolField<S.ArrayDefinition>
export type BlockField = SchemaToolField<S.BlockDefinition>
export type BooleanField = SchemaToolField<S.BooleanDefinition>
export type DateField = SchemaToolField<S.DateDefinition>
export type DatetimeField = SchemaToolField<S.DatetimeDefinition>
export type DocumentField = SchemaToolField<S.DocumentDefinition>
export type EmailField = SchemaToolField<S.EmailDefinition>
export type FileField = SchemaToolField<S.FileDefinition>
export type GeopointField = SchemaToolField<S.GeopointDefinition>
export type ImageField = SchemaToolField<S.ImageDefinition>
export type NumberField = SchemaToolField<S.NumberDefinition>
export type ObjectField = SchemaToolField<S.ObjectDefinition>
export type ReferenceField = SchemaToolField<Omit<S.ReferenceDefinition, 'to'>>
export type SlugField = SchemaToolField<S.SlugDefinition>
export type StringField = SchemaToolField<S.StringDefinition>
export type TextField = SchemaToolField<S.TextDefinition>
export type UrlField = SchemaToolField<S.UrlDefinition>

// Custom field types
export type BlockContentField = Partial<ArrayField>
export type MultiReferenceField = Partial<ArrayField> & {
  options?: {
    types?: string[]
  }
}
export type CategoriesField = MultiReferenceField & {
  options?: {
    types?: string[]
  }
}
export type CategoryField = ReferenceField
export type CheckboxField = BooleanField
export type ExcerptField = TextField
export type FormField = Partial<ObjectField>
export type MessageField = StringField & {
  options?: {
    message?: string
  }
}
export type PublishedDateField = DateField
export type RadioField = StringField
export type RadioList = S.StringOptions['list']
export type SeoField = Omit<ObjectField, 'fields'>
export type TitleField = StringField

// Link field
export type LinkArgs = {
  condition?: RadioField
  url?: ToggleProp<StringField>
  page?: ToggleProp<ReferenceField>
  hasHash?: ToggleProp<CheckboxField>
  hash?: ToggleProp<StringField>
  file?: ToggleProp<FileField>
  video?: ToggleProp<FileField>
  label?: ToggleProp<StringField>
  linkStyle?: ToggleProp<RadioField>
  linkSize?: ToggleProp<RadioField>
  target?: ToggleProp<CheckboxField>
}

export type ConditionsType = {
  [key: string]: string | FieldProps[]
}

export type LinkField = Partial<ObjectField> & {
  types?: string[]
  args?: LinkArgs
  groups?: S.FieldGroupDefinition[]
  conditions?: ConditionsType
}

// Media field
export type MediaArgs = {
  image?: ToggleProp<ImageField>
  video?: ToggleProp<FileField>
  caption?: ToggleProp<StringField>
  ratio?: ToggleProp<StringField>
}

export type MediaField = Partial<ObjectField> & {
  args?: MediaArgs
  conditions?: ConditionsType
}

// Hero field
export type HeroArgs = {
  label?: ToggleProp<StringField>
  heading?: ToggleProp<StringField>
  content?: ToggleProp<BlockContentField>
  link?: ToggleProp<LinkField>
  media?: ToggleProp<MediaField>
  align?: ToggleProp<RadioField>
}

export type HeroField = Partial<ObjectField> & {
  args?: HeroArgs
}

// Content group field
export type ContentGroupField = {
  label?: ToggleProp<StringField>
  heading?: ToggleProp<StringField>
  content?: ToggleProp<BlockContentField>
  link?: ToggleProp<LinkField>
}

export type FieldDefaults = {
  fieldset?: string
  title?: TitleField
  slug?: SlugField
  path?: StringField
}

// Config type
export interface CofigurableFieldTypes {
  array: ArrayField
  block: BlockField
  blockContent: BlockContentField
  boolean: BooleanField
  categories: CategoriesField
  category: CategoryField
  checkbox: CheckboxField
  contentGroup: ContentGroupField
  date: DateField
  datetime: DatetimeField
  document: DocumentField
  email: EmailField
  excerpt: ExcerptField
  file: FileField
  formField: FormField
  geopoint: GeopointField
  hero: HeroField
  image: ImageField
  link: LinkField
  media: MediaField
  message: MessageField
  multiReference: MultiReferenceField
  number: NumberField
  object: ObjectField
  publishedDate: PublishedDateField
  radio: RadioField
  reference: ReferenceField
  seo: SeoField
  slug: SlugField
  string: StringField
  text: TextField
  title: TitleField
  url: UrlField
}

export type ConfigType = {
  [K in keyof CofigurableFieldTypes]?: Partial<CofigurableFieldTypes[K]>
}

export type CustomFieldType = (...args: any[]) => FieldReturn | FieldReturn[]
export type CustomFieldsetType = (...args: any[]) => FieldsetReturn | FieldsetReturn[]
export type CustomGroupType = (...args: any[]) => GroupReturn | GroupReturn[]
export type CustomPreviewType = (...args: any[]) => PreviewReturn

export interface CustomTypes {
  F?: {
    [key: string]: CustomFieldType
  }
  FS?: {
    [key: string]: CustomFieldsetType
  }
  G?: {
    [key: string]: CustomGroupType
  }
  P?: {
    [key: string]: CustomPreviewType
  }
  V?: {
    [key: string]: any // TODO: Improve typing. Validation types are confusing
  }
}