import * as THREE from 'three'
import type Viewport from '@/core/engine/Viewport'
import type BaseRenderer from '@/core/base/BaseRenderer'
import { getRenderer } from './ModuleManager'
import { getClosestObject, getLineId, parseLineId } from '@/core/ModelUtils'
import { Vector2 } from 'three'

/**
 * 实体管理器
 * 缓存所有 数据(ItemJson)和他们的关系, 以及渲染对象 THREE.Object3D
 * 数据更新的流程是:
 * 1. 状态管理器 StateManager 发出数据被修改的请求, 这些请求通常只有 ItemJson 数据
 * 2. 实体管理器 (EntityManager) 需要计算所有相关的点和线的变化. 在 endUpdate 时需要根据 center / in / out 关系, 计算出: 点的创建 / 点的更新 / 点的删除 / 线的创建 / 线的更新 / 线的删除
 * 3. 通知对应的渲染器 (Renderer) 进行点和线的创建 / 更新 / 删除
 */
export default class EntityManager {
  viewport: Viewport

  // 所有数据点的实体
  private readonly entities = new Map<string, ItemJson>()

  // 关系索引
  private readonly relationIndex = new Map<string, Relation>()

  // 所有 THREEJS "点"对象, 检索值是"点实体"的 id, 值是 THREE.Object3D 数组
  private readonly objects = new Map<string, THREE.Object3D[]>()

  // 所有 THREEJS "可选中"对象, 检索值是"点实体"的 id, 值是 THREE.Object3D 数组
  private readonly _selectableObjects: THREE.Object3D[] = []

  // 所有 THREEJS "线"对象, 检索值是"线实体"的 id, 取值方式是 {type}${startId}${endId}, 值是 THREE.Object3D 数组
  private readonly lines = new Map<string, THREE.Object3D[]>()

  // 差量渲染器
  private readonly diffRenderer = new Map<string, BaseRenderer>()
  // 线差量记录
  private readonly lineDiffs = {
    create: new Map<string, LineDiffItem>(),
    update: new Map<string, LineDiffItem>(),
    delete: new Map<string, LineDiffItem>()
  }
  // 记录所有发生过变化的实体, 用于在 endEntityUpdate 时进行写回给 StateManager
  private readonly writeBackEntities = new Set<string>()
  isUpdating = false

  dispose() {
    // 清理所有差量渲染器
    for (const renderer of this.diffRenderer.values()) {
      renderer.dispose()
    }
    this.diffRenderer.clear()

    // 清理所有实体和关系索引
    this.entities.clear()
    this.relationIndex.clear()
    this.objects.clear()
    this.lines.clear()
    this.writeBackEntities.clear()
  }

  /**
   * 克隆需要回写的实体集合
   */
  cloneWriteBackEntities(): Map<string, ItemJson> {
    const entities = new Map<string, ItemJson>()
    for (const id of this.writeBackEntities) {
      const entity = this.entities.get(id)
      if (!entity) continue
      entities.set(id, _.cloneDeep(entity))
    }
    console.log('需要回写', entities.size, '行数据')
    return entities
  }

  init(viewport: Viewport) {
    this.viewport = viewport
  }

  /**
   * 批量更新开始
   */
  beginEntityUpdate(): void {
    this.isUpdating = true
    this.viewport.beginViewUpdate()
    this.writeBackEntities.clear()
    this.diffRenderer.clear()
    this.lineDiffs.create.clear()
    this.lineDiffs.update.clear()
    this.lineDiffs.delete.clear()
  }

