// ================================
// 3D占用网格系统模块
// ================================
import * as Cesium from 'cesium'

class OccupancyGrid {
  constructor(viewer, config = {}, gridParams) {
    this.viewer = viewer
    this.gridEntities = []
    this.tilesBoundingBoxes = [] // 存储瓦片边界框
    this.gridParams = gridParams

    // 网格配置参数 - 可自定义
    this.config = {
      // 网格单元尺寸配置
      gridSize: config.gridSize || 50, // 网格单元大小（米）
      gridWidth: config.gridWidth || 50, // 网格宽度（米）
      gridHeight: config.gridHeight || 50, // 网格高度（米）
      gridDepth: config.gridDepth || 50, // 网格深度（米）

      // 区域扩展配置
      heightExtension: config.heightExtension || 120, // 向上向下各扩展120米，确保4层网格（总高度240米，4×50=200米，留有余量）
      widthExtension: config.widthExtension || 100, // 水平方向扩展100米

      // 颜色配置
      occupiedColor: config.occupiedColor || Cesium.Color.RED.withAlpha(0.7), // 占用网格颜色（红色）
      freeColor: config.freeColor || Cesium.Color.GREEN.withAlpha(0.3), // 空闲网格颜色（绿色）
      occupiedOutlineColor: config.occupiedOutlineColor || Cesium.Color.DARKRED, // 占用网格边框颜色
      freeOutlineColor: config.freeOutlineColor || Cesium.Color.DARKGREEN, // 空闲网格边框颜色
      outlineWidth: config.outlineWidth || 1, // 边框宽度

      // 透明度配置
      occupiedAlpha: config.occupiedAlpha || 0.7, // 占用网格透明度
      freeAlpha: config.freeAlpha || 0.3, // 空闲网格透明度

      // 性能优化配置
      maxGridCount: config.maxGridCount || 10000, // 最大网格数量限制
      enableBatching: config.enableBatching || true, // 是否启用批处理优化

      // 调试配置
      showOccupiedOnly: config.showOccupiedOnly || false, // 是否只显示占用的网格
      showFreeOnly: config.showFreeOnly || false, // 是否只显示空闲的网格
      enableLogging: config.enableLogging || true // 是否启用详细日志
    }

    // 向后兼容旧参数
    this.gridSize = this.config.gridSize
    this.heightExtension = this.config.heightExtension
  }

  // ================================
  // 更新配置
  // ================================
  updateConfig (newConfig) {
    this.config = { ...this.config, ...newConfig }

    // 更新向后兼容参数
    this.gridSize = this.config.gridSize
    this.heightExtension = this.config.heightExtension

    if (this.config.enableLogging) {
      console.log('网格配置已更新:', this.config)
    }
  }

  // ================================
  // 获取当前配置
  // ================================
  getConfig () {
    return { ...this.config }
  }

  // ================================
  // 生成占用网格 - 使用配置参数
  // ================================
  async generateOccupancyGrid (waypoints) {
    if (waypoints.length < 2) {
      console.warn('需要至少2个航点来生成占用网格')
      return
    }

    // 清除之前的网格
    this.clearGrid()

    // 获取起点和终点
    const startPoint = waypoints[0]
    const endPoint = waypoints[waypoints.length - 1]

    // 计算边界框
    const bounds = this.calculateBounds(startPoint, endPoint)

    // 收集3D瓦片的边界框信息
    await this.collectTilesBoundingBoxes(bounds)

    // 生成网格
    await this.createGrid(bounds)

    if (this.config.enableLogging) {
      console.log('3D占用网格生成完成')
      console.log(`网格尺寸: ${this.config.gridWidth}m x ${this.config.gridHeight}m x ${this.config.gridDepth}m`)
      console.log(`总网格数量: ${this.gridEntities.length}`)
      console.log(`瓦片边界框数量: ${this.tilesBoundingBoxes.length}`)
    }
  }

  // ================================
  // 使用航线瓦片数据生成占用网格 - 使用配置参数
  // ================================
  async generateOccupancyGridWithTiles (waypoints, flightPathTiles) {
    if (waypoints.length < 2) {
      console.warn('需要至少2个航点来生成占用网格')
      return
    }

    if (this.config.enableLogging) {
      console.log(`开始生成占用网格，将分析网格范围内的所有叶子瓦片节点`)
    }

    // 清除之前的网格
    this.clearGrid()

    // 获取起点和终点
    const startPoint = waypoints[0]
    const endPoint = waypoints[waypoints.length - 1]

    // 计算边界框
    const bounds = this.calculateBounds(startPoint, endPoint)

    // 获取瓦片集，用于遍历叶子节点
    this.tileset = this.getTileset()

    if (!this.tileset) {
      console.warn('未找到瓦片集，无法生成占用网格')
      return
    }

    // 生成网格
    await this.createGrid(bounds)

    if (this.config.enableLogging) {
      console.log('使用叶子瓦片节点的3D占用网格生成完成')
      console.log(`网格尺寸: ${this.config.gridWidth}m x ${this.config.gridHeight}m x ${this.config.gridDepth}m`)
      console.log(`总网格数量: ${this.gridEntities.length}`)
    }
  }

  // ================================
  // 获取瓦片集
  // ================================
  getTileset () {
    const primitives = this.viewer.scene.primitives

    for (let i = 0; i < primitives.length; i++) {
      const primitive = primitives.get(i)
      if (primitive instanceof Cesium.Cesium3DTileset) {
        return primitive
      }
    }

    return null
  }

