import * as mars3d from "mars3d"

export let map // mars3d.Map三维地图对象

// 需要覆盖config.json中地图属性参数（当前示例框架中自动处理合并）
export const mapOptions = {
  scene: {
    center: { lat: 31.834648, lng: 117.219733, alt: 83, heading: 64, pitch: -34 },
    fxaa: true
  }
}

/**
 * 初始化地图业务，生命周期钩子函数（必须）
 * 框架在地图初始化完成后自动调用该函数
 * @param {mars3d.Map} mapInstance 地图对象
 * @returns {void} 无
 */
export function onMounted(mapInstance) {
  map = mapInstance // 记录map

  globalNotify("操作提示", `鼠标左键单击进行发射`)
  addDemo()
}

/**
 * 释放当前地图业务的生命周期函数
 * @returns {void} 无
 */
export function onUnmounted() {
  map = null
}

function addDemo() {
  const GeometryUtils = Cesium.GeometryUtils
  const MeshPhongMaterial = Cesium.MeshPhongMaterial
  const BasicMeshMaterial = Cesium.BasicMeshMaterial

  const center = Cesium.Cartesian3.fromDegrees(117.220206, 31.834866, 50)
  const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center)

  const meshVisualizer = new Cesium.MeshVisualizer({
    modelMatrix: modelMatrix,
    up: { y: 1 },
    referenceAxisParameter: {
      length: 100,
      width: 0.05,
      headLength: 2,
      headWidth: 0.1
    }
  })
  map.scene.primitives.add(meshVisualizer)
  meshVisualizer.showReference = true // 显示坐标轴

  function createRandomColor() {
    return Cesium.Color.fromRandom({ alpha: 1 }) // fromRgba(Math.floor(Math.random() * (1 << 24)));
  }
  function createMaterial() {
    return new MeshPhongMaterial({
      defaultColor: createRandomColor(),
      side: Cesium.MeshMaterial.Sides.DOUBLE,
      translucent: false
    })
  }

  Cesium.Cartesian3.prototype.set = function (x, y, z) {
    this.x = x
    this.y = y
    this.z = z
  }
  Cesium.Cartesian2.prototype.set = function (x, y) {
    this.x = x
    this.y = y
  }
  Cesium.Quaternion.prototype.set = function (x, y, z, w) {
    this.x = x
    this.y = y
    this.z = z
    this.w = w
  }

  Ammo().then(function () {
    // - Global variables -

    // Graphics variables
    let clickRequest = false
    const mouseCoords = new Cesium.Cartesian2()
    const ballMaterial = createMaterial()
    const pos = new Cesium.Cartesian3()
    const quat = new Cesium.Quaternion()

    // Physics variables
    const gravityConstant = -9.8
    let collisionConfiguration
    let dispatcher
    let broadphase
    let solver
    let physicsWorld
    const rigidBodies = []
    const softBodies = []
    const margin = 0.05
    // let hinge
    const transformAux1 = new Ammo.btTransform()
    const softBodyHelpers = new Ammo.btSoftBodyHelpers()
    // const armMovement = 0
    const ray = new Cesium.Ray()
    let softBodySolver

    function initPhysics() {
      // Physics configuration

      collisionConfiguration = new Ammo.btSoftBodyRigidBodyCollisionConfiguration()
      dispatcher = new Ammo.btCollisionDispatcher(collisionConfiguration)
      broadphase = new Ammo.btDbvtBroadphase()
      solver = new Ammo.btSequentialImpulseConstraintSolver()
      softBodySolver = new Ammo.btDefaultSoftBodySolver()
      physicsWorld = new Ammo.btSoftRigidDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration, softBodySolver)
      physicsWorld.setGravity(new Ammo.btVector3(0, gravityConstant, 0))
      physicsWorld.getWorldInfo().set_m_gravity(new Ammo.btVector3(0, gravityConstant, 0))
    }

    function createObjects() {
      // Ground
      pos.set(0, -0.5, 0)
      quat.set(0, 0, 0, 1)
      const ground = createParalellepiped(
        40,
        1,
        40,
        0,
        pos,
        quat,
        new MeshPhongMaterial({
          defaultColor: "rgb(200,200,200)",
          side: Cesium.MeshMaterial.Sides.DOUBLE,
          translucent: false
        })
      )
      GeometryUtils.computeVertexNormals(ground.geometry)

      // Create soft volumes
      const volumeMass = 15

      const sphereGeometry = new THREE.SphereBufferGeometry(1.5, 40, 25)
      sphereGeometry.translate(5, 5, 0)
      createSoftVolume(sphereGeometry, volumeMass, 250)

      const boxGeometry = new THREE.BufferGeometry().fromGeometry(new THREE.BoxGeometry(1, 1, 5, 4, 4, 20))
      boxGeometry.translate(-2, 5, 0)
      createSoftVolume(boxGeometry, volumeMass, 120)

      // Ramp
      pos.set(3, 1, 0)
      Cesium.Quaternion.fromAxisAngle(new Cesium.Cartesian3(0, 0, 1), (30 * Math.PI) / 180, quat)
      const obstacle = createParalellepiped(
        10,
        1,
        4,
        0,
        pos,
        quat,
        new MeshPhongMaterial({
          defaultColor: "rgb(28,28,28)",
          side: Cesium.MeshMaterial.Sides.DOUBLE,
          translucent: false
        })
      )
      GeometryUtils.computeVertexNormals(obstacle.geometry)
    }

    function processGeometry(bufGeometry) {
      // Obtain a Geometry
      const geometry = new THREE.Geometry().fromBufferGeometry(bufGeometry)

      // Merge the vertices so the triangle soup is converted to indexed triangles
      // const vertsDiff = geometry.mergeVertices()

      // Convert again to BufferGeometry, indexed
      const indexedBufferGeom = createIndexedBufferGeometryFromGeometry(geometry)

      // Create index arrays mapping the indexed vertices to bufGeometry vertices
      mapIndices(bufGeometry, indexedBufferGeom)
    }

    function createIndexedBufferGeometryFromGeometry(geometry) {
      const numVertices = geometry.vertices.length
      const numFaces = geometry.faces.length

      const bufferGeom = new THREE.BufferGeometry()
      const vertices = new Float32Array(numVertices * 3)
      const indices = new (numFaces * 3 > 65535 ? Uint32Array : Uint16Array)(numFaces * 3)

      for (let i = 0; i < numVertices; i++) {
        const p = geometry.vertices[i]

        const i3 = i * 3

        vertices[i3] = p.x
        vertices[i3 + 1] = p.y
        vertices[i3 + 2] = p.z
      }

      for (let i = 0; i < numFaces; i++) {
        const f = geometry.faces[i]

        const i3 = i * 3

        indices[i3] = f.a
        indices[i3 + 1] = f.b
        indices[i3 + 2] = f.c
      }

      bufferGeom.setIndex(new THREE.BufferAttribute(indices, 1))
      bufferGeom.addAttribute("position", new THREE.BufferAttribute(vertices, 3))

      return bufferGeom
    }

    function isEqual(x1, y1, z1, x2, y2, z2) {
      const delta = 0.000001
      return Math.abs(x2 - x1) < delta && Math.abs(y2 - y1) < delta && Math.abs(z2 - z1) < delta
    }

    function mapIndices(bufGeometry, indexedBufferGeom) {
      // Creates ammoVertices, ammoIndices and ammoIndexAssociation in bufGeometry

      const vertices = bufGeometry.attributes.position.array
      const idxVertices = indexedBufferGeom.attributes.position.array
      const indices = indexedBufferGeom.index.array

      const numIdxVertices = idxVertices.length / 3
      const numVertices = vertices.length / 3

      bufGeometry.ammoVertices = idxVertices
      bufGeometry.ammoIndices = indices
      bufGeometry.ammoIndexAssociation = []

      for (let i = 0; i < numIdxVertices; i++) {
        const association = []
        bufGeometry.ammoIndexAssociation.push(association)

        const i3 = i * 3

        for (let j = 0; j < numVertices; j++) {
          const j3 = j * 3
          if (isEqual(idxVertices[i3], idxVertices[i3 + 1], idxVertices[i3 + 2], vertices[j3], vertices[j3 + 1], vertices[j3 + 2])) {
            association.push(j3)
          }
        }
      }
    }

    function createSoftVolume(bufferGeom, mass, pressure) {
      processGeometry(bufferGeom)

      const volume = new Cesium.Mesh(
        bufferGeom,
        new BasicMeshMaterial({
          uniforms: {
            diffuseColorMap: "img/textures/colors.png"
          },
          translucent: false
        })
      )
      volume.geometry.ammoIndexAssociation = bufferGeom.ammoIndexAssociation

      meshVisualizer.add(volume)

      // Volume physic object

      const volumeSoftBody = softBodyHelpers.CreateFromTriMesh(
        physicsWorld.getWorldInfo(),
        bufferGeom.ammoVertices,
        bufferGeom.ammoIndices,
        bufferGeom.ammoIndices.length / 3,
        true
      )

      const sbConfig = volumeSoftBody.get_m_cfg()
      sbConfig.set_viterations(40)
      sbConfig.set_piterations(40)

      // Soft-soft and soft-rigid collisions
      sbConfig.set_collisions(0x11)

      // Friction
      sbConfig.set_kDF(0.1)
      // Damping
      sbConfig.set_kDP(0.01)
      // Pressure
      sbConfig.set_kPR(pressure)
      // Stiffness
      volumeSoftBody.get_m_materials().at(0).set_m_kLST(0.9)
      volumeSoftBody.get_m_materials().at(0).set_m_kAST(0.9)

      volumeSoftBody.setTotalMass(mass, false)
      Ammo.castObject(volumeSoftBody, Ammo.btCollisionObject).getCollisionShape().setMargin(margin)
      physicsWorld.addSoftBody(volumeSoftBody, 1, -1)
      volume.physicsBody = volumeSoftBody
      // Disable deactivation
      volumeSoftBody.setActivationState(4)

      softBodies.push(volume)
    }

    function createParalellepiped(sx, sy, sz, mass, pos, quat, material) {
      const box = Cesium.BoxGeometry.fromDimensions({
        dimensions: new Cesium.Cartesian3(sx, sy, sz),
        vertexFormat: new Cesium.VertexFormat({
          position: true,
          normal: true
        })
      })
      const threeObject = new Cesium.Mesh(box, material)

      const shape = new Ammo.btBoxShape(new Ammo.btVector3(sx * 0.5, sy * 0.5, sz * 0.5))
      shape.setMargin(margin)

      createRigidBody(threeObject, shape, mass, pos, quat)

      return threeObject
    }

    function createRigidBody(threeObject, physicsShape, mass, pos, quat) {
      Cesium.Cartesian3.clone(pos, threeObject.position)
      if (!threeObject.quaternion) {
        threeObject.quaternion = new Cesium.Quaternion()
      }
      Cesium.Quaternion.clone(quat, threeObject.quaternion)

      const transform = new Ammo.btTransform()
      transform.setIdentity()
      transform.setOrigin(new Ammo.btVector3(pos.x, pos.y, pos.z))
      transform.setRotation(new Ammo.btQuaternion(quat.x, quat.y, quat.z, quat.w))
      const motionState = new Ammo.btDefaultMotionState(transform)

      const localInertia = new Ammo.btVector3(0, 0, 0)
      physicsShape.calculateLocalInertia(mass, localInertia)

      const rbInfo = new Ammo.btRigidBodyConstructionInfo(mass, motionState, physicsShape, localInertia)
      const body = new Ammo.btRigidBody(rbInfo)

      threeObject.physicsBody = body

      meshVisualizer.add(threeObject)

      if (mass > 0) {
        rigidBodies.push(threeObject)

        // Disable deactivation
        body.setActivationState(4)
      }

      physicsWorld.addRigidBody(body)

      return body
    }

    function updatePhysics(deltaTime) {
      try {
        // Step world
        physicsWorld.stepSimulation(deltaTime, 10)

        // Update soft volumes
        for (let i = 0, il = softBodies.length; i < il; i++) {
          const volume = softBodies[i]
          const geometry = volume.geometry
          const softBody = volume.physicsBody
          const volumePositions = geometry.attributes.position.values
          const volumeNormals = geometry.attributes.normal.values
          const association = geometry.ammoIndexAssociation
          const numVerts = association.length
          const nodes = softBody.get_m_nodes()
          for (let j = 0; j < numVerts; j++) {
            const node = nodes.at(j)
            const nodePos = node.get_m_x()
            const x = nodePos.x()
            const y = nodePos.y()
            const z = nodePos.z()
            const nodeNormal = node.get_m_n()
            const nx = nodeNormal.x()
            const ny = nodeNormal.y()
            const nz = nodeNormal.z()

            const assocVertex = association[j]

            for (let k = 0, kl = assocVertex.length; k < kl; k++) {
              let indexVertex = assocVertex[k]
              volumePositions[indexVertex] = x
              volumeNormals[indexVertex] = nx
              indexVertex++
              volumePositions[indexVertex] = y
              volumeNormals[indexVertex] = ny
              indexVertex++
              volumePositions[indexVertex] = z
              volumeNormals[indexVertex] = nz
            }
          }

          geometry.attributes.position.needsUpdate = true
          geometry.attributes.normal.needsUpdate = true

          volume.modelMatrixNeedsUpdate = true
        }

        // Update rigid bodies
        for (let i = 0, il = rigidBodies.length; i < il; i++) {
          const objThree = rigidBodies[i]
          const objPhys = objThree.physicsBody
          const ms = objPhys.getMotionState()
          if (ms) {
            ms.getWorldTransform(transformAux1)
            const p = transformAux1.getOrigin()
            const q = transformAux1.getRotation()
            objThree.position.set(p.x(), p.y(), p.z())
            objThree.quaternion.set(q.x(), q.y(), q.z(), q.w())
            objThree.modelMatrixNeedsUpdate = true
          }
        }
      } catch (e) {
        meshVisualizer.beforeUpdate.removeEventListener(update)
        console.log("崩溃了", e)
      }
    }

    let start = false
    let init = false
    let startTime = new Date()
    const rayDir = new Cesium.Cartesian3()
    // const maxDistance = 100 // 发射点与射线和局部场景的交点的距离不能太远，过远会撕碎软体进而碎片过多时导致ammo物理引擎崩溃

    function initInput() {
      const scene = map.scene
      const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas)
      // const lastMesh = null
      handler.setInputAction(function (movement) {
        if (!clickRequest) {
          Cesium.Cartesian2.clone(movement.position, mouseCoords)
          clickRequest = true
        }
      }, Cesium.ScreenSpaceEventType.LEFT_DOWN)
    }

    function processClick() {
      if (clickRequest) {
        meshVisualizer.getPickRay(mouseCoords, ray)
        if (!ray) {
          clickRequest = false
          return
        }
        // Creates a ball
        const ballMass = 3
        const ballRadius = 0.4

        const ball = new Cesium.Mesh(new THREE.SphereGeometry(ballRadius, 18, 16), ballMaterial)

        const ballShape = new Ammo.btSphereShape(ballRadius)
        ballShape.setMargin(margin)

        Cesium.Cartesian3.clone(ray.direction, rayDir)
        Cesium.Cartesian3.subtract(ray.origin, ray.direction, pos)

        quat.set(0, 0, 0, 1)
        const ballBody = createRigidBody(ball, ballShape, ballMass, pos, quat)
        ballBody.setFriction(0.5)

        Cesium.Cartesian3.normalize(rayDir, rayDir)
        Cesium.Cartesian3.multiplyByScalar(rayDir, 30, rayDir)
        ballBody.setLinearVelocity(new Ammo.btVector3(rayDir.x, rayDir.y, rayDir.z))

        clickRequest = false
      }
    }
    function update(frameState) {
      const deltaTime = (new Date() - startTime) / 1000.0
      updatePhysics(deltaTime)
      processClick()
      startTime = new Date()
    }
    setTimeout(function () {
      if (!init) {
        // - Init -
        // initGraphics();

        initPhysics()

        createObjects()

        initInput()

        init = true
      }
      if (!start) {
        meshVisualizer.beforeUpdate.addEventListener(update)
        start = true
      } else {
        meshVisualizer.beforeUpdate.removeEventListener(update)
        start = false
      }
    }, 1000 * 3)
  })
}