  /**
   * 创建或更新一个实体, 这个点的 center[] / in[] / out[] 关联的点, 可能都要对应进行关联
   */
  createOrUpdateEntity(entityRaw: ItemJson, option: EntityCudOption = {}): void {
    if (!entityRaw?.id) {
      throw new Error('Entity must have an id')
    }
    const entity = _.cloneDeep(entityRaw) as ItemJson
    const originEntity = this.entities.get(entity.id)

    // 找到这个数据的渲染器
    const renderer = this.getDiffRenderer(entity.t)

    // 先判断坐标是否变化
    const coordinateChanged = originEntity?.tf && entity?.tf && !_.isEqual(originEntity.tf[0], entity.tf[0])
    this.entities.set(entity.id, entity)

    // 更新关系网
    this.updateRelations(entity, originEntity)

    if (coordinateChanged) {
      this.writeBackEntities.add(entity.id)
      // 点的坐标发生变化, 要通知所有关联线更新
      const relation = this.relationIndex.get(entity.id)

      if (relation) {
        for (const type of (['center', 'in', 'out'] as LinkType[])) {
          const relatedIds = relation[type]
          if (!relatedIds) continue

          for (const relatedId of relatedIds) {
            const lineId = getLineId(entity.id, relatedId, type)
            console.log(`[update] ${entity.id} -> ${relatedId} [${type}] => ${lineId}`)
            this.lineDiffs.update.set(lineId, { startId: entity.id, endId: relatedId, type })

            this.writeBackEntities.add(relatedId)

            // 如果是双向线（比如 center），也要反向加一次
            if (type === 'center') {
              this.lineDiffs.update.set(lineId, { startId: relatedId, endId: entity.id, type })
            }
          }
        }
      }
    }

    if (typeof originEntity === 'undefined') {
      renderer.createPoint(entity, option as RendererCudOption)

    } else {
      option.originEntity = _.cloneDeep(originEntity)
      renderer.updatePoint(entity, option as RendererCudOption)
    }
  }

  /**
   * 删除实体, 与这个点有关的所有线都要删除, 与这个点有关系的点,都要对应的 center[] / in[] / out[] 都要断绝关系
   */
  deleteEntity(id: string, option: EntityCudOption = {}): void {
    const entity = this.entities.get(id)
    if (!entity) return

    option.originEntity = _.cloneDeep(entity)
    this.writeBackEntities.add(id)

    // 先生成线差量，再清理关系
    this.generateLineDiffsForDelete(id)
    this.removeRelations(id)      // 清理关系
    this.entities.delete(id)      // 删除实体

    this.getDiffRenderer(entity.t).deletePoint(id, option as RendererCudOption)
  }

  generateLineDiffsForDelete(id: string): void {
    const relations = this.relationIndex.get(id)
    if (!relations) return

    const removeLine = (relatedId: string, type: LinkType) => {
      const lineId = getLineId(id, relatedId, type)
      this.writeBackEntities.add(relatedId)
      this.lineDiffs.delete.set(lineId, { startId: id, endId: relatedId, type })
    }

    relations.center.forEach(relatedId => removeLine(relatedId, 'center'))
    relations.input.forEach(relatedId => removeLine(relatedId, 'in'))
    relations.output.forEach(relatedId => removeLine(relatedId, 'out'))
  }