  // ================================
  // 计算边界框 - 使用配置参数
  // ================================
  calculateBounds (startPoint, endPoint) {
    // 转换为地理坐标
    const startCartographic = Cesium.Cartographic.fromCartesian(startPoint.position)
    const endCartographic = Cesium.Cartographic.fromCartesian(endPoint.position)

    // 计算基础边界
    let minLon = Math.min(startCartographic.longitude, endCartographic.longitude)
    let maxLon = Math.max(startCartographic.longitude, endCartographic.longitude)
    let minLat = Math.min(startCartographic.latitude, endCartographic.latitude)
    let maxLat = Math.max(startCartographic.latitude, endCartographic.latitude)

    // 应用水平扩展
    const earthRadius = 6371000
    const widthExtensionLon = this.config.widthExtension / (earthRadius * Math.cos((minLat + maxLat) / 2))
    const widthExtensionLat = this.config.widthExtension / earthRadius

    minLon -= widthExtensionLon
    maxLon += widthExtensionLon
    minLat -= widthExtensionLat
    maxLat += widthExtensionLat

    // 计算平均高度和垂直扩展
    const avgHeight = (startPoint.height + endPoint.height) / 2
    const heightOffset = 20 // 向上平移50米，避免网格被tileset遮盖
    const minHeight = avgHeight - this.config.heightExtension + heightOffset
    const maxHeight = avgHeight + this.config.heightExtension + heightOffset

    const bounds = {
      minLon: minLon,
      maxLon: maxLon,
      minLat: minLat,
      maxLat: maxLat,
      minHeight: minHeight,
      maxHeight: maxHeight,
      avgHeight: avgHeight
    }

    if (this.config.enableLogging) {
      console.log('计算网格边界范围:', {
        经度范围: `${Cesium.Math.toDegrees(minLon).toFixed(6)} 到 ${Cesium.Math.toDegrees(maxLon).toFixed(6)}`,
        纬度范围: `${Cesium.Math.toDegrees(minLat).toFixed(6)} 到 ${Cesium.Math.toDegrees(maxLat).toFixed(6)}`,
        高度范围: `${minHeight.toFixed(1)}m 到 ${maxHeight.toFixed(1)}m (向上平移50m)`,
        水平扩展: `${this.config.widthExtension}m`,
        垂直扩展: `${this.config.heightExtension}m`
      })
    }

    return bounds
  }

  // ================================
  // 收集3D瓦片的边界框信息
  // ================================
  async collectTilesBoundingBoxes (bounds) {
    this.tilesBoundingBoxes = []

    // 获取所有的图元
    const primitives = this.viewer.scene.primitives
    let tileset = null

    // 查找3D Tiles图层
    for (let i = 0; i < primitives.length; i++) {
      const primitive = primitives.get(i)
      if (primitive instanceof Cesium.Cesium3DTileset) {
        tileset = primitive
        break
      }
    }

    if (!tileset || !tileset.root) {
      console.warn('未找到3D Tiles图层')
      return
    }

    // 等待瓦片集加载完成
    if (!tileset.ready) {
      await tileset.readyPromise
    }

    // 遍历瓦片树并收集边界框
    this.traverseTiles(tileset.root, bounds)

    console.log(`收集到${this.tilesBoundingBoxes.length}个瓦片边界框`)
  }

  // ================================
  // 收集航线瓦片的边界框信息
  // ================================
  collectFlightPathTilesBoundingBoxes (flightPathTiles) {
    console.log('开始收集航线瓦片边界框信息')
    this.tilesBoundingBoxes = []

    flightPathTiles.forEach((tile, index) => {
      try {
        // 获取边界体信息
        let boundingVolume = null

        if (tile.boundingVolume) {
          boundingVolume = tile.boundingVolume
        } else if (tile._boundingVolume) {
          boundingVolume = tile._boundingVolume
        } else if (tile.contentBoundingVolume) {
          boundingVolume = tile.contentBoundingVolume
        }

        if (!boundingVolume) {
          console.warn(`瓦片 ${index} 没有边界体信息`)
          return
        }

        let boundingBox = null

        // 处理不同类型的边界体
        if (boundingVolume instanceof Cesium.OrientedBoundingBox) {
          boundingBox = this.orientedBoundingBoxToAxisAligned(boundingVolume)
        }
        else if (boundingVolume instanceof Cesium.BoundingSphere) {
          boundingBox = this.sphereToAxisAligned(boundingVolume)
        }
        else if (boundingVolume.orientedBoundingBox) {
          boundingBox = this.orientedBoundingBoxToAxisAligned(boundingVolume.orientedBoundingBox)
        }
        else if (boundingVolume.boundingSphere) {
          boundingBox = this.sphereToAxisAligned(boundingVolume.boundingSphere)
        }
        else if (boundingVolume._orientedBoundingBox) {
          boundingBox = this.orientedBoundingBoxToAxisAligned(boundingVolume._orientedBoundingBox)
        }
        else if (boundingVolume._boundingSphere) {
          boundingBox = this.sphereToAxisAligned(boundingVolume._boundingSphere)
        }

        if (boundingBox) {
          this.tilesBoundingBoxes.push(boundingBox)
          console.log(`添加瓦片 ${index} 的边界框`)
        } else {
          console.warn(`无法处理瓦片 ${index} 的边界体类型`)
        }
      } catch (error) {
        console.warn(`处理瓦片 ${index} 边界体时出错:`, error)
      }
    })

    console.log(`成功收集 ${this.tilesBoundingBoxes.length} 个航线瓦片边界框`)
  }

  // ================================
  // 遍历瓦片树
  // ================================
  traverseTiles (tile, bounds) {
    if (!tile) return

    // 获取瓦片的边界框
    const boundingVolume = tile.boundingVolume
    if (boundingVolume) {
      let boundingBox = null

      try {
        // 检查是否有中心点和半径（球体）
        if (boundingVolume.center && boundingVolume.radius !== undefined) {
          boundingBox = this.sphereToBox(boundingVolume)
        }
        // 检查是否有中心点和半轴（盒子）
        else if (boundingVolume.center && boundingVolume.halfAxes) {
          const halfAxes = boundingVolume.halfAxes
          const halfExtents = new Cesium.Cartesian3(
            Math.max(10, Cesium.Cartesian3.magnitude(new Cesium.Cartesian3(halfAxes[0], halfAxes[1], halfAxes[2]))),
            Math.max(10, Cesium.Cartesian3.magnitude(new Cesium.Cartesian3(halfAxes[3], halfAxes[4], halfAxes[5]))),
            Math.max(10, Cesium.Cartesian3.magnitude(new Cesium.Cartesian3(halfAxes[6], halfAxes[7], halfAxes[8])))
          )
          boundingBox = {
            center: boundingVolume.center,
            halfExtents: halfExtents
          }
        }
        // 检查是否有区域信息
        else if (boundingVolume.west !== undefined && boundingVolume.east !== undefined) {
          boundingBox = this.regionToBox(boundingVolume)
        }
        // 默认情况：创建一个小的边界框
        else if (boundingVolume.center) {
          boundingBox = {
            center: boundingVolume.center,
            halfExtents: new Cesium.Cartesian3(50, 50, 50) // 默认50米
          }
        }
      } catch (error) {
        console.warn('处理边界体积时出错:', error)
        return
      }

      if (boundingBox && this.isBoundingBoxInRegion(boundingBox, bounds)) {
        this.tilesBoundingBoxes.push(boundingBox)
      }
    }

    // 递归遍历子瓦片
    if (tile.children && tile.children.length > 0) {
      for (const child of tile.children) {
        this.traverseTiles(child, bounds)
      }
    }
  }

