import defu from "defu"
import { row } from "./builtin/row"
import { readModifier, type CordoModifier } from "./modifier"
import type { AllowedComponents as ContainerAllowedComponents } from "./builtin/container"
import type { AllowedComponents as ModalAllowedComponents } from "./builtin/modal"


const CordoComponentSymbol = Symbol.for('CordoComponent')

export const ComponentType = {
  ActionRow: 1,
  Button: 2,
  StringSelect: 3,
  TextInput: 4,
  UserSelect: 5,
  RoleSelect: 6,
  MentionableSelect: 7,
  ChannelSelect: 8,
  Section: 9,
  TextDisplay: 10,
  Thumbnail: 11,
  MediaGallery: 12,
  File: 13,
  Seperator: 14,
  Container: 17,
  Label: 18,
  FileUpload: 19,
  RadioGroup: 21,
  CheckboxGroup: 22,
  Checkbox: 23,

  Modal: -1, // This is a special type that is not used in the API, but for Cordo's internal use
} as const
export type StringComponentType = keyof typeof ComponentType
export type ComponentIdFromName<Name extends StringComponentType> = typeof ComponentType[Name]

export type CordoComponent<Type extends StringComponentType = StringComponentType> = {
  [CordoComponentSymbol]: {
    nativeName: Type
    nativeType: typeof ComponentType[Type]
    visible: boolean
    attributes: Record<string, any>
    render: (meta: {
      hirarchy: Array<StringComponentType>
      attributes: Record<string, any>
    }) => Record<string, any> | null
  }
  visible: (value: boolean) => CordoComponent<Type>
  attributes: (attrs: Record<string, any>) => CordoComponent<Type>
} & (
  Type extends 'Container'
    ? { [Symbol.iterator]: () => Iterator<ContainerAllowedComponents> }
    : Type extends 'Modal'
      ? { [Symbol.iterator]: () => Iterator<ModalAllowedComponents> }
      : { [Symbol.iterator]: never }
)
export type CordoComponentPayload<Type extends StringComponentType> = CordoComponent<Type>[typeof CordoComponentSymbol]

export function createComponent<Type extends StringComponentType>(
  type: Type,
  render: CordoComponentPayload<Type>['render']
): CordoComponent<Type> {
  const comp = {
    nativeName: type,
    nativeType: ComponentType[type],
    visible: true,
    attributes: {},
    render,
  }
  const out = {
    [CordoComponentSymbol]: comp,
    visible(value: boolean) {
      comp.visible = value
      return this
    },
    attributes(attrs: Record<string, any>) {
      comp.attributes = defu(attrs, comp.attributes)
      return this
    }
  }
  return out as any as CordoComponent<Type>
}

export function readComponent<T extends CordoComponent<StringComponentType>>(comp: T): T[typeof CordoComponentSymbol] {
  return comp[CordoComponentSymbol]!
}

export function isComponent(t: Record<string, any>): t is CordoComponent<StringComponentType> {
  return !!t && CordoComponentSymbol in t
}

export function renderComponent(
  c: CordoComponent<StringComponentType> | CordoComponentPayload<StringComponentType>,
  parent: StringComponentType | null,
  hirarchy: Array<StringComponentType> = [],
  inheritAttributes: Record<string, any> = {}
) {
  const extracted = CordoComponentSymbol in c ? readComponent(c) : c
  if (!extracted.visible)
    return null
  return extracted.render({
    hirarchy: parent
      ? [ parent, ...hirarchy ]
      : hirarchy,
    attributes: defu(extracted.attributes, inheritAttributes)
  })
}

export function renderComponentList(
  list: Array<CordoComponent<StringComponentType> | CordoModifier>,
  parent: StringComponentType | null,
  hirarchy: Array<StringComponentType> = [],
  inheritAttributes: Record<string, any> = {},
  transform?: (component: CordoComponent<StringComponentType>, parsed: CordoComponentPayload<StringComponentType>) => CordoComponent<StringComponentType> | null
) {
  let pipeline: Array<CordoComponentPayload<StringComponentType>> = []
  /* when we have buttons without a host row we use this to collect up to 5 and then create the row for it */
  const rowBuilder: Array<CordoComponent<StringComponentType>> = []
  const modifiers: Array<ReturnType<typeof readModifier>> = []

  for (let item of list) {
    if (!item)
      continue

    if (!isComponent(item)) {
      const mod = readModifier(item)
      if (mod && !modifiers.some(m => m.name === mod.name))
        modifiers.push(mod)
      continue
    }

    let parsed = readComponent(item)
    for (const mod of modifiers) {
      if (mod.hooks?.onRender)
        parsed = mod.hooks.onRender(parsed)
    }

    if (transform) {
      const transformed = transform(item, parsed)
      if (!transformed)
        continue
      item = transformed
      parsed = readComponent(transformed)
    }

    if (parent !== 'ActionRow') {
      if (parsed.nativeName === 'Button') {
        rowBuilder.push(item)
        if (rowBuilder.length === 5) {
          pipeline.push(readComponent(row(...rowBuilder as any)))
          rowBuilder.splice(0)
        }
        continue
      }

      if (parsed.nativeName === 'StringSelect' || parsed.nativeName === 'TextInput') {
        if (rowBuilder.length > 0) {
          pipeline.push(readComponent(row(...rowBuilder as any)))
          rowBuilder.splice(0)
        }

        pipeline.push(readComponent(row(item as any)))
        continue
      }
    }

    if (rowBuilder.length > 0) {
      pipeline.push(readComponent(row(...rowBuilder as any)))
      rowBuilder.splice(0)
    }

    pipeline.push(parsed)
  }

  if (rowBuilder.length > 0) {
    pipeline.push(readComponent(row(...rowBuilder as any)))
    rowBuilder.splice(0)
  }

  for (const mod of modifiers) {
    if (mod.hooks?.beforeRender)
      pipeline = mod.hooks.beforeRender(pipeline)
  }

  let output = pipeline
    .map(c => renderComponent(c, parent, hirarchy, inheritAttributes))
    .filter(Boolean) as Record<string | any, any>[]

  // join adjacent text components
  let previousTextComponent: Record<string, any> | null = null
  output = output.filter((item) => {
    if (item.type === ComponentType.TextDisplay) {
      if (previousTextComponent) {
        (previousTextComponent as any).content += '\n' + item.content
        return false
      } else {
        previousTextComponent = item
      }
    } else {
      previousTextComponent = null
    }
    return true
  })

  for (const mod of modifiers) {
    if (mod.hooks?.afterRender)
      output = mod.hooks.afterRender(output)
  }

  return output
}