import { CameraInfo, PathStyle, Weather, AreaStyle, EntityType } from '../export/BasicClass'
import { color2RGBValue, color2RGBAValue } from './ColorTrans'
import { fun4_1_1 } from './WYAdapterOtherVersion'

/**
 * @class WYAdapter
 * @classdesc superapi接口类
 */
export default class WYAdapter {
  constructor(div, url, key) {
    this.div = div
    this.url = url
    this.key = key
    this.cloudRender = null
  }
  /**
   * 初始化实例
   * @param {function} callback 回调函数
   */
  initialInstance(callback) {
    this.cloudRender = new cloudRenderer(this.div, 0)
    let cloudurl = this.url, //云渲染服务地址, 8889:固定端口
      orderID = this.key //渲染口令, 在云渲染客户端上获得

    fetch(`${cloudurl}/Renderers/Any/order`, {
      method: 'POST',
      headers: { 'Content-type': 'application/json' },
      body: JSON.stringify({ order: orderID, width: window.innerWidth, height: window.innerHeight })
    })
      .then((res) => {
        if (!res.ok) {
          throw Error(res.statusText)
        }
        return res.json()
      })
      .then((json) => {
        if (json.url) {
          //启动云渲染
          this.cloudRender.SuperAPI('StartRenderCloud', json.url)
          this.cloudRender.SuperAPI('superAPIinfo', (e) => {
            var obj = JSON.parse(e)
            this.sceneVertion = obj.superAPI_scene_plugins
          })

          this.cloudRender.SuperAPI('RegisterCloudResponse', this.handleResponseFunction)

          callback(this.cloudRender)
        }
      })
      .catch((error) => {
        console.error('Error: ', error)
      })
  }
  /**
   * 加载场景
   * @param {function} callback 回调函数
   */
  loadScene(scenename = null, callback) {
    window.sceneloaded = new CustomEvent('valueChange', {
      detail: { loaded: true }
    })

    window.addEventListener('valueChange', function (e) {
      // console.log(e)
      callback(e)
    })
  }
  handleResponseFunction(data) {
    const jsonObject = typeof data === 'object' ? JSON.parse(JSON.stringify(data)) : JSON.parse(data)
    if (jsonObject.func_name == 'APIAlready') {
      window.dispatchEvent(window.sceneloaded)
    }
  }
  /**
   * 设置镜头参数
   * @param {CameraInfo} info 镜头参数类
   *  * {number} pitch 镜头俯仰角
   * {number} yaw 镜头偏航角
   * {array}  position 镜头位置 [x,y,z]
   * {array}  lonlat 镜头经纬度 [lon,lat,z]
   * {number} duration 镜头移动时间，单位秒
   * {number} distance 镜头离中心点的距离
   */
  setCameraInfo(cameraInfo) {
    var location = cameraInfo.lonlat
    var coordtype = 0
    if (cameraInfo.position) {
      location = cameraInfo.position
      coordtype = 1
    }
    return this.cloudRender.SuperAPI('SetCameraInfo', {
      'coord_type': coordtype,
      'cad_mapkey': '',
      'pitch': cameraInfo.pitch,
      'yaw': cameraInfo.yaw,
      'arm_distance': cameraInfo.distance || 500,
      'center_coord': location[0] + ',' + location[1],
      'coord_z': location[2].toString() || 0, //在海拔情况下的高度值(单位:米)
      'fly': true
    })
  }
  /**
   * 获得镜头参数
   * @returns CameraInfo 镜头参数
   */
  async getCameraInfo() {
    var respos = await this.cloudRender
      .SuperAPI('GetCameraInfo', {
        'coord_type': 0, //坐标类型(0:经纬度坐标, 1:cad坐标)
        'cad_mapkey': '' //CAD基准点Key值, 项目中约定
      })
      .then((res) => {
        var c = JSON.parse(res)
        if (c.success) {
          c = c.args
          return new CameraInfo(c.pitch, c.yaw, null, c.center_coord, 0, c.arm_distance)
        }
      })
    return respos
  }
  /**
   * 根据id获取实体信息
   * @param {string} id 实体id
   * @returns 实体信息
   */
  async getEntityByID(id) {
    var respos = await this.cloudRender
      .SuperAPI('GetAESObjectDataWithEids', {
        'eid': [id]
      })
      .then((res) => {
        var c = JSON.parse(res)
        if (c.success) {
          return c.args.data
        }
      })
    return respos
  }
  /**
   * 场景内所有元素id,需要点击实体获得
   * @returns 场景内被点击元素id
   */
  getAllEntityIds() {
    // super api 6.6.0
    return this.cloudRender.SuperAPI('StartGetEID', {
      'state': true, //true:开启获取EID; false:关闭获取EID
      'highlight': false, //true:点击实体高亮; false:点击实体不高亮
      'act_layers': [] //可被选中元素所在图层，删除该字段，全部元素可被选中
    })
    // return null // super api 5.5.0不支持
  }
  /**
   * 设置镜头绕场景中心点旋转
   * @param {number} time 旋转一周所需要的时间,单位秒
   * @param {string} direction 旋转方向，clockwise:顺时针; anticlockwise:逆时针; stop:停止旋转
   */
  setCameraRotate(time, direction) {
    return this.cloudRender.SuperAPI('SetCameraRotate', {
      'time': time,
      'direction': direction
    })
  }
  setCameraLimit(pitch, yaw, boundingBox, minDistance, maxDistance) {
    var boundsmin = boundingBox.min.slice(0, 2).toString()
    var boundsmax = boundingBox.max.slice(0, 2).toString()

    return this.cloudRender.SuperAPI('SetCameraSpace', {
      'coord_type': 0, //坐标类型(0:经纬度坐标, 1:cad坐标)
      'cad_mapkey': '', //CAD基准点Key值, 项目中约定
      'coord_z': 100, //坐标高度(单位:米)
      'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面；1:相对3D世界地面；2:相对3D世界海拔; 注:cad坐标无效)
      'arm_distance_limit': minDistance.toString() + ',' + maxDistance.toString(), //镜头距离范围
      'pitch_limit': pitch[0].toString() + ',' + pitch[1].toString(), //镜头俯仰角(5~89)
      'yaw_limit': yaw[0].toString() + ',' + yaw[1].toString(), //镜头偏航角(0正北, 0~359)
      'points': [
        {
          'coord': boundsmin //西北
        },
        {
          'coord': boundsmax //东南
        }
      ]
    })
  }
  // 取消镜头限制
  removeCameraLimit() {
    this.cloudRender.SuperAPI('ResetCameraSpace', {
      'state': 'default' //default: 边界限制; free: 开放边界限制
    })
  }
  /**
   * 设置渲染分辨率
   * @param {number} width 宽
   * @param {number} height 高
   */
  setResolution(width, height) {
    this.cloudRender.SuperAPI('SetResolution', {
      'width': width || 1920,
      'height': height || 1080
    })
  }
  /**
   * 设置环境时间
   * @param {int} datetime 时间戳
   */
  setDateTime(date) {
    var d = new Date(date * 1000)
    var h = d.getHours() + ':'
    var m = d.getMinutes()

    return this.cloudRender.SuperAPI('SetEnvTime', {
      'env_time': h + m
    })
  }
  /**
   * 设置天气
   * @param {Weather} name 天气
   */
  setWeather(weather) {
    var w = 'auto'
    switch (weather) {
      case Weather.晴天:
        w = 'Sunny'
        break
      case Weather.阴天:
        w = 'Overcast'
        break
      case Weather.小雨:
        w = 'LightRain'
        break
      case Weather.中雨:
        w = 'ModerateRain'
        break
      case Weather.大雨:
        w = 'HeavyRain'
        break
      case Weather.小雪:
        w = 'LightSnow'
        break
      case Weather.中雪:
        w = 'ModerateSnow'
        break
      case Weather.大雪:
        w = 'HeavySnow'
        break
      case Weather.雾霾:
        w = 'Haze'
        break
      case Weather.少云:
      default:
        w = 'PartlyCloudy'
        break
    }
    return this.cloudRender.SuperAPI('SetEnvWeather', {
      'env_weather': w
    })
  }
  /**
   * 镜头聚焦物体
   * @param {string} id 聚焦目标的 id
   * @param {number} distance 距离，单位米
   * @param {EntityType} type 物体类型
   */
  focusEntity(id, distance, type, isFlashing) {
    if (type == EntityType.Object) {
      return this.cloudRender.SuperAPI('FocusAESObject', {
        'eid': [id],
        'distance': distance || 500
      })
    } else {
      return this.cloudRender.SuperAPI('FocusCovering', {
        'id': id,
        'covering_type': type,
        'distance': distance || 500
      })
    }
  }
  /**
   * 销毁实体
   * @param {string} id 需要销毁的实体id
   * @param {EntityType} type 物体类型
   */
  destroyEntity(id, type) {
    return this.cloudRender.SuperAPI('RemoveCovering', {
      'id': id,
      'covering_type': type
    })
  }
  /**
   * 隐藏实体
   * @param {string} id 隐藏实体id
   */
  hideEntity(id) {
    return this.cloudRender.SuperAPI('ShowHideAESObject', {
      'eid': [id],
      'bshow': false //true:显示; false:隐藏
    })
  }
  /**
   * 显示实体
   * @param {string} id 显示实体id
   */
  showEntity(id) {
    return this.cloudRender.SuperAPI('ShowHideAESObject', {
      'eid': [id],
      'bshow': true //true:显示; false:隐藏
    })
  }
  /**
   * 高亮实体
   * @param {string} id 高亮实体id
   * @param {array} borderColor 高亮实体边颜色[r,g,b]
   */
  highlightEntity(id, borderColor) {
    var c = color2RGBValue(borderColor)
    return this.cloudRender.SuperAPI('OutLineAESObject', {
      'eid': [id],
      'boutline': true, //true:描边; false:不描边
      'color': c || 'ffff00' //颜色(HEX颜色值)
    })
  }
  /**
   * 取消高亮实体
   * @param {string} id 取消高亮实体id
   */
  restoreEntity(id) {
    return this.cloudRender.SuperAPI('OutLineAESObject', {
      'eid': [id],
      'boutline': false
    })
  }
  /**
   * 创建热力图
   * @param {string} id 热力图id
   * @param {number} radius 热力半径，单位米
   * @param {array} minCoord 区域最小坐标 [x,y,z]
   * @param {array} maxCoord 区域最大坐标 [x,y,z]
   * @param {array} data 位置与数据，[x,y,z,value]
   */
  createHeatmap(id, radius, minCoord, maxCoord, data) {
    var hdata = data.map((item) => {
      return {
        'coord': item.slice(0, 2).toString(),
        'value': item.slice(-1)[0]
      }
    })
    return this.cloudRender.SuperAPI('AddHeatMap', {
      'id': id,
      'coord_type': 0, //坐标类型(0:经纬度坐标, 1:cad坐标)
      'cad_mapkey': '', //CAD基准点Key值, 项目中约定
      'coord_z': 15, //高度(单位:米)
      'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面; 1:相对3D世界地面; 2:相对3D世界海拔; 注:cad坐标无效)
      'heatmap_type': 1, //样式类型(1: 投影型, 贴合地面;  2:平面型)
      'leftupper_coord': minCoord.x + ',' + maxCoord.y, //热力区域坐标(左上坐标 lng,lat)
      'leftlower_coord': minCoord.x + ',' + minCoord.y, //热力区域坐标(左下坐标 lng,lat)
      'rightlower_coord': maxCoord.x + ',' + minCoord.y, //热力区域坐标(右下坐标 lng,lat)
      'rightupper_coord': maxCoord.x + ',' + maxCoord.y, //热力区域坐标(右上坐标 lng,lat)
      'brush_diameter': radius, //热力点笔刷直径(单位:米, 单个热力点覆盖直径)
      'heatpoint_minvalue': 1, //热力点热力值范围最小值(1:绿色接近透明, 100:最红, 线性计算)
      'heatpoint_maxvalue': 100, //热力点热力值范围最大值
      'gradient_setting': {
        //自定义热力点渐变颜色(HEX颜色值,共5个色值)
        'color1': '00ffff',
        'color2': 'fdff00',
        'color3': '009fff',
        'color4': 'f300ff',
        'color5': 'ff0000'
      },
      'data': hdata
    })
  }
  /**
   * 创建POI
   * @param {POI} poidata POI点数据类
   *  * {string} id 唯一标识
   * {string} resourceName 资源库中资源名称
   * {array} position POI位置
   * {array} scale x,y,z方向缩放比例
   * {string} label POI文字
   * {string} iconUrl POI图标url
   */
  addPOI(poidata) {
    if (!poidata.iconUrl) {
      return
    }
    var sizeW = 200
    var sizeH = 300
    const img = new Image()
    img.src = poidata.iconUrl
    if (img.complete) {
      sizeW = poidata.scale[0] * img.width || img.width
      sizeH = poidata.scale[1] * img.height || img.height

      this._setPOI(poidata, { width: sizeW, height: sizeH })
    } else {
      img.onload = () => {
        sizeW = poidata.scale[0] * img.width || img.width
        sizeH = poidata.scale[1] * img.height || img.height
        this._setPOI(poidata, { width: sizeW, height: sizeH })
      }
    }
  }
  _setPOI(poidata, imgSize) {
    var pos = poidata.position.slice(0, 2).toString()
    var height = poidata.position.slice(-1)[0]
    var len = poidata.label.replace(/[^\x00-\xff]/g, '00').length
    var labelWidth = 23 * len

    var poijson = {
      'id': poidata.id,
      'coord_type': 0, //坐标类型(0:经纬度坐标, 1:cad坐标)
      'cad_mapkey': '', //CAD基准点的Key值, 项目中约定
      'coord': pos, //POI点的坐标 lng,lat
      'coord_z': height || 0, //高度(单位:米)
      'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面；1:相对3D世界地面；2:相对3D世界海拔; 注:cad坐标无效)
      'always_show_label': true, //是否永远显示label, true:显示label(默认), false:不显示label
      'show_label_range': '0,2000', //POI点显示label的范围(单位:米, 范围最小、最大距离; 在此范围内显示, 超出范围隐藏; 注意:always_show_label属性优先于此属性)
      'sort_order': false, //是否开启遮挡排序(根据POI点真实3D位置开启遮挡排序,
      //注: 只与其他开启排序的POI之间进行排序, 开启此排序会消耗性能(最多60个POI点同时开启排序)
      'animation_type': 'bounce', //动画类型(bounce:弹出式; stretch:伸缩式; wipe:展开式)
      'duration_time': 0.7, //规定完成动画所花费的时间(单位:秒)
      'state': 'state_1', //与marker之中images中的define_state对应
      'marker': {
        'size': imgSize.width.toString() + ',' + imgSize.height.toString(), //marker大小(宽,高 单位:像素)
        'images': [
          {
            'define_state': 'state_1', //marker图片组
            'normal_url': poidata.iconUrl,
            'activate_url': poidata.iconUrl
          }
        ]
      }
    }
    if (len > 0) {
      poijson.label = {
        'bg_image_url': 'http://superapi.51hitech.com/doc-static/images/static/LabelBg.png',
        'bg_size': labelWidth.toString() + ',80', //label大小(宽, 高 单位:像素)
        'bg_offset': poidata.labelOffset.slice(0, 2).toString() || '50,200', //整个label左上角相对于marker的中心点(coord坐标中心点)的偏移(x,y 单位:像素), 注: x为正向右, y为正向上
        'content': [
          {
            'text': [poidata.label, 'ff0000ff', '30'], //[文本内容, HEXA颜色, 文本大小]
            'text_offset': '10,10', //文本框左上角相对于label中bg_offset左上角的margin偏移(x,y 单位:像素), 注: x为正向右, y为正向下
            // "text_boxwidth": 80,      //文本框宽度
            'text_centered': false, //文本居中(true:居中; false:不居中)
            'scroll_speed': 0 //文本滚动速度(0:不滚动; 注: "text_centered":true优先)
          }
        ]
      }
    }
    return this.cloudRender.SuperAPI('AddCustomPOI', poijson)
    // this.mapLayers.push(new Map3DOverLayer(poidata.id, true, MapLayerType.POI))
  }
  /**
   * 开启镜头移动
   * @param {number} duaration 漫游持续时间
   * @param {number} speed 漫游速度，单位米/秒
   * @param {boolean} loop 是否循环
   * @param {number} armDistance 镜头沿视角到路径的距离，单位米
   * @param {number} roll 翻滚角
   * @param {number} pitch 俯仰角
   * @param {number} yaw 偏航角
   * @param {array} path 路径点
   */
  startThirdPersonRoaming(duaration, speed, loop, armDistance, roll, pitch, yaw, path) {
    if (path.length > 0) {
      if (this.sceneVertion == '4.1.1') {
        return fun4_1_1.startThirdPersonRoaming(
          this.cloudRender,
          duaration,
          speed,
          loop,
          armDistance,
          roll,
          pitch,
          yaw,
          path
        )
      } else {
        var hdata = path.map((item) => {
          return {
            'coord': item.slice(0, 2).toString(),
            'coord_z': item.slice(-1)[0]
          }
        })

        var pathjson = {
          'id': 'move_path_id', //路径id
          'coord_type': 0, //路径中坐标类型(0:经纬度坐标, 1:cad坐标)
          'cad_mapkey': '', //CAD基准点Key值, 项目中约定
          'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面; 1:相对3D世界地面; 2:相对3D世界海拔; 注:cad坐标无效)
          'type': 'none', //路径样式类型(none, solid, arrow, arrow_dot, dashed_dot, arrow_dashed, flash, scan_line, brimless_arrow, railway, railway, square_pipe, dashed_line)
          'points': hdata,
          'width': 1,
          'color': ''
        }
        var that = this
        return new Promise((resolve, reject) => {
          this.cloudRender.SuperAPI('AddPath', pathjson, (mycallback) => {
            let obj = JSON.parse(mycallback)
            if (obj.success) {
              that.cloudRender
                .SuperAPI('AddCamera', {
                  'camera_id': 'camera1',
                  'coord_type': '0', //位置的坐标类型(0:经纬度坐标, 1:cad坐标)
                  'cad_mapkey': '', //CAD基准点Key值, 项目中约定
                  'coord': path[0].slice(0, 2).toString(), //相机位置坐标 lng, lat
                  'coord_z': 0, //高度(单位:米)
                  'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面；1:相对3D世界地面；2:相对3D世界海拔; 注:cad坐标无效)
                  'pitch': pitch, //镜头俯仰角(-90~90)
                  'pitch_limit': '0,90', //镜头俯仰角范围(-90~90)
                  'yaw': yaw, //镜头偏航角(0正北, 0~359)
                  'yaw_limit': '0,359', //镜头偏航角范围(0正北, 0~359)
                  'arm_distance': armDistance, //镜头距坐标点距离(单位:米)
                  'arm_distance_limit': '50,300' //镜头距坐标点距离范围(单位:米)
                })
                .then(() => {
                  that.cloudRender
                    .SuperAPI('SetCameraActive', {
                      'camera_id': 'camera1'
                    })
                    .then(() => {
                      resolve(
                        that.cloudRender.SuperAPI('SetCameraToMove', {
                          'camera_id': 'camera1',
                          'be_attach_id': 'move_path_id',
                          'be_attach_type': 'path', //依附的覆盖物类型 见下表
                          'speed': speed, //移动速度 (单位:米/秒)
                          'loop': loop || false, //是否循环
                          'reverse': false, //是否反向移动
                          'arm_distance': armDistance, //镜头距覆盖物距离(单位:米)
                          'pitch': pitch //镜头俯仰角(0~89)
                        })
                      )
                    })
                })
            }
          })
        })
      }
    }
  }
  /**
   * 暂停镜头移动
   */
  pauseThirdPersonRoaming() {
    return this.cloudRender.SuperAPI('SetCameraToMoveState', {
      'camera_id': 'camera1',
      'state': 'pause'
    })
  }
  /**
   * 继续镜头移动
   */
  continueThirdPersonRoaming() {
    return this.cloudRender.SuperAPI('SetCameraToMoveState', {
      'camera_id': 'camera1',
      'state': 'continue'
    })
  }
  /**
   * 停止镜头移动
   */
  stopThirdPersonRoaming() {
    return this.cloudRender.SuperAPI('SetCameraToMoveState', {
      'camera_id': 'camera1',
      'state': 'stop'
    })
  }
  /**
   * 创建弹窗
   * @param {string} poiId 需要创建弹窗的实体id
   * @param {string} windowID 创建弹窗的id
   * @param {string} windowUrl 弹窗内容html地址
   * @param {number} width 窗口宽，单位像素
   * @param {number} height 窗口高，单位像素
   * @param {number} xoffset 弹窗左上角相对横向偏移量，单位像素
   * @param {number} yoffset 弹窗左上角相对纵向偏移量，单位像素
   * @param {EntityType} type 要创建弹窗的实体类型
   */
  addInfowindow(poiID, windowID, windowUrl, width, height, xOffset, yOffset, type) {
    var that = this
    if (type == EntityType.POI) {
      return new Promise((resolve) => {
        this.cloudRender
          .SuperAPI('UpdateCustomPOIWindow', {
            'id': poiID,
            'window': {
              'url': windowUrl,
              'size': width + ',' + height,
              'offset': xOffset + ',' + yOffset
            }
          })
          .then(() => {
            that.cloudRender.SuperAPI(
              'SimClickCovering',
              {
                'id': poiID,
                'selected_state': false,
                'covering_type': 'poi'
              },
              (status) => {
                resolve(status)
              }
            )
          })
      })
    } else {
      return new Promise((resolve) => {
        this.cloudRender
          .SuperAPI('AddCoverWindow', {
            'coverings_id': poiID,
            'coverings_type': type,
            'POIData': {
              'id': windowID,
              'window': {
                'url': windowUrl,
                'size': width + ',' + height,
                'offset': xOffset + ',' + yOffset
              }
            }
          })
          .then((e) => {
            that.cloudRender
              .SuperAPI('StartGetEID', {
                'state': true, //true:开启获取EID; false:关闭获取EID
                'highlight': false, //true:点击实体高亮; false:点击实体不高亮
                'act_layers': [] //可被选中元素所在图层，删除该字段，全部元素可被选中
              })
              .then(() => {
                resolve(e)
              })
          })
      })
    }
  }
  /**
   * 销毁弹窗
   * @param {string} poiId 绑定弹窗的实体id
   * @param {string} windowID 弹窗id
   * @param {EntityType} type 要创建弹窗的实体类型
   */
  destroyInfowindow(poiId = null, windowId, type) {
    if (type == EntityType.POI) {
      return this.cloudRender.SuperAPI('SimClickCovering', {
        'id': poiId,
        'selected_state': false, //覆盖物是否被选中; true:选中; false:未选中
        'covering_type': type
      })
    } else {
      return this.cloudRender.SuperAPI('RemoveCoverWindow', {
        'coverings_type': type,
        'id': windowId
      })
    }
  }
  /**
   *楼层展开
   * @param {string} buildingId 需要展开的建筑id
   * @param {array} floorIds 需要展开的楼层id,id为string类型
   * @param {number} space 展开后楼层间间隔距离，单位米
   * @param {number} floor 楼层号
   */
  explodeEntity(buildingId, floorIds = null, space = null, floor) {
    return this.cloudRender.SuperAPI('SplitBuild', {
      'build_id': buildingId, //建筑物id (项目中约定)
      'floor': floor, //要拆解的楼层(1楼为1,地下一楼为-1)
      'animation_type': 1 //动画类型 (1:伸缩杆动画)
    })
  }
  /**
   * 楼层还原
   * @param {string} buildingId 需要展开的建筑id
   * @param {array} floorIds
   */
  unexplodedEntity(buildingId, floorIds = null) {
    return this.cloudRender.SuperAPI('SplitBuild', {
      'build_id': buildingId,
      'floor': 10000,
      'animation_type': 1
    })
  }
  /**
   * 添加模型实体
   * @param {string} id 模型实体id
   * @param {array} position 位置 [x,y,z]
   * @param {string} resourceName  资源库中资源的名称
   * @param {number} roll 翻滚角
   * @param {number} pitch 俯仰角
   * @param {number} yaw 偏航角
   * @param {array} scale 比例 [scaleX,scaleY,scaleZ]
   */
  addModel(id, position, resourceName, roll, pitch, yaw, scale) {
    return this.addEffect(id, resourceName, position, roll, pitch, yaw, scale)
  }
  /**
   * 开启模型移动
   * @param {string} id 模型实体id
   * @param {number} duaration 移动持续时间
   * @param {number} speed 速度，单位米/秒
   * @param {boolean} loop 是否循环
   * @param {array} path 路径点
   * @param {number} roll 翻滚角
   * @param {number} pitch 俯仰角
   * @param {number} yaw 偏航角
   */
  startEntityMoving(id, duration = null, speed, loop, path, roll = null, pitch = null, yaw = null) {
    if (path.length > 0) {
      if (this.sceneVertion == '4.1.1') {
        return fun4_1_1.startEntityMoving(this.cloudRender, id, null, speed, loop, path)
      } else {
        var hdata = path.map((item) => {
          return {
            'coord': item.slice(0, 2).toString(),
            'coord_z': item.slice(-1)[0]
          }
        })
        //create path
        var pathjson = {
          'id': 'path_id', //路径id
          'coord_type': 0, //路径中坐标类型(0:经纬度坐标, 1:cad坐标)
          'cad_mapkey': '', //CAD基准点Key值, 项目中约定
          'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面; 1:相对3D世界地面; 2:相对3D世界海拔; 注:cad坐标无效)
          'type': 'none', //路径样式类型(none, solid, arrow, arrow_dot, dashed_dot, arrow_dashed, flash, scan_line, brimless_arrow, railway, railway, square_pipe, dashed_line)
          'points': hdata,
          'color': 'ffffff',
          'pass_color': 'ffffff',
          'width': 1
        }
        var that = this
        return new Promise((resolve) => {
          this.cloudRender.SuperAPI('AddPath', pathjson, (mycallback) => {
            let obj = JSON.parse(mycallback)
            if (obj.success) {
              resolve(
                that.cloudRender.SuperAPI('CoverToMove', {
                  'attach_id': id, //要移动的覆盖物id
                  'attach_type': 'scene_effect',
                  'be_attach_id': 'path_id', //依附的覆盖物id
                  'be_attach_type': 'path', //依附的覆盖物类型 见下表
                  'speed': speed, //移动速度 (单位:米/秒)
                  'loop': loop || false, //是否循环
                  'reverse': false //是否反向移动
                })
              )
            }
          })
        })
      }
    }
  }
  /**
   * 暂停模型移动
   * @param {string} id 模型实体id
   */
  pauseEntityMoving(id) {
    return this.cloudRender.SuperAPI('PlayCoverMoveState', {
      'id': id,
      'type': 'scene_effect',
      'play': false //true:继续移动; false:暂停移动;
    })
  }