  // ================================
  // 将球体转换为包围盒
  // ================================
  sphereToBox (sphere) {
    const center = sphere.center
    const radius = sphere.radius

    // 创建一个立方体包围盒
    const halfExtents = new Cesium.Cartesian3(radius, radius, radius)

    return {
      center: center,
      halfExtents: halfExtents
    }
  }

  // ================================
  // 将区域转换为包围盒
  // ================================
  regionToBox (region) {
    // 计算区域的中心点
    const centerLon = (region.west + region.east) / 2
    const centerLat = (region.south + region.north) / 2
    const centerHeight = (region.minimumHeight + region.maximumHeight) / 2

    const center = Cesium.Cartesian3.fromRadians(centerLon, centerLat, centerHeight)

    // 计算区域的半尺寸
    const lonExtent = (region.east - region.west) / 2
    const latExtent = (region.north - region.south) / 2
    const heightExtent = (region.maximumHeight - region.minimumHeight) / 2

    // 转换为笛卡尔坐标的半扩展
    const earthRadius = 6371000
    const halfExtents = new Cesium.Cartesian3(
      lonExtent * earthRadius * Math.cos(centerLat),
      latExtent * earthRadius,
      heightExtent
    )

    return {
      center: center,
      halfExtents: halfExtents
    }
  }

  // ================================
  // 检查边界框是否在感兴趣区域内
  // ================================
  isBoundingBoxInRegion (boundingBox, bounds) {
    // 将边界框中心转换为地理坐标
    const centerCartographic = Cesium.Cartographic.fromCartesian(boundingBox.center)

    // 检查是否在地理范围内
    return (centerCartographic.longitude >= bounds.minLon &&
      centerCartographic.longitude <= bounds.maxLon &&
      centerCartographic.latitude >= bounds.minLat &&
      centerCartographic.latitude <= bounds.maxLat &&
      centerCartographic.height >= bounds.minHeight &&
      centerCartographic.height <= bounds.maxHeight)
  }

  // ================================
  // 创建网格 - 使用配置参数
  // ================================
  async createGrid (bounds) {
    // 将地理坐标转换为距离（米）
    const earthRadius = 6371000 // 地球半径（米）

    // 计算经纬度范围对应的实际距离
    const latDistance = (bounds.maxLat - bounds.minLat) * earthRadius
    const lonDistance = (bounds.maxLon - bounds.minLon) * earthRadius * Math.cos((bounds.minLat + bounds.maxLat) / 2)
    const heightDistance = bounds.maxHeight - bounds.minHeight

    // 计算网格数量 - 使用配置的网格尺寸
    const gridCountX = Math.ceil(lonDistance / this.config.gridWidth)
    const gridCountY = Math.ceil(latDistance / this.config.gridHeight)
    const gridCountZ = Math.ceil(heightDistance / this.config.gridDepth)

    const totalGridCount = gridCountX * gridCountY * gridCountZ

    if (this.config.enableLogging) {
      console.log(`计划生成网格数量: ${gridCountX} x ${gridCountY} x ${gridCountZ} = ${totalGridCount}`)
      console.log(`网格单元尺寸: 宽${this.config.gridWidth}m x 高${this.config.gridHeight}m x 深${this.config.gridDepth}m`)
      console.log(`实际距离: 经度${lonDistance.toFixed(1)}m x 纬度${latDistance.toFixed(1)}m x 高度${heightDistance.toFixed(1)}m`)
      console.log(`垂直方向: 高度范围${heightDistance.toFixed(1)}m ÷ 网格深度${this.config.gridDepth}m = ${gridCountZ}层网格`)
    }

    // 性能保护：检查网格数量是否超出限制
    if (totalGridCount > this.config.maxGridCount) {
      console.warn(`网格数量 ${totalGridCount} 超过最大限制 ${this.config.maxGridCount}，将进行优化处理`)

      // 自动调整网格尺寸
      const scaleFactor = Math.cbrt(totalGridCount / this.config.maxGridCount)
      const adjustedGridSize = this.config.gridSize * scaleFactor

      console.log(`自动调整网格尺寸从 ${this.config.gridSize}m 到 ${adjustedGridSize.toFixed(1)}m`)

      // 重新计算网格数量
      const newGridCountX = Math.ceil(lonDistance / adjustedGridSize)
      const newGridCountY = Math.ceil(latDistance / adjustedGridSize)
      const newGridCountZ = Math.ceil(heightDistance / adjustedGridSize)

      if (this.config.enableLogging) {
        console.log(`调整后网格数量: ${newGridCountX} x ${newGridCountY} x ${newGridCountZ} = ${newGridCountX * newGridCountY * newGridCountZ}`)
      }

      // 使用调整后的参数
      return this.createGridWithCustomSize(bounds, newGridCountX, newGridCountY, newGridCountZ, adjustedGridSize)
    }

    // 正常情况下生成网格
    return this.createGridWithCustomSize(bounds, gridCountX, gridCountY, gridCountZ, this.config.gridSize)
  }

