<template>
  <a-card :title="title" :bordered="true">
    <a-tree
      :load-data="onLoadData"
      :tree-data="treeData"
      @select="handleSelect"
      style="overflow: hidden; overflow-wrap: normal;"
    />
  </a-card>
</template>

<script>
import { getAction } from '@api/manage'

export default {
  name: 'DeviceTypeTree',
  props: {
    maxLevel: {
      type: Number,
      default: -1,
      required: false,
    },
    title: {
      type: String,
      default: '设备构型',
      required: false,
    },
  },
  data() {
    return {
      treeData: [],
      urlList: {
        listAllType: '/device/buDeviceType/list/deviceType',     // 设备类型树
        listAllPartType: '/device/buDeviceType/list/all',        // 部件类型树
      },
    }
  },
  mounted() {
    this.loadData()
  },
  methods: {
    handleSelect(key, e) {
      console.log('设备树选择', key, e)
      this.$emit('select-device', key, e.node.dataRef.level)
    },

    // 初始加载：设备类型根节点
    loadData() {
      getAction(this.urlList.listAllType).then((res) => {
        if (res.success) {
          this.treeData = this.buildDeviceTypeNodes(res.result, 0)
        }
      })
    },

    // 构建设备类型节点（递归结构，懒展开）
    buildDeviceTypeNodes(items, level) {
      if (!items || !Array.isArray(items)) return []
      return items.map(item => {
        const hasSub = item.subTypes && item.subTypes.length > 0
        const isLeafByMax = this.maxLevel !== -1 && level >= this.maxLevel

        return {
          key: item.id,
          title: `${item.typeName}(${item.typeCode})`,
          level,
          nodeType: 'deviceType', // 标记来源
          // 如果受 maxLevel 限制，或没有 subTypes，则不再展开设备类型子树
          rawSubTypes: !isLeafByMax && hasSub ? item.subTypes : null,
          children: [],
          // ⭐⭐⭐ 关键：设备类型节点永远 isLeaf = false！
          // 因为即使没有 subTypes，也要加载部件类型
          isLeaf: false,
        }
      })
    },

    // 构建部件类型节点（同样支持多层）
    buildPartTypeNodes(items, level) {
      if (!items || !Array.isArray(items)) return []
      return items.map(item => {
        const hasSub = item.subTypes && item.subTypes.length > 0
        const isLeafByMax = this.maxLevel !== -1 && level >= this.maxLevel

        return {
          key: item.id,
          title: `${item.typeName}(${item.typeCode})`,
          level,
          nodeType: 'partType',
          rawSubTypes: !isLeafByMax && hasSub ? item.subTypes : null,
          children: [],
          isLeaf: isLeafByMax || !hasSub,
        }
      })
    },

    // 懒加载子节点（统一入口）
    onLoadData(treeNode) {
      const dataRef = treeNode.dataRef
      if (!dataRef) return Promise.resolve()

      // 情况1：节点有缓存的 subTypes（来自设备类型或部件类型）
      if (dataRef.rawSubTypes) {
        const nextLevel = dataRef.level + 1
        const children = dataRef.nodeType === 'deviceType'
          ? this.buildDeviceTypeNodes(dataRef.rawSubTypes, nextLevel)
          : this.buildPartTypeNodes(dataRef.rawSubTypes, nextLevel)

        dataRef.children = children
        dataRef.rawSubTypes = null
        return Promise.resolve()
      }

      // 情况2：设备类型的叶子节点 → 加载其下的部件类型
      if (dataRef.nodeType === 'deviceType') {
        return getAction(this.urlList.listAllPartType, {
          pid: dataRef.key,
          calss: 2,
        }).then((res) => {
          if (res.success && Array.isArray(res.result)) {
            const nextLevel = dataRef.level + 1
            const partTypeNodes = this.buildPartTypeNodes(res.result, nextLevel)
            dataRef.children = partTypeNodes.length > 0 ? partTypeNodes : []
            // 如果没数据，保持 isLeaf=true；否则已设为非叶子
          }
        }).catch(err => {
          console.error('加载部件类型失败:', err)
          return Promise.reject(err)
        })
      }

      // 情况3：部件类型的叶子节点（当前无需加载具体部件，可留空）
      // 如果未来要加载具体部件（listAllPart），可在此扩展

      return Promise.resolve()
    },
  },
}
</script>