import type { Component, ComponentInternalInstance, Ref, RenderFunction, SetupContext } from 'vue'
import type Node from 'element-plus/es/components/tree/src/model/node'
import type {
  AllowDragFunction,
  AllowDropFunction,
  FilterNodeMethodFunction,
  LoadFunction,
  NodeDropType,
  RenderContentFunction,
  TreeData,
  TreeKey,
  TreeNodeData,
  TreeOptionProps,
} from 'element-plus/es/components/tree/src/tree.type'

import type { TreeProps } from '../base'
import type {
  ComponentBaseOptions,
  ComponentSlotType,
  DefineComponentApp,
  DefineComponentInstance,
  Merge,
} from '../common'

export declare const KTree: DefineComponentApp<KTreeProps, KTreeEmits, KTreeSlots>

export type KTreeInstance = DefineComponentInstance<KTreeProps, KTreeConstructor>

export interface KTreeConstructor extends ComponentBaseOptions, KTreeMethods {
  props: KTreeProps
  context: SetupContext<KTreeEmits>
  getRefMaps(): KTreePrivateRef
  getComputeMaps(): KTreePrivateComputed
  renderVN: RenderFunction
}

export interface KTreePrivateRef {
  refElem: Ref<HTMLDivElement | undefined>
}

export interface KTreePrivateComputed { }

export type KTreeProps = Merge<TreeProps, ElTreeProps>

interface ElTreeProps {
  data?: TreeData
  emptyText?: string
  nodeKey?: string
  props?: TreeOptionProps
  renderAfterExpand?: boolean
  load?: LoadFunction
  renderContent?: RenderContentFunction
  highlightCurrent?: boolean
  defaultExpandAll?: boolean
  expandOnClickNode?: boolean
  checkOnClickNode?: boolean
  autoExpandParent?: boolean
  defaultExpandedKeys?: Array<string | number>
  showCheckbox?: boolean
  checkStrictly?: boolean
  defaultCheckedKeys?: Array<string | number>
  currentNodeKey?: string | number
  filterNodeMethod?: FilterNodeMethodFunction
  accordion?: boolean
  indent?: number
  icon?: string | Component
  lazy?: boolean
  draggable?: boolean
  allowDrag?: AllowDragFunction
  allowDrop?: AllowDropFunction
}

export interface KTreeEmits {
  nodeClick: (data: TreeNodeData, node: Node, instance: ComponentInternalInstance | null, event: MouseEvent) => void
  nodeContextmenu: (event: Event, data: TreeNodeData, node: Node, instance: ComponentInternalInstance | null) => void
  checkChange: (data: TreeNodeData, checked: boolean, indeterminate: boolean) => void
  check: (
    data: TreeNodeData,
    checkedData: { checkedNodes: Node[]; checkedKeys: TreeKey[]; halfCheckedNodes: Node[]; halfCheckedKeys: TreeKey[] },
  ) => void
  currentChange: (data: TreeNodeData, currentNode: Node) => void
  nodeExpand: (data: TreeNodeData, node: Node, instance: ComponentInternalInstance | null) => void
  nodeCollapse: (data: TreeNodeData, node: Node, instance: ComponentInternalInstance | null) => void
  nodeDragStart: (node: Node, event: DragEvents) => void
  nodeDragLeave: (dragNode: Node, oldNode: Node, event: DragEvents) => void
  nodeDragEnter: (dragNode: Node, dropNode: Node, event: DragEvents) => void
  nodeDragOver: (dragNode: Node, dropNode: Node, event: DragEvents) => void
  nodeDragEnd: (dragNode: Node, dropNode: Node, dropType: NodeDropType, event: DragEvents) => void
  nodeDrop: (dragNode: Node, dropNode: Node, dropType: NodeDropType, event: DragEvents) => void
}

export interface KTreeSlots {
  default: (_: { node: Node; data: TreeNodeData }) => ComponentSlotType
  empty: () => ComponentSlotType
}

export type KTreeMethods = {
  filter: (value: string) => void
  updateKeyChildren: (key: TreeKey, data: TreeData) => void
  getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => Node[]
  setCheckedNodes: (nodes: Node[], leafOnly?: boolean) => void
  getCheckedKeys: (leafOnly?: boolean) => TreeKey[]
  setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void
  setChecked: (data: TreeKey | TreeData, checked: boolean, deep?: boolean) => void
  getHalfCheckedNodes: () => Node[]
  getHalfCheckedKeys: () => TreeKey[]
  getCurrentKey: () => string | number | null
  getCurrentNode: () => Node | null
  setCurrentKey: (key: TreeKey, shouldAutoExpandParent?: boolean) => void
  setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void
  getNode: (data: TreeKey | TreeNodeData) => Node
  remove: (data: TreeNodeData | Node) => void
  append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | Node) => void
  insertBefore: (data: TreeKey | TreeNodeData | Node) => void
  insertAfter: (data: TreeKey | TreeNodeData | Node) => void
}