  // ================================
  // 使用自定义尺寸创建网格
  // ================================
  async createGridWithCustomSize (bounds, gridCountX, gridCountY, gridCountZ, gridSize) {
    let occupiedCount = 0
    let freeCount = 0

    // 批处理参数
    const batchSize = this.config.enableBatching ? 100 : 1
    let batchCount = 0

    // 生成网格立方体
    for (let i = 0; i < gridCountX; i++) {
      for (let j = 0; j < gridCountY; j++) {
        for (let k = 0; k < gridCountZ; k++) {
          const gridCenter = this.calculateGridCenter(bounds, i, j, k, gridCountX, gridCountY, gridCountZ)
          const isOccupied = await this.checkOccupancy(gridCenter)

          // 计算网格索引号 (i, j, k)
          const gridIndex = { x: i, y: j, z: k }

          // 根据配置决定是否显示
          let shouldCreate = true
          if (this.config.showOccupiedOnly && !isOccupied) {
            shouldCreate = false
          }
          if (this.config.showFreeOnly && isOccupied) {
            shouldCreate = false
          }

          if (shouldCreate) {
            this.createGridCube(gridCenter, isOccupied, gridSize, gridIndex)
          }

          // 统计
          if (isOccupied) {
            occupiedCount++
          } else {
            freeCount++
          }

          // 批处理优化：每处理一定数量后让出控制权
          batchCount++
          if (this.config.enableBatching && batchCount >= batchSize) {
            batchCount = 0
            await new Promise(resolve => setTimeout(resolve, 1)) // 让出1ms给浏览器
          }
        }
      }
    }

    if (this.config.enableLogging) {
      this.gridParams.hasGrid = true
      console.log(`网格生成完成 - 占用: ${occupiedCount}, 空闲: ${freeCount}, 总计: ${this.gridEntities.length}`)
    }
  }

  // ================================
  // 计算网格中心点
  // ================================
  calculateGridCenter (bounds, i, j, k, gridCountX, gridCountY, gridCountZ) {
    // 计算网格中心的地理坐标
    const lonStep = (bounds.maxLon - bounds.minLon) / gridCountX
    const latStep = (bounds.maxLat - bounds.minLat) / gridCountY
    const heightStep = (bounds.maxHeight - bounds.minHeight) / gridCountZ

    const lon = bounds.minLon + (i + 0.5) * lonStep
    const lat = bounds.minLat + (j + 0.5) * latStep
    const height = bounds.minHeight + (k + 0.5) * heightStep

    return {
      longitude: lon,
      latitude: lat,
      height: height
    }
  }

  // ================================
  // 检查占用状态 - 基于网格范围内的叶子瓦片节点及其外包盒求交
  // ================================
  async checkOccupancy (gridCenter) {
    if (!this.tileset) {
      return false // 没有瓦片集，默认未占用
    }

    // 计算网格单元的边界范围
    const gridBounds = this.calculateGridBounds(gridCenter)

    // 收集网格范围内的所有叶子瓦片节点
    const leafTilesInGrid = []
    this.findLeafTilesInGridBounds(this.tileset.root, gridBounds, leafTilesInGrid)
    console.log(this.tileset.root, gridBounds, 'this.tileset.root')
    if (leafTilesInGrid.length === 0) {
      return false // 没有叶子瓦片，标记为未占用
    }

    // 使用叶子节点的外包盒与网格单元进行精确求交计算
    const hasIntersection = this.checkGridTileIntersections(gridBounds, leafTilesInGrid)

    if (hasIntersection) {
      console.log(`网格单元 [${Cesium.Math.toDegrees(gridCenter.longitude).toFixed(6)}, ${Cesium.Math.toDegrees(gridCenter.latitude).toFixed(6)}, ${gridCenter.height.toFixed(1)}] 与 ${leafTilesInGrid.length} 个叶子瓦片相交`)
    }

    return hasIntersection
  }

  // ================================
  // 递归查找网格范围内的叶子瓦片节点
  // ================================
  findLeafTilesInGridBounds (tile, gridBounds, leafTiles) {
    if (!tile) {
      return
    }

    // 检查是否为叶子节点
    const isLeafNode = !tile.children || tile.children.length === 0

    // 首先检查当前瓦片是否与网格边界相交
    const intersects = this.isTileIntersectingGridBounds(tile, gridBounds)

    if (!intersects) {
      return // 如果当前瓦片不与网格相交，则跳过其所有子节点
    }

    if (isLeafNode) {
      // 只有叶子节点才添加到结果中
      leafTiles.push(tile)
    } else {
      // 中间节点与网格相交，继续遍历其子节点
      for (let i = 0; i < tile.children.length; i++) {
        this.findLeafTilesInGridBounds(tile.children[i], gridBounds, leafTiles)
      }
    }
  }

  // ================================
  // 检查瓦片是否与网格边界相交（简化版本，用于预筛选）
  // ================================
  isTileIntersectingGridBounds (tile, gridBounds) {
    // 获取瓦片的边界体信息
    let boundingVolume = null

    if (tile.boundingVolume) {
      boundingVolume = tile.boundingVolume
    } else if (tile._boundingVolume) {
      boundingVolume = tile._boundingVolume
    } else if (tile.contentBoundingVolume) {
      boundingVolume = tile.contentBoundingVolume
    }

    if (!boundingVolume) {
      return false // 没有边界体信息
    }

    try {
      // 简化的边界检测，用于快速预筛选
      let tileBounds = null

      if (boundingVolume instanceof Cesium.OrientedBoundingBox) {
        tileBounds = this.getSimpleBoundsFromOBB(boundingVolume)
      }
      else if (boundingVolume instanceof Cesium.BoundingSphere) {
        tileBounds = this.getSimpleBoundsFromSphere(boundingVolume)
      }
      else if (boundingVolume.orientedBoundingBox) {
        tileBounds = this.getSimpleBoundsFromOBB(boundingVolume.orientedBoundingBox)
      }
      else if (boundingVolume.boundingSphere) {
        tileBounds = this.getSimpleBoundsFromSphere(boundingVolume.boundingSphere)
      }
      else if (boundingVolume._orientedBoundingBox) {
        tileBounds = this.getSimpleBoundsFromOBB(boundingVolume._orientedBoundingBox)
      }
      else if (boundingVolume._boundingSphere) {
        tileBounds = this.getSimpleBoundsFromSphere(boundingVolume._boundingSphere)
      }

      if (!tileBounds) {
        return false
      }

      // 简单的3D AABB相交检测
      const tolerance = 0.0001

      const intersects = !(
        gridBounds.maxLon < tileBounds.minLon - tolerance ||
        gridBounds.minLon > tileBounds.maxLon + tolerance ||
        gridBounds.maxLat < tileBounds.minLat - tolerance ||
        gridBounds.minLat > tileBounds.maxLat + tolerance ||
        gridBounds.maxHeight < tileBounds.minHeight - tolerance ||
        gridBounds.minHeight > tileBounds.maxHeight + tolerance
      )

      return intersects

    } catch (error) {
      console.warn('预筛选瓦片边界体时出错:', error)
      return true // 出错时保守地返回true，让后续精确计算处理
    }
  }

