import { h, render } from 'vue'
import { ControlComponentEnum } from '../packages/Control'
import { doCommandDelivery, getDeviceActive, getDeviceInfo } from '@/api/device'
import type { MouseUpEventDataType, NodeDataDataSourceJsonType, NodeDataEventJsonType, SingleClickEventDataType } from '@/api/node/model'
import { CommandWayEnum } from '@/enums/commandEnum'
import { ActRangListItemTypeEnum, EventActionTypeEnum, TransportTypeEnum } from '@/enums/datasource'
import { useMessage } from '@/hooks/web/useMessage'
import { AttributeDeliverModal, CommandDeliveryConfirmModal, CommandDeliveryModal, ConfirmModal } from '@/core/Library/components/PublicForm/components/DataEvents/CommandDeliveryModal'
import type { MxCell } from '@/fitCore/types'
import { NodeUtils } from '@/hooks/business/useNodeUtils'
import { useContentDataStoreWithOut } from '@/store/modules/contentData'
import type { RpcCommandType } from '@/api/device/model'

export function useNodeEvent(eventJson: NodeDataEventJsonType, dataSourceJson: NodeDataDataSourceJsonType, cell: MxCell) {
  const { createMessage } = useMessage()

  const handlerCommandDelivery = async (data: MouseUpEventDataType) => {
    try {
      const promiseList: (() => Promise<any>)[] = []
      const { commandList = [], enable } = data || {}
      if (!enable) return
      for (const item of commandList) {
        const { command, way, deviceId } = item
        promiseList.push(async () => {
          if (way === CommandWayEnum.TWO_WAY) {
            const [record] = await getDeviceActive(deviceId)
            if (!record.value) {
              createMessage.warning('设备不在线')
              return
            }
          }
          await doCommandDelivery({
            way,
            deviceId,
            command: {
              additionalInfo: { cmdType: 'API' },
              method: 'methodThingskit',
              params: command,
              persistent: true,
            },
          })
          createMessage.success('下发成功')
        })
      }

      await Promise.all(promiseList.map(fn => fn()))
    }
    catch (error) {
      createMessage.error(error as string)
    }
  }

  const handleOpenLink = (data: SingleClickEventDataType) => {
    const { openLink } = data
    window.open(openLink)
  }

  const handleSwitchPage = (data: SingleClickEventDataType) => {
    const { openPage } = data
    const pages = window.DrawApp.pages
    const openPageFile = pages.find(item => item.getId() === openPage)
    if (openPageFile)
      window.DrawApp.selectPage(openPageFile)
  }

  const handleParamsSetting = async (_data: SingleClickEventDataType) => {
    const deviceInfo = dataSourceJson

    const instance = h(CommandDeliveryModal)
    render(instance, document.body);
    (instance.component?.exposed as InstanceType<typeof CommandDeliveryModal>)?.open({ ..._data, deviceInfo, operationPassword: eventJson?.OPERATION_PASSWORD })
  }

  const handleAttributeDelivery = async (data: SingleClickEventDataType) => {
    try {
      const nodeUtils = new NodeUtils()
      const { way = CommandWayEnum.ONE_WAY } = data
      const { attr, deviceId, attrInfo } = dataSourceJson
      const { transportType, alias, name: deviceName } = await getDeviceInfo(dataSourceJson.deviceId) || {}// 设备信息
      const contentDataStore = useContentDataStoreWithOut()
      const currentData = contentDataStore.contentData.find(item => item.id === cell.getId())
      if (!currentData) return
      const { actJson, eventJson } = currentData
      const { value: operationPassword, checked: operationPasswordEnable } = eventJson.OPERATION_PASSWORD

      const command: RpcCommandType = {
        additionalInfo: { cmdType: 'API' },
        method: 'methodThingskit',
        params: {},
        persistent: true,
      }
      if (nodeUtils.getNodeComponentKey(cell) === ControlComponentEnum.SWITCH) {
        const { rangeList } = actJson.STATUS_SETTING
        const status = cell.getAttribute('SWITCH_STATUS')
        const res = rangeList.find(item => item.type === (status === ActRangListItemTypeEnum.OPEN ? ActRangListItemTypeEnum.CLOSE : ActRangListItemTypeEnum.OPEN))
        if (!res) return
        const { statusValue } = res
        command.params = transportType === TransportTypeEnum.TCP
          ? statusValue!
          : {
              [attr]: statusValue,
            }

        if (operationPasswordEnable) {
          const instance = h(CommandDeliveryConfirmModal)
          render(instance, document.body)
          await (instance.component?.exposed as InstanceType<typeof CommandDeliveryConfirmModal>)?.open(operationPassword)
        }
        else {
          const instance = h(ConfirmModal)
          render(instance, document.body)
          await (instance.component?.exposed as InstanceType<typeof ConfirmModal>)?.open()
        }

        await doCommandDelivery({ way, command, deviceId })
        createMessage.success('命令下发成功')
      }
      else {
        const instance = h(AttributeDeliverModal)
        render(instance, document.body)
        const value = await (instance.component?.exposed as InstanceType<typeof AttributeDeliverModal>)?.open({ title: `${alias || deviceName}-${attrInfo.name}`, operationPassword }) as string

        command.params = transportType === TransportTypeEnum.TCP ? value : { [attr]: value }
        await doCommandDelivery({ way, command, deviceId })
        createMessage.success('命令下发成功')
      }
    }
    catch (error) {
      console.error(error)
    }
  }

  const handlerMouseClickEvent = (data: SingleClickEventDataType) => {
    const { actionType, enable } = data
    if (!enable) return
    if (actionType === EventActionTypeEnum.OPEN_LINK)
      handleOpenLink(data)
    else if (actionType === EventActionTypeEnum.OPEN_PAGE)
      handleSwitchPage(data)
    else if (actionType === EventActionTypeEnum.PARAMS_SETTING)
      handleParamsSetting(data)
    else if (actionType === EventActionTypeEnum.ATTRIBUTE_DELIVERY)
      handleAttributeDelivery(data)
  }

  const handlerMouseDown = async () => {
    eventJson.DOWN && handlerCommandDelivery(eventJson.DOWN)
  }

  const handlerMouseUp = () => {
    eventJson.UP && handlerCommandDelivery(eventJson.UP)
  }

  const handlerMouseClick = () => {
    eventJson.SINGLE && handlerMouseClickEvent(eventJson.SINGLE)
  }

  const handlerMouseDoubleClick = () => {
    eventJson.DOUBLE && handlerMouseClickEvent(eventJson.DOUBLE)
  }

  return {
    handlerMouseUp,
    handlerMouseDown,
    handlerMouseClick,
    handlerMouseDoubleClick,
  }
}