import type { Optional, StylesheetModel } from '../index.js'
import type { MergeInterfaces, Unformatted } from '../utils/value.js'
import { TypeDefinitions } from './definition.js'
import { Details } from './details.js'
import * as RuleMethods from './methods/rule.js'
import { Props } from './props.js'
import { isTypeInCategory, TypesByCategory, Category } from './definition.js'
import type { Type } from './type.js'

export type Rule<T extends Type = Type> = RuleByType[T]
export namespace Rule {
  export type Basic = Rule<Type.Basic>
  export type Aspect = Rule<Type.Aspect>
  export type Element = Rule<Type.Element>
  export type Concept = Rule<Type.Concept>
  export type ElementAspect<T extends Type.Element = Type.Element> = Rule<Type.ElementAspect<T>>
  export type ElementWithAspect<T extends Type.Aspect> = Rule<Type.ElementWithAspect<T>>
}
export namespace RuleCollection {
  export type Element<T extends Type.Element = Type.Element> = RuleWithProps<
    'collection',
    TypeDefinitions.collection.Props<T>
  >
}
export type RuleCollection<T extends Type = Type> = RuleWithProps<'collection', TypeDefinitions.collection.Props<T>>

export interface Empty {
  type: Type
}

export type RuleMerged<T extends Type> = RuleWithProps<T, Partial<MergeInterfaces<Props[T]>>>

export interface RuleWithProps<T, P> {
  type: T
  props: P
  details: Details
}

export type typeOf<R extends RuleWithProps<Type, any>> = R extends RuleWithProps<infer T extends Type, any> ? T : never
export type typesOf<R extends RuleWithProps<Type, any>[]> = R extends RuleWithProps<infer T extends Type, any>[]
  ? T
  : never

export type RuleByType = {
  [id in Type]: RuleWithProps<id, Props[id]>
}

export type AspectsByType<T extends Type.Element = Type.Element> = {
  [key in (typeof TypeDefinitions)[T]['aspects'][number]]: Rule<key>[]
}
export type AspectByType<T extends Type.Element = Type.Element> = {
  [key in (typeof TypeDefinitions)[T]['aspects'][number]]: Rule<key>
}

export function RuleConstructor<T extends Type>({
  type,
  details,
  props
}: {
  type: T
  details?: Unformatted<Optional<Details, 'title' | 'description' | 'id'>>
  props?: Unformatted<Props[T]>
}): Rule<T> {
  return {
    type,
    details: Details({
      exampleContent: type === 'text' || type === 'typography' ? 'Example' : null,
      ...details,
      title: type == 'font' && !details?.title ? (props as Props['font'])?.familyName : details?.title || ''
    }),
    props: TypeDefinitions[type] ? TypeDefinitions[type].Props(props) : props
  } as Rule<T>
}

export const RuleShortcuts = {
  fix<T extends Type>(style: Rule<T>, rules: Rule[]): Rule<T> {
    var { type, details, props } = style

    return Rule({
      type,
      details: {
        ...details,
        slug: details.slug || Rule.getSlug(style as Rule, rules)
      },
      props: Props.fix(type, props, rules)
    })
  },

  /** Ensure that basic shape of a style is correct  */
  isValid(rule: Rule) {
    return rule.type && rule.details.title && rule.details.id && rule.props
  },

  isInCategory<T extends Category>(style: Rule, category: T): style is Rule<TypesByCategory[T]> {
    return isTypeInCategory(style.type, category)
  },

  /** A constructor for newly created rules for a given collection. Assigns some default values */
  forCollection(collection: Rule<'collection'>) {
    const style = RuleConstructor({
      type: collection.props.type,
      details: {
        collectionId: collection.details.id
      }
    })

    if (style.type === 'color') {
      style.props = { red: 255, green: 255, blue: 255, alpha: 1 }
    }

    if (style.type === 'text' || style.type === 'inline' || style.type === 'block') {
      // @ts-ignore
      style.props = Object.keys(style.props).reduce((acc, prop) => {
        return { ...acc, [prop]: ['blank-' + prop.replace('Ids', '')] }
      }, {})
    }
    return style
  }
}

export type RuleError<T extends Rule = Rule> = Partial<{
  details?: Partial<T['details']>
  props?: { [key in keyof T['props']]: string }
}> | null

export const Rule = Object.assign(RuleConstructor, RuleMethods, RuleShortcuts)