  // ================================
  // 从OrientedBoundingBox获取简化边界（用于预筛选）
  // ================================
  getSimpleBoundsFromOBB (obb) {
    const center = obb.center
    const halfAxes = obb.halfAxes

    // 计算边界盒的大致范围
    const xAxis = new Cesium.Cartesian3()
    const yAxis = new Cesium.Cartesian3()
    const zAxis = new Cesium.Cartesian3()
    Cesium.Matrix3.getColumn(halfAxes, 0, xAxis)
    Cesium.Matrix3.getColumn(halfAxes, 1, yAxis)
    Cesium.Matrix3.getColumn(halfAxes, 2, zAxis)

    // 估算边界盒的最大扩展
    const maxExtent = Math.max(
      Cesium.Cartesian3.magnitude(xAxis),
      Cesium.Cartesian3.magnitude(yAxis),
      Cesium.Cartesian3.magnitude(zAxis)
    )

    // 将中心转换为地理坐标
    const centerCartographic = Cesium.Cartographic.fromCartesian(center)
    const centerLon = Cesium.Math.toDegrees(centerCartographic.longitude)
    const centerLat = Cesium.Math.toDegrees(centerCartographic.latitude)
    const centerHeight = centerCartographic.height

    // 估算经纬度范围
    const deltaLon = maxExtent / (111320 * Math.cos(centerCartographic.latitude))
    const deltaLat = maxExtent / 110540

    return {
      minLon: centerLon - deltaLon,
      maxLon: centerLon + deltaLon,
      minLat: centerLat - deltaLat,
      maxLat: centerLat + deltaLat,
      minHeight: centerHeight - maxExtent,
      maxHeight: centerHeight + maxExtent
    }
  }

  // ================================
  // 从BoundingSphere获取简化边界（用于预筛选）
  // ================================
  getSimpleBoundsFromSphere (sphere) {
    const center = sphere.center
    const radius = sphere.radius

    // 将球心转换为地理坐标
    const centerCartographic = Cesium.Cartographic.fromCartesian(center)
    const centerLon = Cesium.Math.toDegrees(centerCartographic.longitude)
    const centerLat = Cesium.Math.toDegrees(centerCartographic.latitude)
    const centerHeight = centerCartographic.height

    // 估算经纬度范围
    const deltaLon = radius / (111320 * Math.cos(centerCartographic.latitude))
    const deltaLat = radius / 110540

    return {
      minLon: centerLon - deltaLon,
      maxLon: centerLon + deltaLon,
      minLat: centerLat - deltaLat,
      maxLat: centerLat + deltaLat,
      minHeight: centerHeight - radius,
      maxHeight: centerHeight + radius
    }
  }

  // ================================
  // 检查网格与叶子瓦片的精确求交
  // ================================
  checkGridTileIntersections (gridBounds, leafTiles) {
    for (const tile of leafTiles) {
      if (this.isGridIntersectingTileBoundingBox(gridBounds, tile)) {
        return true // 找到一个相交的叶子瓦片即可确定占用状态
      }
    }
    return false
  }

  // ================================
  // 检查网格是否与瓦片外包盒相交（精确计算）
  // ================================
  isGridIntersectingTileBoundingBox (gridBounds, tile) {
    // 获取瓦片的边界体信息
    let boundingVolume = null

    if (tile.boundingVolume) {
      boundingVolume = tile.boundingVolume
    } else if (tile._boundingVolume) {
      boundingVolume = tile._boundingVolume
    } else if (tile.contentBoundingVolume) {
      boundingVolume = tile.contentBoundingVolume
    }

    if (!boundingVolume) {
      return false // 没有边界体信息
    }

    try {
      // 获取瓦片边界框的8个顶点（轴对齐）
      const tileVertices = this.getTileBoundingBoxVertices(boundingVolume)

      if (!tileVertices) {
        return false
      }

      // 将网格边界转换为轴对齐边界框的8个顶点
      const gridVertices = this.getGridBoundingBoxVertices(gridBounds)

      // 执行3D AABB求交检测
      return this.checkAABBIntersection(gridVertices, tileVertices)

    } catch (error) {
      console.warn('处理瓦片边界体时出错:', error)
      return false
    }
  }

  // ================================
  // 获取瓦片边界框的8个顶点（参考FlightPathTiles方法）
  // ================================
  getTileBoundingBoxVertices (boundingVolume) {
    let center = null
    let halfAxes = null

    // 处理不同类型的边界体
    if (boundingVolume instanceof Cesium.OrientedBoundingBox) {
      center = boundingVolume.center
      halfAxes = boundingVolume.halfAxes
    } else if (boundingVolume.orientedBoundingBox) {
      center = boundingVolume.orientedBoundingBox.center
      halfAxes = boundingVolume.orientedBoundingBox.halfAxes
    } else if (boundingVolume._orientedBoundingBox) {
      center = boundingVolume._orientedBoundingBox.center
      halfAxes = boundingVolume._orientedBoundingBox.halfAxes
    } else if (boundingVolume instanceof Cesium.BoundingSphere) {
      return this.getBoundingSphereVertices(boundingVolume)
    } else if (boundingVolume.boundingSphere) {
      return this.getBoundingSphereVertices(boundingVolume.boundingSphere)
    } else if (boundingVolume._boundingSphere) {
      return this.getBoundingSphereVertices(boundingVolume._boundingSphere)
    }

    if (!center || !halfAxes) {
      return null
    }

    return this.calculateBoundingBoxVertices(center, halfAxes)
  }