  /**
   * 批量更新结束, 结束后会触发视窗的渲染
   *  这个方法最重要的是进行连线逻辑的处理
   *  - 如果进行了添加, 那么这个点的 center[] / in[] / out[] 关联的点, 都要对应进行关联
   *  - 如果进行了删除, 与这个点有关的所有线都要删除, 与这个点有关系的点,都要对应的 center[] / in[] / out[] 都要断绝关系
   *  - 如果进行了更新, 如果改了颜色/位置, 则需要在UI上进行对应修改，如果改了关系，需要与关联的节点批量调整
   *  将影响到的所有数据, 都变成一个修改集合, 统一调用对应单元类型渲染器(BaseRenderer)的 createPoint / deletePoint / updatePoint / createLine / updateLine / deleteLine 方法
   */
  endEntityUpdate(): void {
    for (const [itemTypeName, renderer] of this.diffRenderer.entries()) {
      // "线"创建
      for (const [lineId, lineDiffItem] of this.lineDiffs.create.entries()) {
        const start = this.entities.get(lineDiffItem.startId)
        const end = this.entities.get(lineDiffItem.endId)

        // 添加存在性检查
        if (!start || !end) {
          system.showErrorDialog(`无法创建线 ${lineId}, 起点或终点不存在`)
          continue
        }

        if (start.t !== itemTypeName) {
          // 只通知起点对应的渲染器
          continue
        }
        renderer.createLine(start, end, lineDiffItem.type)
      }

      // "线"更新
      for (const [lineId, lineDiffItem] of this.lineDiffs.update.entries()) {
        const start = this.entities.get(lineDiffItem.startId)
        const end = this.entities.get(lineDiffItem.endId)

        // 添加存在性检查
        if (!start || !end) {
          system.showErrorDialog(`无法更新线 ${lineId}, 起点或终点不存在`)
          continue
        }

        if (start.t !== itemTypeName) {
          // 只通知起点对应的渲染器
          console.error(`Line ${lineId} start point type mismatch: expected ${itemTypeName}, got ${start.t}`)
          continue
        }
        renderer.updateLine(start, end, lineDiffItem.type)
      }

      // "线"删除
      for (const [lineId, lineDiffItem] of this.lineDiffs.delete.entries()) {
        const start = this.entities.get(lineDiffItem.startId)
        const end = this.entities.get(lineDiffItem.endId)

        if (!start || !end) {
          // 即使实体不存在也要处理删除
          renderer.deleteLine(
            start || { id: lineDiffItem.startId, t: 'unknown' } as ItemJson,
            end || { id: lineDiffItem.endId, t: 'unknown' } as ItemJson,
            lineDiffItem.type)
          continue
        }

        if (start.t !== itemTypeName) {
          // 只通知起点对应的渲染器
          continue
        }

        // 使用安全删除方法, 即使实体不存在也要处理删除
        renderer.deleteLine(start, end, lineDiffItem.type)
      }

      renderer.endRendererUpdate()
    }

    // 将 lineDiffs 中新的关系网数据, 更新到实体点里
    const needUpdateIds = new Set<string>()
    for (const [lineId, lineDiffItem] of this.lineDiffs.create.entries()) {
      needUpdateIds.add(lineDiffItem.startId)
      needUpdateIds.add(lineDiffItem.endId)
    }
    for (const [lineId, lineDiffItem] of this.lineDiffs.update.entries()) {
      needUpdateIds.add(lineDiffItem.startId)
      needUpdateIds.add(lineDiffItem.endId)
    }
    for (const [lineId, lineDiffItem] of this.lineDiffs.delete.entries()) {
      needUpdateIds.add(lineDiffItem.startId)
      needUpdateIds.add(lineDiffItem.endId)
    }
    for (const id of needUpdateIds) {
      const entity = this.entities.get(id)
      if (entity) {
        entity.dt.center = Array.from(this.relationIndex.get(id)?.center || [])
        entity.dt.in = Array.from(this.relationIndex.get(id)?.input || [])
        entity.dt.out = Array.from(this.relationIndex.get(id)?.output || [])
      }
    }

    this.viewport.endViewUpdate()
    this.isUpdating = false
  }

  /**
   * 更新关系关系网, 计算出差值, 可以临时放在 diffRenderer 中, 等待 commitUpdate 时统一处理
   */
  private updateRelations(entity: ItemJson, originEntity?: ItemJson): void {
    const { id, dt } = entity
    if (!id || !dt) return

    const oldCenter = new Set(originEntity?.dt?.center || [])
    const oldIn = new Set(originEntity?.dt?.in || [])
    const oldOut = new Set(originEntity?.dt?.out || [])

    const newCenter = new Set(dt.center || [])
    const newIn = new Set(dt.in || [])
    const newOut = new Set(dt.out || [])

    // 更新正向关系
    const relations = this.relationIndex.get(id) || new Relation()
    relations.center = newCenter
    relations.input = newIn
    relations.output = newOut
    this.relationIndex.set(id, relations)

    // 更新反向关系
    this.updateReverseRelations(id, oldCenter, newCenter, 'center')
    this.updateReverseRelations(id, oldIn, newIn, 'out')   // 入边的反向是出边
    this.updateReverseRelations(id, oldOut, newOut, 'in')  // 出边的反向是入边

    // 更新线差量
    this.calculateLineDiffs(id, oldCenter, newCenter, 'center')
    this.calculateLineDiffs(id, oldIn, newIn, 'in')
    this.calculateLineDiffs(id, oldOut, newOut, 'out')
  }

  private updateReverseRelations(id: string, oldIds: Set<string>, newIds: Set<string>, relationType: LinkType) {
    // 确保关系索引存在
    if (!this.relationIndex.has(id)) {
      this.relationIndex.set(id, new Relation())
    }

    // 移除旧关系
    for (const relatedId of oldIds) {
      if (!newIds.has(relatedId)) {
        const rev = this.relationIndex.get(relatedId)
        rev.delete(relationType, id)
        this.writeBackEntities.add(relatedId)
      }
    }

    // 添加新关系
    for (const relatedId of newIds) {
      if (!oldIds.has(relatedId)) {
        let rev = this.relationIndex.get(relatedId)
        if (!rev) {
          rev = new Relation()
          this.relationIndex.set(relatedId, rev)
        }
        rev.add(relationType, id)
        this.writeBackEntities.add(relatedId)
      }
    }
  }

