/**
 * @name: click
 * @author: Administrator
 * @date: 2023-05-28 11:05
 * @description：click
 * @update: 2023-05-28 11:05
 */
let leftClickHandler = null
let rightClickHandler = null
let MoveHandler = null
let leftClickCallbackMap = new Map()
let rightClickCallbackMap = new Map()
let MoveCallbackMap = new Map()
let selectedFeature;


function cartesian3Towgs84(cartesian, viewer) {
  var ellipsoid = viewer.scene.globe.ellipsoid
  var cartesian3 = new Cesium.Cartesian3(
    cartesian.x,
    cartesian.y,
    cartesian.z
  )
  var cartographic = ellipsoid.cartesianToCartographic(cartesian3)
  var lat = Cesium.Math.toDegrees(cartographic.latitude)
  var lng = Cesium.Math.toDegrees(cartographic.longitude)
  var alt = cartographic.height < 0 ? 0 : cartographic.height
  return {
    lng: lng,
    lat: lat,
    alt: alt,
  }
}

function getcartesian(sdk, movement) {
  if (movement.endPosition) {
    movement.endPosition.y -= 2
  }
  let position = movement.position || movement.endPosition
  // 获取世界坐标系地表坐标，考虑地形，不包括模型，倾斜摄影模型表面；
  let cartesian = sdk.viewer.scene.pickPosition(position)
  if (!cartesian) {
    const ray = sdk.viewer.camera.getPickRay(position); //相交的射线
    cartesian = sdk.viewer.scene.globe.pick(ray, sdk.viewer.scene);
  }
  return cartesian
}