  // ================================
  // 计算边界框的8个顶点（轴对齐，参考FlightPathTiles方法）
  // ================================
  calculateBoundingBoxVertices (center, halfAxes) {
    // 计算所有8个顶点，然后找到轴对齐的边界框
    const tempVertices = []
    const directions = [
      [-1, -1, -1], [-1, -1, 1], [-1, 1, -1], [-1, 1, 1],
      [1, -1, -1], [1, -1, 1], [1, 1, -1], [1, 1, 1]
    ]

    // 提取三个轴向的向量
    const xAxis = new Cesium.Cartesian3()
    const yAxis = new Cesium.Cartesian3()
    const zAxis = new Cesium.Cartesian3()
    Cesium.Matrix3.getColumn(halfAxes, 0, xAxis)
    Cesium.Matrix3.getColumn(halfAxes, 1, yAxis)
    Cesium.Matrix3.getColumn(halfAxes, 2, zAxis)

    // 计算原始的8个顶点
    directions.forEach(dir => {
      const vertex = Cesium.Cartesian3.clone(center)
      Cesium.Cartesian3.add(vertex, Cesium.Cartesian3.multiplyByScalar(xAxis, dir[0], new Cesium.Cartesian3()), vertex)
      Cesium.Cartesian3.add(vertex, Cesium.Cartesian3.multiplyByScalar(yAxis, dir[1], new Cesium.Cartesian3()), vertex)
      Cesium.Cartesian3.add(vertex, Cesium.Cartesian3.multiplyByScalar(zAxis, dir[2], new Cesium.Cartesian3()), vertex)
      tempVertices.push(vertex)
    })

    // 转换为地理坐标，找到边界范围
    let minLon = Infinity, maxLon = -Infinity
    let minLat = Infinity, maxLat = -Infinity
    let minHeight = Infinity, maxHeight = -Infinity

    tempVertices.forEach(vertex => {
      const cartographic = Cesium.Cartographic.fromCartesian(vertex)
      const lon = Cesium.Math.toDegrees(cartographic.longitude)
      const lat = Cesium.Math.toDegrees(cartographic.latitude)
      const height = cartographic.height

      minLon = Math.min(minLon, lon)
      maxLon = Math.max(maxLon, lon)
      minLat = Math.min(minLat, lat)
      maxLat = Math.max(maxLat, lat)
      minHeight = Math.min(minHeight, height)
      maxHeight = Math.max(maxHeight, height)
    })

    // 创建轴对齐的边界框顶点（平行于地面）
    const vertices = [
      // 底面4个顶点
      Cesium.Cartesian3.fromDegrees(minLon, minLat, minHeight), // 0: 左下后
      Cesium.Cartesian3.fromDegrees(maxLon, minLat, minHeight), // 1: 右下后
      Cesium.Cartesian3.fromDegrees(minLon, maxLat, minHeight), // 2: 左上后
      Cesium.Cartesian3.fromDegrees(maxLon, maxLat, minHeight), // 3: 右上后
      // 顶面4个顶点
      Cesium.Cartesian3.fromDegrees(minLon, minLat, maxHeight), // 4: 左下前
      Cesium.Cartesian3.fromDegrees(maxLon, minLat, maxHeight), // 5: 右下前
      Cesium.Cartesian3.fromDegrees(minLon, maxLat, maxHeight), // 6: 左上前
      Cesium.Cartesian3.fromDegrees(maxLon, maxLat, maxHeight)  // 7: 右上前
    ]

    return vertices
  }

  // ================================
  // 处理球体边界的情况
  // ================================
  getBoundingSphereVertices (sphere) {
    const center = sphere.center
    const radius = sphere.radius

    // 将球心转换为地理坐标
    const centerCartographic = Cesium.Cartographic.fromCartesian(center)
    const centerLon = Cesium.Math.toDegrees(centerCartographic.longitude)
    const centerLat = Cesium.Math.toDegrees(centerCartographic.latitude)
    const centerHeight = centerCartographic.height

    // 估算经纬度范围（简化处理）
    const deltaLon = radius / (111320 * Math.cos(centerCartographic.latitude)) // 经度差
    const deltaLat = radius / 110540 // 纬度差

    // 创建轴对齐的边界框顶点
    const vertices = [
      // 底面4个顶点
      Cesium.Cartesian3.fromDegrees(centerLon - deltaLon, centerLat - deltaLat, centerHeight - radius),
      Cesium.Cartesian3.fromDegrees(centerLon + deltaLon, centerLat - deltaLat, centerHeight - radius),
      Cesium.Cartesian3.fromDegrees(centerLon - deltaLon, centerLat + deltaLat, centerHeight - radius),
      Cesium.Cartesian3.fromDegrees(centerLon + deltaLon, centerLat + deltaLat, centerHeight - radius),
      // 顶面4个顶点
      Cesium.Cartesian3.fromDegrees(centerLon - deltaLon, centerLat - deltaLat, centerHeight + radius),
      Cesium.Cartesian3.fromDegrees(centerLon + deltaLon, centerLat - deltaLat, centerHeight + radius),
      Cesium.Cartesian3.fromDegrees(centerLon - deltaLon, centerLat + deltaLat, centerHeight + radius),
      Cesium.Cartesian3.fromDegrees(centerLon + deltaLon, centerLat + deltaLat, centerHeight + radius)
    ]

    return vertices
  }

  // ================================
  // 获取网格边界框的8个顶点
  // ================================
  getGridBoundingBoxVertices (gridBounds) {
    const vertices = [
      // 底面4个顶点
      Cesium.Cartesian3.fromDegrees(gridBounds.minLon, gridBounds.minLat, gridBounds.minHeight),
      Cesium.Cartesian3.fromDegrees(gridBounds.maxLon, gridBounds.minLat, gridBounds.minHeight),
      Cesium.Cartesian3.fromDegrees(gridBounds.minLon, gridBounds.maxLat, gridBounds.minHeight),
      Cesium.Cartesian3.fromDegrees(gridBounds.maxLon, gridBounds.maxLat, gridBounds.minHeight),
      // 顶面4个顶点
      Cesium.Cartesian3.fromDegrees(gridBounds.minLon, gridBounds.minLat, gridBounds.maxHeight),
      Cesium.Cartesian3.fromDegrees(gridBounds.maxLon, gridBounds.minLat, gridBounds.maxHeight),
      Cesium.Cartesian3.fromDegrees(gridBounds.minLon, gridBounds.maxLat, gridBounds.maxHeight),
      Cesium.Cartesian3.fromDegrees(gridBounds.maxLon, gridBounds.maxLat, gridBounds.maxHeight)
    ]

    return vertices
  }