  private calculateLineDiffs(id: string, oldIds: Set<string>, newIds: Set<string>, lineType: LinkType) {
    // 确保关系索引存在
    if (!this.relationIndex.has(id)) return

    // 删除被移除的线
    for (const relatedId of oldIds) {
      if (!newIds.has(relatedId)) {
        const lineId = getLineId(id, relatedId, lineType)

        // 如果这条线已经在 update 列表中，则跳过 delete
        if (this.lineDiffs.update.has(lineId)) continue
        console.log(`[delete] ${id} -> ${relatedId} [${lineType}] => ${lineId}`)
        this.lineDiffs.delete.set(lineId, { startId: id, endId: relatedId, type: lineType })
      }
    }

    // 新增新增的线
    for (const relatedId of newIds) {
      if (!oldIds.has(relatedId)) {
        const lineId = getLineId(id, relatedId, lineType)

        // 如果这条线已经在 update 列表中，则跳过 create
        if (this.lineDiffs.update.has(lineId)) continue

        this.lineDiffs.create.set(lineId, { startId: id, endId: relatedId, type: lineType })
      }
    }
  }


  /**
   * 删除关系关系网, 计算出差值, 可以临时放在 diffRenderer 中, 等待 commitUpdate 时统一处理
   */
  private removeRelations(id: string): void {
    const relations = this.relationIndex.get(id)
    if (!relations) return

    relations.center.forEach(relatedId => {
      const rev = this.relationIndex.get(relatedId)
      if (rev) rev.center.delete(id)
      this.writeBackEntities.add(relatedId)
    })

    relations.input.forEach(relatedId => {
      const rev = this.relationIndex.get(relatedId)
      if (rev) rev.output.delete(id)
      this.writeBackEntities.add(relatedId)
    })

    relations.output.forEach(relatedId => {
      const rev = this.relationIndex.get(relatedId)
      if (rev) rev.input.delete(id)
      this.writeBackEntities.add(relatedId)
    })

    this.relationIndex.delete(id)
  }

  private getDiffRenderer(type: string) {
    let renderer = this.diffRenderer.get(type)
    if (typeof renderer === 'undefined') {
      renderer = getRenderer(type)
      renderer.beginRendererUpdate(this.viewport)
      this.diffRenderer.set(type, renderer)
    }
    return renderer
  }


  // /**
  //  * 重命名一个点
  //  * 注意, 不能在更新时刻改名. 所有的关系节点都应该改名
  //  */
  // renamePoint(newId: string, originId: string) {
  //   if (this.isUpdating) {
  //     throw new Error('Cannot rename point during update')
  //   }
  //   const entity = this.entities.get(originId)
  //   if (!entity) {
  //     throw new Error(`Entity with id ${originId} does not exist`)
  //   }
  //   if (this.entities.has(newId)) {
  //     throw new Error(`Entity with id ${newId} already exists`)
  //   }
  //   entity.id = newId
  //   this.entities.set(newId, entity)
  //   this.entities.delete(originId)
  //   this.objects.set(newId, this.objects.get(originId) || [])
  //   this.objects.delete(originId)
  //
  //   // 更新关系索引
  //   const relations = this.relationIndex.get(originId)
  //   if (relations) {
  //     this.relationIndex.delete(originId)
  //
  //     // 更新所有关系中的 id
  //     relations.center.forEach((relatedId) => {
  //       const rev = this.relationIndex.get(relatedId)
  //       if (rev && rev.delete('center', originId)) {
  //         rev.add('center', newId)
  //       }
  //     })
  //     relations.input.forEach((relatedId) => {
  //       const rev = this.relationIndex.get(relatedId)
  //       if (rev && rev.delete('out', originId)) {
  //         rev.add('out', newId)
  //       }
  //     })
  //     relations.output.forEach((relatedId) => {
  //       const rev = this.relationIndex.get(relatedId)
  //       if (rev && rev.delete('in', originId)) {
  //         rev.add('in', newId)
  //       }
  //     })
  //
  //     this.relationIndex.set(newId, relations)
  //   }
  //
  //   // 更新所有线段数据
  //   for (const [lineId, lineObjects] of this.lines.entries()) {
  //     const [type, startId, endId] = parseLineId(lineId)
  //     if (startId === originId) {
  //       const newLineId = getLineId(newId, endId, type)
  //       this.lines.set(newLineId, lineObjects)
  //       this.lines.delete(lineId)
  //
  //     } else if (endId === originId) {
  //       const newLineId = getLineId(startId, newId, type)
  //       this.lines.set(newLineId, lineObjects)
  //       this.lines.delete(lineId)
  //     }
  //   }
  // }

