import * as mars3d from "mars3d"

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

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

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

  globalNotify("操作提示", `Q 逆时针摆动、 A 顺时针摆动`)
  creatDemo()
}

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

function creatDemo() {
  const MeshVisualizer = Cesium.MeshVisualizer
  const Mesh = Cesium.Mesh
  const MeshMaterial = Cesium.MeshMaterial
  const GeometryUtils = Cesium.GeometryUtils
  const PlaneBufferGeometry = Cesium.PlaneBufferGeometry
  const MeshPhongMaterial = Cesium.MeshPhongMaterial

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

  const meshVisualizer = new 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 // 显示坐标轴

  Ammo().then(function () {
    // Physics variables
    const gravityConstant = -9.8
    let collisionConfiguration
    let dispatcher
    let broadphase
    let solver
    let physicsWorld
    const rigidBodies = []
    const margin = 0.05
    let hinge
    let cloth
    const transformAux1 = new Ammo.btTransform()
    let armMovement = 0
    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 createRandomColor() {
      return Cesium.Color.fromRandom({ alpha: 1 }) // fromRgba(Math.floor(Math.random() * (1 << 24)));
    }
    function createMaterial() {
      return new MeshPhongMaterial({
        defaultColor: createRandomColor(),
        side: MeshMaterial.Sides.DOUBLE,
        translucent: false
      })
    }

    function createObjects() {
      const pos = new Cesium.Cartesian3()
      const quat = new Cesium.Quaternion()

      // Ground
      pos.x = 0
      pos.y = -0.5
      pos.z = 0
      quat.x = 0
      quat.y = 0
      quat.z = 0
      quat.w = 1
      const ground = createParalellepiped(
        40,
        1,
        40,
        0,
        pos,
        quat,
        new MeshPhongMaterial({
          defaultColor: "rgb(125,125,125)",
          side: MeshMaterial.Sides.DOUBLE,
          translucent: false
        })
      )

      // Wall
      const brickMass = 0.5
      const brickLength = 1.2
      const brickDepth = 0.6
      const brickHeight = brickLength * 0.5
      const numBricksLength = 6
      const numBricksHeight = 8
      const z0 = -numBricksLength * brickLength * 0.5

      pos.x = 0
      pos.y = brickHeight * 0.5
      pos.z = z0
      quat.x = 0
      quat.y = 0
      quat.z = 0
      quat.w = 1

      for (let j = 0; j < numBricksHeight; j++) {
        const oddRow = j % 2 === 1

        pos.z = z0

        if (oddRow) {
          pos.z -= 0.25 * brickLength
        }

        const nRow = oddRow ? numBricksLength + 1 : numBricksLength
        for (let i = 0; i < nRow; i++) {
          let brickLengthCurrent = brickLength
          let brickMassCurrent = brickMass
          if (oddRow && (i === 0 || i === nRow - 1)) {
            brickLengthCurrent *= 0.5
            brickMassCurrent *= 0.5
          }

          const brick = createParalellepiped(brickDepth, brickHeight, brickLengthCurrent, brickMassCurrent, pos, quat, createMaterial())

          if (oddRow && (i === 0 || i === nRow - 2)) {
            pos.z += 0.75 * brickLength
          } else {
            pos.z += brickLength
          }
        }
        pos.y += brickHeight
      }

      // The cloth
      // Cloth graphic object
      const clothWidth = 4
      const clothHeight = 3
      const clothNumSegmentsZ = clothWidth * 5
      const clothNumSegmentsY = clothHeight * 5
      const clothSegmentLengthZ = clothWidth / clothNumSegmentsZ
      const clothSegmentLengthY = clothHeight / clothNumSegmentsY
      const clothPos = new Cesium.Cartesian3(-3, 3, 2)

      const clothGeometry = new PlaneBufferGeometry(clothWidth, clothHeight, clothNumSegmentsZ, clothNumSegmentsY)

      const clothMaterial = new MeshPhongMaterial({
        defaultColor: "rgb(255,255,255)",
        side: MeshMaterial.Sides.DOUBLE,
        translucent: false
      })

      cloth = new Mesh(clothGeometry, clothMaterial)
      GeometryUtils.rotateY(cloth.geometry, Math.PI * 0.5)
      GeometryUtils.translate(cloth.geometry, clothPos.x, clothPos.y + clothHeight * 0.5, clothPos.z - clothWidth * 0.5)
      GeometryUtils.computeVertexNormals(cloth.geometry)
      meshVisualizer.add(cloth)

      // Cloth physic object
      const softBodyHelpers = new Ammo.btSoftBodyHelpers()
      const clothCorner00 = new Ammo.btVector3(clothPos.x, clothPos.y + clothHeight, clothPos.z)
      const clothCorner01 = new Ammo.btVector3(clothPos.x, clothPos.y + clothHeight, clothPos.z - clothWidth)
      const clothCorner10 = new Ammo.btVector3(clothPos.x, clothPos.y, clothPos.z)
      const clothCorner11 = new Ammo.btVector3(clothPos.x, clothPos.y, clothPos.z - clothWidth)
      const clothSoftBody = softBodyHelpers.CreatePatch(
        physicsWorld.getWorldInfo(),
        clothCorner00,
        clothCorner01,
        clothCorner10,
        clothCorner11,
        clothNumSegmentsZ + 1,
        clothNumSegmentsY + 1,
        0,
        true
      )
      const sbConfig = clothSoftBody.get_m_cfg()
      sbConfig.set_viterations(10)
      sbConfig.set_piterations(10)

      clothSoftBody.setTotalMass(0.9, false)
      Ammo.castObject(clothSoftBody, Ammo.btCollisionObject)
        .getCollisionShape()
        .setMargin(margin * 3)
      physicsWorld.addSoftBody(clothSoftBody, 1, -1)
      cloth.physicsBody = clothSoftBody
      // Disable deactivation
      clothSoftBody.setActivationState(4)

      // The base
      const armMass = 2
      const armLength = 3 + clothWidth
      const pylonHeight = clothPos.y + clothHeight
      const baseMaterial = new MeshPhongMaterial({
        defaultColor: "rgb(255,255,0)",
        side: MeshMaterial.Sides.DOUBLE,
        translucent: false
      })

      pos.x = clothPos.x
      pos.y = 0.1
      pos.z = clothPos.z - armLength
      quat.x = 0
      quat.y = 0
      quat.z = 0
      quat.w = 1
      const base = createParalellepiped(1, 0.2, 1, 0, pos, quat, baseMaterial)

      pos.x = clothPos.x
      pos.y = 0.5 * pylonHeight
      pos.z = clothPos.z - armLength

      const pylon = createParalellepiped(0.4, pylonHeight, 0.4, 0, pos, quat, baseMaterial)

      pos.x = clothPos.x
      pos.y = pylonHeight + 0.2
      pos.z = clothPos.z - 0.5 * armLength
      const arm = createParalellepiped(0.4, 0.4, armLength + 0.4, armMass, pos, quat, baseMaterial)

      // Glue the cloth to the arm
      const influence = 0.5
      clothSoftBody.appendAnchor(0, arm.physicsBody, false, influence)
      clothSoftBody.appendAnchor(clothNumSegmentsZ, arm.physicsBody, false, influence)

      // Hinge constraint to move the arm
      const pivotA = new Ammo.btVector3(0, pylonHeight * 0.5, 0)
      const pivotB = new Ammo.btVector3(0, -0.2, -armLength * 0.5)
      const axis = new Ammo.btVector3(0, 1, 0)
      hinge = new Ammo.btHingeConstraint(pylon.physicsBody, arm.physicsBody, pivotA, pivotB, axis, axis, true)
      physicsWorld.addConstraint(hinge, true)
    }

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

      threeObject.quaternion = new Cesium.Quaternion()
      threeObject.geometry.attributes.uv = threeObject.geometry.attributes.st
      threeObject.geometry.attributes.st = undefined
      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)
      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)
    }

    // deltaTime单位是：秒/s
    function updatePhysics(deltaTime) {
      // Hinge control
      hinge.enableAngularMotor(true, 0.8 * armMovement, 50)

      // Step world
      physicsWorld.stepSimulation(deltaTime, 10)

      // Update cloth
      const softBody = cloth.physicsBody
      const clothPositions = cloth.geometry.attributes.position.values
      const numVerts = clothPositions.length / 3
      const nodes = softBody.get_m_nodes()
      let indexFloat = 0
      for (let i = 0; i < numVerts; i++) {
        const node = nodes.at(i)
        const nodePos = node.get_m_x()
        clothPositions[indexFloat++] = nodePos.x()
        clothPositions[indexFloat++] = nodePos.y()
        clothPositions[indexFloat++] = nodePos.z()
      }

      cloth.geometry.attributes.position.needsUpdate = true
      if (cloth.geometry.primitiveType === Cesium.PrimitiveType.TRIANGLES) {
        // Cesium.GeometryPipeline.computeNormal(cloth.geometry);
        GeometryUtils.computeVertexNormals(cloth.geometry)
      }

      // Update rigid bodies
      for (let i = 0, il = rigidBodies.length; i < il; i++) {
        const objGraph = rigidBodies[i]
        const objPhys = objGraph.physicsBody
        const ms = objPhys.getMotionState()
        if (ms) {
          ms.getWorldTransform(transformAux1)
          const p = transformAux1.getOrigin()
          const q = transformAux1.getRotation()
          objGraph.position.x = p.x()
          objGraph.position.y = p.y()
          objGraph.position.z = p.z()
          objGraph.quaternion.x = q.x()
          objGraph.quaternion.y = q.y()
          objGraph.quaternion.z = q.z()
          objGraph.quaternion.w = q.w()
          // objGraph.needsUpdate = true;
          objGraph.modelMatrixNeedsUpdate = true
        }
      }
    }

    let start = false
    function initInput() {
      window.addEventListener(
        "keydown",
        function (event) {
          if (!start) {
            return
          }
          switch (event.keyCode) {
            // Q
            case 81:
              armMovement = 1
              break

            // A
            case 65:
              armMovement = -1
              break
          }
        },
        false
      )

      window.addEventListener(
        "keyup",
        function (event) {
          armMovement = 0
        },
        false
      )
    }

    let startTime = new Date()
    function update(frameState) {
      const deltaTime = (new Date() - startTime) / 1000.0
      updatePhysics(deltaTime)
      startTime = new Date()
    }

    let init = false
    setTimeout(function () {
      if (!init) {
        initPhysics()

        createObjects()

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

  // });
}