  // ================================
  // 检查两个轴对齐边界框（AABB）是否相交
  // ================================
  checkAABBIntersection (vertices1, vertices2) {
    // 将顶点转换为地理坐标进行比较
    const bounds1 = this.getVerticesBounds(vertices1)
    const bounds2 = this.getVerticesBounds(vertices2)

    // 3D AABB相交检测
    const tolerance = 0.0001

    const intersects = !(
      bounds1.maxLon < bounds2.minLon - tolerance ||
      bounds1.minLon > bounds2.maxLon + tolerance ||
      bounds1.maxLat < bounds2.minLat - tolerance ||
      bounds1.minLat > bounds2.maxLat + tolerance ||
      bounds1.maxHeight < bounds2.minHeight - tolerance ||
      bounds1.minHeight > bounds2.maxHeight + tolerance
    )

    return intersects
  }

  // ================================
  // 从顶点计算边界范围
  // ================================
  getVerticesBounds (vertices) {
    let minLon = Infinity, maxLon = -Infinity
    let minLat = Infinity, maxLat = -Infinity
    let minHeight = Infinity, maxHeight = -Infinity

    vertices.forEach(vertex => {
      const cartographic = Cesium.Cartographic.fromCartesian(vertex)
      const lon = Cesium.Math.toDegrees(cartographic.longitude)
      const lat = Cesium.Math.toDegrees(cartographic.latitude)
      const height = cartographic.height

      minLon = Math.min(minLon, lon)
      maxLon = Math.max(maxLon, lon)
      minLat = Math.min(minLat, lat)
      maxLat = Math.max(maxLat, lat)
      minHeight = Math.min(minHeight, height)
      maxHeight = Math.max(maxHeight, height)
    })

    return {
      minLon: minLon,
      maxLon: maxLon,
      minLat: minLat,
      maxLat: maxLat,
      minHeight: minHeight,
      maxHeight: maxHeight
    }
  }

  // ================================
  // 计算网格单元的边界范围
  // ================================
  calculateGridBounds (gridCenter) {
    const gridLon = Cesium.Math.toDegrees(gridCenter.longitude)
    const gridLat = Cesium.Math.toDegrees(gridCenter.latitude)
    const gridHeight = gridCenter.height

    // 计算网格单元的边界范围
    const earthRadius = 6371000
    const halfSize = this.gridSize / 2

    // 计算经纬度的半范围
    const deltaLon = halfSize / (earthRadius * Math.cos(gridCenter.latitude))
    const deltaLat = halfSize / earthRadius

    return {
      minLon: gridLon - Cesium.Math.toDegrees(deltaLon),
      maxLon: gridLon + Cesium.Math.toDegrees(deltaLon),
      minLat: gridLat - Cesium.Math.toDegrees(deltaLat),
      maxLat: gridLat + Cesium.Math.toDegrees(deltaLat),
      minHeight: gridHeight - halfSize,
      maxHeight: gridHeight + halfSize
    }
  }





  // ================================
  // 创建网格单元的边界框
  // ================================
  createGridBoundingBox (gridCenter) {
    // 将地理坐标转换为笛卡尔坐标
    const centerCartesian = Cesium.Cartesian3.fromRadians(
      gridCenter.longitude,
      gridCenter.latitude,
      gridCenter.height
    )

    // 创建半扩展向量
    const halfSize = this.gridSize / 2
    const halfExtents = new Cesium.Cartesian3(halfSize, halfSize, halfSize)

    return {
      center: centerCartesian,
      halfExtents: halfExtents
    }
  }

  // ================================
  // 检查两个边界框是否相交
  // ================================
  checkBoundingBoxIntersection (box1, box2) {
    // 计算两个边界框的最小和最大点
    const box1Min = Cesium.Cartesian3.subtract(box1.center, box1.halfExtents, new Cesium.Cartesian3())
    const box1Max = Cesium.Cartesian3.add(box1.center, box1.halfExtents, new Cesium.Cartesian3())

    const box2Min = Cesium.Cartesian3.subtract(box2.center, box2.halfExtents, new Cesium.Cartesian3())
    const box2Max = Cesium.Cartesian3.add(box2.center, box2.halfExtents, new Cesium.Cartesian3())

    // 检查在三个轴上是否都有重叠
    return (box1Min.x <= box2Max.x && box1Max.x >= box2Min.x &&
      box1Min.y <= box2Max.y && box1Max.y >= box2Min.y &&
      box1Min.z <= box2Max.z && box1Max.z >= box2Min.z)
  }

  // ================================
  // 创建网格立方体 - 使用配置的颜色和尺寸
  // ================================
  createGridCube (gridCenter, isOccupied, customGridSize = null, gridIndex = null) {
    // 将地理坐标转换为笛卡尔坐标
    const position = Cesium.Cartesian3.fromRadians(
      gridCenter.longitude,
      gridCenter.latitude,
      gridCenter.height
    )

    // 使用配置的颜色和透明度
    const color = isOccupied ?
      (this.config.occupiedColor || Cesium.Color.RED.withAlpha(this.config.occupiedAlpha)) :
      (this.config.freeColor || Cesium.Color.GREEN.withAlpha(this.config.freeAlpha))

    const outlineColor = isOccupied ?
      this.config.occupiedOutlineColor :
      this.config.freeOutlineColor

    // 使用自定义尺寸或配置的网格尺寸
    const gridSize = customGridSize || this.config.gridSize
    const dimensions = new Cesium.Cartesian3(
      this.config.gridWidth || gridSize,
      this.config.gridHeight || gridSize,
      this.config.gridDepth || gridSize
    )

    // 创建立方体实体
    const entity = this.viewer.entities.add({
      position: position,
      show: isOccupied ? this.gridParams.showOccupancy : this.gridParams.showIdle,
      box: {
        dimensions: dimensions,
        material: color,
        outline: true,
        outlineColor: outlineColor,
        outlineWidth: this.config.outlineWidth
      },
      // 添加占用状态标记，用于统计
      properties: {
        isOccupied: isOccupied,
        gridType: isOccupied ? 'occupied' : 'free',
        createdAt: new Date().toISOString(),
        gridIndex: gridIndex // 存储网格索引号
      }
    })

    this.gridEntities.push(entity)

    if (isOccupied && this.config.enableLogging) {
      const indexStr = gridIndex ? `索引[${gridIndex.x},${gridIndex.y},${gridIndex.z}] ` : ''
      console.log(`创建占用网格 ${indexStr}在位置: [${Cesium.Math.toDegrees(gridCenter.longitude).toFixed(6)}, ${Cesium.Math.toDegrees(gridCenter.latitude).toFixed(6)}, ${gridCenter.height.toFixed(1)}]`)
    }
  }