  /**
   * 继续模型移动
   * @param {string} id 模型实体id
   */
  resumeEntityMoving(id) {
    return this.cloudRender.SuperAPI('PlayCoverMoveState', {
      'id': id,
      'type': 'scene_effect',
      'play': true //true:继续移动; false:暂停移动;
    })
  }
  /**
   * 停止模型移动
   * @param {string} id 模型实体id
   */
  stopEntityMoving(id) {
    return this.pauseEntityMoving(id)
  }
  /**
   * 创建特效
   * @param {string} id 特效id
   * @param {string} resourceName 资源库中资源的名称
   * @param {array} position 特效位置，[x,y,z]
   * @param {number} roll 翻滚角
   * @param {number} pitch 俯仰角
   * @param {number} yaw 偏航角
   * @param {array} scale 比例 [scaleX,scaleY,scaleZ]
   */
  addEffect(id, resourceName, position, roll, pitch, yaw, scale) {
    var pos = position.slice(0, 2).toString()
    var height = position.slice(-1)[0]
    var s = scale.slice(0, 1)[0]

    return this.cloudRender.SuperAPI('AddEffect', {
      'id': id,
      'coord_type': 0, //坐标类型(0:经纬度坐标, 1:cad坐标)
      'cad_mapkey': '', //CAD基准点Key值, 项目中约定
      'type': resourceName, //样式类型(见下表)
      'scale': s || 10, //半径(单位:米; "adaptive":true 时含义为倍率)
      'adaptive': true, //true:自适应大小;false:默认
      'coord': pos, //坐标点 lng,lat
      'coord_z': height || 0, //高度(单位:米)
      'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面；1:相对3D世界地面；2:相对3D世界海拔; 注:cad坐标无效)
      'pitch': pitch, //俯仰角, 参考(-90~90)
      'roll': roll, //翻滚角, 参考(0~360)
      'yaw': yaw, //偏航角, 参考(0正北, 0~360)
      'title_text': '', //文本内容, 富文本内容
      'title_offset': '10,100', //文本偏移(单位:米; 东西向为x轴进行偏移)
      'title_face_to_camera': true, //顶部文字是否跟踪朝向摄像机(注: true优先, "pitch", "roll", "yaw" 无效)
      'title_text_portrait': true //顶部文字排列方向(true: 纵向, false: 横向)
    })
  }
  /**
   * 创建三维文字
   * @param {string} id 文字id
   * @param {string} text 文字内容
   * @param {array} position 文字位置,[x,y,z]
   * @param {array} color 颜色 [r,g,b,a]
   * @param {number} roll 翻滚角
   * @param {number} pitch 俯仰角
   * @param {number} yaw 偏航角
   * @param {array} scale 比例 [scaleX,scaleY,scaleZ]
   * @param {number} thickness 厚度
   */
  add3dText(id, text, position, color, roll, pitch, yaw, scale, thickness) {
    var pos = position.slice(0, 2).toString()
    var height = position.slice(-1)[0]
    var s = scale.slice(0, 1)[0]
    var c = color2RGBValue(color)
    return this.cloudRender.SuperAPI('Add3DText', {
      'id': id,
      'coord_type': 0, //坐标类型(0:经纬度坐标, 1:cad坐标)
      'cad_mapkey': '', //CAD基准点Key值, 项目中约定
      'coord': pos, //坐标 lng,lat
      'coord_z': height, //高度(单位:米)
      'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面; 1:相对3D世界地面; 2:相对3D世界海拔; 注:cad坐标无效)
      'text': text, //文字内容
      'color': c || 'ff00ff', //颜色(HEX颜色值)
      'size': 50 * s || 1, //字体大小(单位:米)
      'thickness': thickness || 5, //厚度(单位:米)
      'type': 'plain', //样式(plain; reflection; metal)
      'outline': 1, //轮廓(单位:百分比), 取值范围[0~1]
      'portrait': false, //纵向(true/false)
      'space': 0.2, //间距(单位:米)
      'flash': 0, //闪烁动效(单位:秒)
      'bounce': 0, //反弹动效(单位:米/秒)
      'pitch': pitch, //俯仰角(-90~90)
      'yaw': yaw, //偏航角(0正北, 0~360)
      'face_to_camera': true //文字是否跟踪朝向摄像机(注:true优先, "pitch", "yaw" 无效)
    })
  }
  /**
   * 创建路径
   * @param {string} id 路径id
   * @param {array} path 路径点
   * @param {PathStyle} pathStyle 路径样式
   * @param {array} color 颜色 [r,g,b,a]
   * @param {number} width 宽度
   */
  addPath(id, path, pathStyle, color, width) {
    var hdata = path.map((item) => {
      return {
        'coord': item.slice(0, 2).toString(),
        'coord_z': item.slice(-1)[0]
      }
    })
    var style = 'solid'
    switch (pathStyle) {
      case PathStyle.Dashed:
        style = 'dashed_line'
        break
      case PathStyle.Arrow:
        style = 'arrow'
        break
      case PathStyle.Flash:
        style = 'scan_line'
        break
      case PathStyle.Solid:
      default:
        style = 'solid'
        break
    }
    var c = color2RGBValue(color)
    return this.cloudRender.SuperAPI('AddPath', {
      'id': id,
      'advancedSetting': {
        'smoothnessOfCorners': 'extremelyHigh' //设置路径边角的平滑度(extremelyHigh:极高; high:高; middle:中; low:低;)
      },
      'coord_type': 0, //坐标类型(0:经纬度坐标, 1:cad坐标)
      'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面；1:相对3D世界地面；2:相对3D世界海拔; 注:cad坐标无效)
      'cad_mapkey': '', //CAD基准点Key值, 项目中约定
      'type': style, //样式类型; 注①
      'color': c || '00c864', //颜色(HEX颜色值, 空值即透明; railway类型无效, 默认黑白色)
      'pass_color': 'ffff00', //覆盖物移动经过路径颜色(HEX颜色值)
      'width': width || 10, //宽度(单位:米, 圆柱直径或方柱边长；当类型为“adaptive_solid”，含义为倍率)
      'points': hdata
    })
  }
  /**
   * 创建区域
   * @param {string} id 区域id
   * @param {array} path 路径点
   * @param {AreaStyle} type 区域样式
   * @param {array} color 颜色 [r,g,b,a]
   * @param {number} height 区域高度，单位米
   */
  addArea(id, path, type, color, height) {
    var hdata = path.map((item) => {
      return {
        'coord': item.slice(0, 2).toString()
      }
    })
    var style = 'none'
    switch (type) {
      case AreaStyle.Strip:
        style = 'wave'
        break
      case AreaStyle.Grid:
        style = 'grid'
        break
      case AreaStyle.Solid:
      default:
        style = 'none'
        break
    }

    var c = color2RGBAValue(color)
    return this.cloudRender.SuperAPI('AddRange', {
      'id': id,
      'coord_type': 0, //坐标类型(0:经纬度坐标, 1:cad坐标)
      'cad_mapkey': '', //CAD基准点Key值, 项目中约定
      'coord_z': 0, //高度(单位:米)
      'coord_z_type': 0, //坐标高度类型(0:相对3D世界表面；1:相对3D世界地面；2:相对3D世界海拔; 注:cad坐标无效)
      'type': style, //样式类型
      'color': c || 'ff00004c', //轮廓颜色(HEXA颜色值)
      'range_height': height || 10, //围栏高度(单位:米)
      'stroke_weight': 2, //底部轮廓线宽度(单位:米; 注: 区域中含有内环"inner_points"时无效)
      'fill_area': 'none', //底部区域填充类型; 注②
      'points': hdata
    })
  }
  /**
   * 销毁实例
   */
  destroyMap() {
    if (this.cloudRender) {
      this.cloudRender.SuperAPI('StopRenderCloud')
    }
  }
  /**
   * 51没有鼠标事件注册/取消
   * @param {*} eventType
   * @param {*} callback
   */
  addEventListener(eventType, callback) {}
  removeEventListener(eventType) {}
}