  deleteEntityOnly(id: string) {
    return this.entities.delete(id)
  }

  findObjectsById(id: string) {
    return this.objects.get(id) || []
  }

  deleteObjectsOnly(id: string) {
    // 删除对象时，也需要从 _selectableObjects 中移除
    const rel = this.objects.get(id)
    if (rel) {
      _.remove(this._selectableObjects, obj => !rel.includes(obj))
    }
    return this.objects.delete(id)
  }

  appendObject(id: string, points: THREE.Object3D[]) {
    this.objects.set(id, points)
    // 如果是可选中对象，添加到 _selectableObjects 中
    if (points.some(obj => obj.userData.selectable !== false)) {
      this._selectableObjects.push(...points)
    }
  }

  appendLineObject(id: string, lines: THREE.Object3D[]) {
    this.lines.set(id, lines)
    // 如果是可选中对象，添加到 _selectableObjects 中
    if (lines.some(obj => obj.userData.selectable !== false)) {
      this._selectableObjects.push(...lines)
    }
  }

  findLineObjectsById(lineId: string): THREE.Object3D[] {
    return this.lines.get(lineId) || []
  }

  deleteLineObjectOnly(id: string) {
    // 删除线对象时，也需要从 _selectableObjects 中移除
    const rel = this.lines.get(id)
    if (rel) {
      _.remove(this._selectableObjects, obj => !rel.includes(obj))
    }
    return this.lines.delete(id)
  }

  /**
   * 根据 linkStartPointId 查找对应的 ItemJson
   */
  findItemById(linkStartPointId: string): ItemJson | undefined {
    if (!linkStartPointId) {
      return
    }
    return this.entities.get(linkStartPointId)
  }

  getObjectByCanvasMouse(event: MouseEvent): THREE.Object3D[] {
    const _domElement = this.viewport.renderer.domElement
    const rect = _domElement.getBoundingClientRect()
    const _pointer = new Vector2()
    _pointer.x = (event.clientX - rect.left) / rect.width * 2 - 1
    _pointer.y = -(event.clientY - rect.top) / rect.height * 2 + 1
    this.viewport.raycaster.setFromCamera(_pointer, this.viewport.camera)
    const _intersections = this.viewport.raycaster.intersectObjects(this._selectableObjects, true)

    if (!_intersections || _intersections.length === 0) {
      return []
    }

    // 根据距离排序射线命中的对象集
    return _.map(
      _intersections.sort((a, b) => a.distance - b.distance),
      r => getClosestObject(r.object)
    ).filter(obj => obj?.userData && obj.userData.selectable !== false)
  }

  /**
   * 获取指定范围内的所有对象
   */
  getObjectsInBox(startX: number, startZ: number, endX: number, endZ: number) {
    const box = new THREE.Box2(
      new THREE.Vector2(startX, startZ),
      new THREE.Vector2(endX, endZ)
    )
    const objectsInBox: THREE.Object3D[] = []

    for (const [id, objects] of this.objects.entries()) {
      for (const obj of objects) {
        if (box.containsPoint(new Vector2(obj.position.x, obj.position.z))) {
          objectsInBox.push(obj)
        }
      }
    }

    return objectsInBox
  }
}

interface LineDiffItem {
  startId: string
  endId: string
  type: LinkType
}


/**
 * 关系详情
 */
export class Relation {
  center = new Set<string>()
  input = new Set<string>()
  output = new Set<string>()

  add(type: LinkType, id: string) {
    if (type === 'in')
      return this.input.add(id)
    else if (type === 'out')
      return this.output.add(id)
    else if (type === 'center')
      return this.center.add(id)
    else
      throw new Error(`Unknown link type: ${type}`)
  }

  delete(type: LinkType, id: string) {
    if (type === 'in')
      return this.input.delete(id)
    else if (type === 'out')
      return this.output.delete(id)
    else if (type === 'center')
      return this.center.delete(id)
    else
      throw new Error(`Unknown link type: ${type}`)
  }
}