  // ================================
  // 清除网格
  // ================================
  clearGrid () {
    // 移除所有网格实体
    this.gridEntities.forEach(entity => {
      this.viewer.entities.remove(entity)
    })
    this.gridEntities = []

    // 清除瓦片边界框数据
    this.tilesBoundingBoxes = []

    console.log('已清除3D占用网格')
  }

  // ================================
  // 切换网格显示
  // ================================
  toggleGridVisibility (visible) {
    this.gridEntities.forEach(entity => {
      entity.show = visible
    })

    console.log(`3D占用网格${visible ? '显示' : '隐藏'}`)
  }

  // ================================
  // 获取网格统计信息 - 使用配置参数
  // ================================
  getGridStatistics () {
    const totalGrids = this.gridEntities.length
    const occupiedGrids = this.gridEntities.filter(entity =>
      entity.properties && entity.properties.isOccupied
    ).length
    const freeGrids = totalGrids - occupiedGrids
    const occupancyRate = totalGrids > 0 ? Math.round((occupiedGrids / totalGrids) * 100) : 0

    if (this.config.enableLogging) {
      console.log(`网格统计: 总计${totalGrids}, 占用${occupiedGrids}, 空闲${freeGrids}, 占用率${occupancyRate}%`)
      console.log(`网格配置: 尺寸${this.config.gridWidth}x${this.config.gridHeight}x${this.config.gridDepth}m, 扩展${this.config.heightExtension}m(垂直)/${this.config.widthExtension}m(水平)`)
    }

    return {
      total: totalGrids,
      occupied: occupiedGrids,
      free: freeGrids,
      occupancyRate: occupancyRate,
      config: this.getConfig()
    }
  }

  // ================================
  // 获取占用网格数量
  // ================================
  getOccupiedGridCount () {
    return this.gridEntities.filter(entity =>
      entity.properties && entity.properties.isOccupied
    ).length
  }

  // 只显示占用
  sheGridDisplay () {
    this.gridEntities.forEach(entity => {
      const isOccupied = entity.properties.isOccupied?._value
      entity.show = isOccupied ? this.gridParams.showOccupancy : this.gridParams.showIdle
    })
  }

  // ================================
  // 将OrientedBoundingBox转换为轴对齐边界框
  // ================================
  orientedBoundingBoxToAxisAligned (obb) {
    const center = obb.center
    const halfAxes = obb.halfAxes

    // 计算8个顶点
    const vertices = []
    const directions = [
      [-1, -1, -1], [-1, -1, 1], [-1, 1, -1], [-1, 1, 1],
      [1, -1, -1], [1, -1, 1], [1, 1, -1], [1, 1, 1]
    ]

    // 提取三个轴向的向量
    const xAxis = new Cesium.Cartesian3()
    const yAxis = new Cesium.Cartesian3()
    const zAxis = new Cesium.Cartesian3()
    Cesium.Matrix3.getColumn(halfAxes, 0, xAxis)
    Cesium.Matrix3.getColumn(halfAxes, 1, yAxis)
    Cesium.Matrix3.getColumn(halfAxes, 2, zAxis)

    directions.forEach(dir => {
      const vertex = Cesium.Cartesian3.clone(center)
      Cesium.Cartesian3.add(vertex, Cesium.Cartesian3.multiplyByScalar(xAxis, dir[0], new Cesium.Cartesian3()), vertex)
      Cesium.Cartesian3.add(vertex, Cesium.Cartesian3.multiplyByScalar(yAxis, dir[1], new Cesium.Cartesian3()), vertex)
      Cesium.Cartesian3.add(vertex, Cesium.Cartesian3.multiplyByScalar(zAxis, dir[2], new Cesium.Cartesian3()), vertex)
      vertices.push(vertex)
    })

    // 转换为地理坐标，找到边界范围
    let minLon = Infinity, maxLon = -Infinity
    let minLat = Infinity, maxLat = -Infinity
    let minHeight = Infinity, maxHeight = -Infinity

    vertices.forEach(vertex => {
      const cartographic = Cesium.Cartographic.fromCartesian(vertex)
      const lon = Cesium.Math.toDegrees(cartographic.longitude)
      const lat = Cesium.Math.toDegrees(cartographic.latitude)
      const height = cartographic.height

      minLon = Math.min(minLon, lon)
      maxLon = Math.max(maxLon, lon)
      minLat = Math.min(minLat, lat)
      maxLat = Math.max(maxLat, lat)
      minHeight = Math.min(minHeight, height)
      maxHeight = Math.max(maxHeight, height)
    })

    return {
      center: center,
      minLon: minLon,
      maxLon: maxLon,
      minLat: minLat,
      maxLat: maxLat,
      minHeight: minHeight,
      maxHeight: maxHeight
    }
  }

  // ================================
  // 将BoundingSphere转换为轴对齐边界框
  // ================================
  sphereToAxisAligned (sphere) {
    const center = sphere.center
    const radius = sphere.radius

    // 将球心转换为地理坐标
    const centerCartographic = Cesium.Cartographic.fromCartesian(center)
    const centerLon = Cesium.Math.toDegrees(centerCartographic.longitude)
    const centerLat = Cesium.Math.toDegrees(centerCartographic.latitude)
    const centerHeight = centerCartographic.height

    // 估算经纬度范围（简化处理）
    const deltaLon = radius / (111320 * Math.cos(centerCartographic.latitude)) // 经度差
    const deltaLat = radius / 110540 // 纬度差

    return {
      center: center,
      minLon: centerLon - deltaLon,
      maxLon: centerLon + deltaLon,
      minLat: centerLat - deltaLat,
      maxLat: centerLat + deltaLat,
      minHeight: centerHeight - radius,
      maxHeight: centerHeight + radius
    }
  }
}

export default OccupancyGrid