function openLeftClick(sdk, cb) {
  if (!sdk || !sdk.viewer) {
    return
  }
  let click = true
  leftClickHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
  leftClickHandler.setInputAction((movement) => {
    let cartesian = sdk.viewer.scene.pickPosition(movement.position)
    if (!cartesian) {
      const ray = sdk.viewer.camera.getPickRay(movement.position); //相交的射线
      cartesian = sdk.viewer.scene.globe.pick(ray, sdk.viewer.scene);
    }
    if (!cartesian) {
      return
    }

    let pos84 = cartesian3Towgs84(cartesian, sdk.viewer)

    cb && cb(pos84)

    if (click) {
      click = false
      setTimeout(() => {
        click = true
      }, 600);
      if (!YJ.Measure.GetMeasureStatus() && cartesian) {
        let flag = false
        for (let i = leftClickCallbackMap.size - 1; i >= 0; i--) {
          let key = Array.from(leftClickCallbackMap.keys())[i]
          let obj = leftClickCallbackMap.get(key)
          if (obj) {

            if (obj.that) {
              // 是否为多边形
              if (obj.that.type === 'PolygonObject') {
                // 是否可点击y
                if (obj.that.picking) {
                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
                    let pt = turf.point([pos84.lng, pos84.lat]);
                    let polyPos = []
                    for (let i = 0; i < obj.that.options.positions.length; i++) {
                      polyPos.push([
                        obj.that.options.positions[i].lng,
                        obj.that.options.positions[i].lat
                      ])
                    }
                    polyPos.push([
                      obj.that.options.positions[0].lng,
                      obj.that.options.positions[0].lat
                    ])
                    let poly = turf.polygon([polyPos]);
                    let contain = turf.booleanPointInPolygon(pt, poly);
                    if (contain) {
                      obj.callback(
                        movement,
                        obj.that.options.id,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                      flag = true
                      break
                    }
                  }
                }
              }
              // 聚集地
              else if (obj.that.type === 'AssembleObject') {
                if (obj.that.picking) {
                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
                    let positions = obj.that.computeAssemble(obj.that.options.positions, true)
                    let pt = turf.point([pos84.lng, pos84.lat]);
                    let polyPos = []
                    for (let i = 0; i < positions.length; i += 2) {
                      polyPos.push([
                        positions[i],
                        positions[i + 1]
                      ])
                    }
                    let poly = turf.polygon([polyPos]);
                    let contain = turf.booleanPointInPolygon(pt, poly);
                    if (contain) {
                      obj.callback(
                        movement,
                        obj.that.options.id,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                      flag = true
                      break
                    }
                  }
                }
              }
              // 单箭头
              else if (obj.that.type === 'AttackArrowObject') {
                if (obj.that.picking) {
                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
                    let pt = turf.point([pos84.lng, pos84.lat]);
                    let positions = obj.that.computeAttackArrow(obj.that.options.positions)
                    let polyPos = []
                    for (let m = 0; m < positions.length; m++) {
                      let pos84 = cartesian3Towgs84(positions[m], sdk.viewer)
                      polyPos.push([pos84.lng, pos84.lat])
                    }
                    let poly = turf.polygon([polyPos]);
                    let contain = turf.booleanPointInPolygon(pt, poly);
                    if (contain) {
                      obj.callback(
                        movement,
                        obj.that.options.id,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                      flag = true
                      break
                    }
                  }
                }
              }
              // 双箭头
              else if (obj.that.type === 'PincerArrowObject') {
                if (obj.that.picking) {
                  if (obj.that.options.positions && obj.that.options.positions.length >= 5) {
                    let pt = turf.point([pos84.lng, pos84.lat]);
                    let positions = obj.that.computePincerArrow(obj.that.options.positions)
                    let polyPos = []
                    for (let m = 0; m < positions.length; m++) {
                      let pos84 = cartesian3Towgs84(positions[m], sdk.viewer)
                      polyPos.push([pos84.lng, pos84.lat])
                    }
                    let pos84_0 = cartesian3Towgs84(positions[0], sdk.viewer)
                    polyPos.push([pos84_0.lng, pos84_0.lat])
                    let poly = turf.polygon([polyPos]);
                    let contain = turf.booleanPointInPolygon(pt, poly);
                    if (contain) {
                      obj.callback(
                        movement,
                        obj.that.options.id,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                      flag = true
                      break
                    }
                  }
                }
              }
              // 圆
              else if (obj.that.type === 'CircleObject') {
                if (obj.that.picking) {
                  let pt = turf.point([pos84.lng, pos84.lat]);
                  if (obj.that.options.center && obj.that.options.radius) {
                    let center = [obj.that.options.center.lng, obj.that.options.center.lat];
                    let radius = obj.that.options.radius / 1000;
                    let options = { steps: 360, units: 'kilometers' };
                    let circle = turf.circle(center, radius, options);
                    let contain = turf.booleanPointInPolygon(pt, circle);
                    if (contain) {
                      obj.callback(
                        movement,
                        obj.that.options.id,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                      flag = true
                      break
                    }
                  }

                }
              }
              // 扇形
              else if (obj.that.type === 'SectorObject') {
                if (obj.that.picking) {
                  let pt = turf.point([pos84.lng, pos84.lat]);
                  if (obj.that.options.center && obj.that.options.radius && obj.that.options.startAngle && obj.that.options.endAngle) {
                    let positions = obj.that.calSector(obj.that.options.center, obj.that.options.radius, obj.that.options.startAngle, obj.that.options.endAngle, undefined, true)
                    let polyPos = []
                    for (let m = 0; m < positions.length; m++) {
                      polyPos.push([positions[m].lng, positions[m].lat])
                    }
                    let poly = turf.polygon([polyPos]);
                    let contain = turf.booleanPointInPolygon(pt, poly);
                    if (contain) {
                      obj.callback(
                        movement,
                        obj.that.options.id,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                      flag = true
                      break
                    }
                  }

                }
              }
            }
          }
        }
        if (!flag) {
          const pick = sdk.viewer.scene.pick(movement.position)
          if (pick) {
            if (pick.id) {
              let entityId
              // 矢量
              if (pick.id.type && pick.id.type === 'vector' && pick.id.parentId) {
                let obj = leftClickCallbackMap.get(pick.id.parentId)
                if (obj.that.picking && obj.that.geojson) {
                  for (let i = 0; i < obj.that.geojson.features.length; i++) {
                    if (obj.that.geojson.features[i].id === pick.id._id) {
                      obj.callback(
                        movement,
                        obj.that.geojson.features[i].id,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                    }
                  }
                }
              }
              else if (typeof pick.id.id == 'string') {
                let array = pick.id.id.split('-')
                array.splice(array.length - 1, 1)
                entityId = array.join('-')
              }

              if (pick.id.properties && pick.id.properties.id && leftClickCallbackMap.has(pick.id.properties.id._value)) {
                let obj = leftClickCallbackMap.get(pick.id.properties.id._value)
                if (obj.that.picking) {
                  obj.callback(
                    movement,
                    pick.id.properties.id._value,
                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                }
              }
              else if (leftClickCallbackMap.has(pick.id.id)) {
                let obj = leftClickCallbackMap.get(pick.id.id)
                if (obj.that.picking) {
                  obj.callback(
                    movement,
                    pick.id.id,
                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                }
              }
              else if (entityId && leftClickCallbackMap.has(entityId)) {
                let obj = leftClickCallbackMap.get(entityId)
                if (obj.that.picking) {
                  obj.callback(
                    movement,
                    entityId,
                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                }
              }
              else if (pick.primitive) {
                if (typeof pick.id == 'string' && leftClickCallbackMap.has(pick.id)) {
                  let obj = leftClickCallbackMap.get(pick.id)
                  obj.callback(
                    movement,
                    pick.id,
                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                }
              }
            }
            else {
              if (pick.primitive && pick.primitive.id) {
                if (leftClickCallbackMap.has(pick.primitive.id)) {
                  let obj = leftClickCallbackMap.get(pick.primitive.id)
                  if (obj.that.picking) {
                    if (obj.that.type === 'bim') {
                      if (YJ.Global.getBimPickStatus(sdk)) {
                        obj.callback(
                          movement,
                          pick.primitive,
                          cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                      }
                    }
                    else {
                      obj.callback(
                        movement,
                        pick.primitive.id,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                    }
                  }
                }
              }
            }
            if (pick.content && (!pick.primitive || !pick.primitive.id)) {
              if (leftClickCallbackMap.has(pick.content.tileset.id)) {
                let obj = leftClickCallbackMap.get(pick.content.tileset.id)
                if (obj.that.picking) {
                  if (obj.that.type === 'bim') {
                    if (YJ.Global.getBimPickStatus(sdk)) {
                      obj.callback(
                        movement,
                        pick.content.tileset,
                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                    }
                  }
                  else {
                    obj.callback(
                      movement,
                      pick.content.tileset.id,
                      cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
                  }
                }
              }
            }
          }
        }
      }
    }


    // if (click) {
    //   click = false
    //   setTimeout(() => {
    //     click = true
    //   }, 300);
    //   if (!YJ.Measure.GetMeasureStatus()) {

    //   }
    // }
  }, Cesium.ScreenSpaceEventType.LEFT_CLICK)

  // leftClickHandler.setInputAction(function (movement) {
  //   const feature = sdk.viewer.scene.pick(movement.endPosition);
  //   // unselectFeature(selectedFeature);
  //   if (selectedFeature) {
  //     selectedFeature.color = Cesium.Color.WHITE;
  //   }
  //   selectedFeature = feature
  //   if (feature) {
  //     feature.color = Cesium.Color.YELLOW;
  //   }
  // }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
  // }

}

function closeLeftClick(sdk) {
  leftClickHandler.destroy() //关闭事件句柄
  leftClickHandler = null
  // }
}

function openRightClick(sdk) {
  if (!sdk || !sdk.viewer) {
    return
  }
  rightClickHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
  rightClickHandler.setInputAction((movement) => {
    if (!YJ.Measure.GetMeasureStatus()) {
      const pick = sdk.viewer.scene.pick(movement.position)
      if (pick && pick.id) {
        let id
        if (pick.id.type && pick.id.type === 'vector' && pick.id.parentId) {
          let obj = rightClickCallbackMap.get(pick.id.parentId)
          if (obj.that.picking && obj.that.geojson) {
            for (let i = 0; i < obj.that.geojson.features.length; i++) {
              if (obj.that.geojson.features[i].id === pick.id._id) {
                obj.callback(
                  movement,
                  obj.that.geojson.features[i].id,
                  cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
              }
            }
          }
        }
        else {
          if (typeof pick.id === 'string') {
            id = pick.id
          }
          else {
            id = pick.id.id
          }
          if (rightClickCallbackMap.has(id)) {
            let obj = rightClickCallbackMap.get(id)
            if (obj.that.picking) {
              let cartesian = getcartesian(sdk, movement)
              if (!cartesian) {
                return
              }
              obj.callback(
                movement,
                id,
                cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
            }
          }
        }
      }
      if (pick && pick.content) {
        if (rightClickCallbackMap.has(pick.content.tileset.id)) {
          let obj = rightClickCallbackMap.get(pick.content.tileset.id)
          if (obj.that.picking) {
            if (obj.that.type === 'bim') {
              if (YJ.Global.getBimPickStatus(sdk)) {
                let cartesian = getcartesian(sdk, movement)
                if (!cartesian) {
                  return
                }
                obj.callback(
                  movement,
                  pick.getProperty('id'),
                  cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
              }
            }
            else {
              let cartesian = getcartesian(sdk, movement)
              if (!cartesian) {
                return
              }
              obj.callback(
                movement,
                pick.content.tileset.id,
                cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
            }
          }
        }
      }
    }
  }, Cesium.ScreenSpaceEventType.RIGHT_CLICK)
}

function closeRightClick() {
  if (rightClickHandler) {
    rightClickHandler.destroy() //关闭事件句柄
    rightClickHandler = null
  }
}

function openMove(sdk) {
  MoveHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
  MoveHandler.setInputAction(function (movement) {
    const pick = sdk.viewer.scene.pick(movement.endPosition);
    // unselectFeature(selectedFeature);
    // if (selectedFeature) {
    //   let color = '#fff'
    //   let state = selectedFeature.getProperty('state')
    //   switch (state) {
    //     case '0':
    //       color = '#fff'
    //       break;
    //     case '1':
    //       color = '#f00'
    //       break;
    //     case '2':
    //       color = '#0f0'
    //       break;
    //     case '3':
    //       color = '#00f'
    //       break;
    //     default:
    //   }
    //   selectedFeature.color = Cesium.Color.fromCssColorString(color).withAlpha(selectedFeature.tileset.transparency)
    // }
    // if (pick && pick.id) { }
    // if (pick && pick.content) {
    //   if (MoveCallbackMap.has(pick.content.tileset.id)) {
    //     let obj = MoveCallbackMap.get(pick.content.tileset.id)
    //     if (obj.that.picking) {
    //       if (obj.that.type === 'bim') {
    //         if (YJ.Global.getBimPickStatus(sdk)) {
    //           selectedFeature = pick
    //           pick.color = Cesium.Color.YELLOW;
    //         }
    //         else {
    //           selectedFeature = null
    //         }
    //       }
    //       else {
    //         selectedFeature = pick
    //         pick.color = Cesium.Color.YELLOW;
    //       }
    //     }
    //     else {
    //       selectedFeature = null
    //     }
    //   }
    // }
  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
}

function closeMove() {
  if (MoveHandler) {
    MoveHandler.destroy() //关闭事件句柄
    MoveHandler = null
  }
}

/*注册左键回调*/
function regLeftClickCallback(id, callback, that) {

  leftClickCallbackMap.set(id, { callback, that })
}/*取消左键回调*/
function unRegLeftClickCallback(id,) {
  leftClickCallbackMap.delete(id,)
}

/*注册右键回调*/
function regRightClickCallback(id, callback, that) {
  rightClickCallbackMap.set(id, { callback, that })
}/*取消右键回调*/
function unRegRightClickCallback(id,) {
  rightClickCallbackMap.delete(id,)
}

/*注册左键回调*/
function regMoveCallback(id, callback, that) {
  MoveCallbackMap.set(id, { callback, that })
}/*取消左键回调*/
function unregMoveCallback(id,) {
  MoveCallbackMap.delete(id,)
}

function getLeftClickState() {
  if (leftClickHandler) {
    return true
  }
  else {
    false
  }
}

function getRightClickState() {
  if (rightClickHandler) {
    return true
  }
  else {
    false
  }
}

function getMoveState() {
  if (MoveHandler) {
    return true
  }
  else {
    false
  }
}


export { openLeftClick, closeLeftClick, regLeftClickCallback, unRegLeftClickCallback, openRightClick, closeRightClick, regRightClickCallback, unRegRightClickCallback, openMove, closeMove, regMoveCallback, unregMoveCallback, getLeftClickState, getRightClickState, getMoveState }