import * as mars3d from "mars3d"

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

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

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

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

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

function addDemo() {
  const MeshVisualizer = Cesium.MeshVisualizer
  const Mesh = Cesium.Mesh
  const MeshMaterial = Cesium.MeshMaterial
  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 // 显示坐标轴

  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
    })
  }

  Cesium.Cartesian3.prototype.set = function (x, y, z) {
    this.x = x
    this.y = y
    this.z = z
  }
  Cesium.Cartesian3.prototype.copy = function (src) {
    this.x = src.x
    this.y = src.y
    this.z = src.z
  }

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

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

    // - Global variables -

    // 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 rope
    const transformAux1 = new Ammo.btTransform()

    const time = 0
    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 createObjects() {
      const pos = new Cesium.Cartesian3()
      const quat = new Cesium.Quaternion()

      // 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: Cesium.Color.fromRgba(0xffffff).withAlpha(1), // "rgb(200,200,200)",
          side: MeshMaterial.Sides.DOUBLE,
          translucent: false
        })
      )
      ground.quaternion = null
      // Ball
      const ballMass = 1.2
      const ballRadius = 0.6

      const ball = new Mesh(
        new Cesium.SphereGeometry({
          radius: ballRadius,
          stackPartitions: 20,
          slicePartitions: 20
        }),
        new MeshPhongMaterial({
          defaultColor: Cesium.Color.fromRgba(0x000000).withAlpha(1),
          side: MeshMaterial.Sides.DOUBLE,
          translucent: false
        })
      )

      const ballShape = new Ammo.btSphereShape(ballRadius)
      ballShape.setMargin(margin)
      pos.set(-3, 2, 0)
      quat.set(0, 0, 0, 1)
      createRigidBody(ball, ballShape, ballMass, pos, quat)
      ball.physicsBody.setFriction(0.5)

      // 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.set(0, brickHeight * 0.5, z0)
      quat.set(0, 0, 0, 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 rope
      // Rope graphic object
      const ropeNumSegments = 10
      const ropeLength = 4
      const ropeMass = 3
      const ropePos = ball.position.clone()
      ropePos.y += ballRadius

      const segmentLength = ropeLength / ropeNumSegments
      const ropeMaterial = new MeshMaterial({
        defaultColor: Cesium.Color.fromRgba(0x000000).withAlpha(1),
        side: MeshMaterial.Sides.DOUBLE,
        translucent: false,
        wireframe: true
      })
      const ropePositions = []
      const ropeIndices = []

      for (let i = 0; i < ropeNumSegments + 1; i++) {
        ropePositions.push(ropePos.x, ropePos.y + i * segmentLength, ropePos.z)
      }

      for (let i = 0; i < ropeNumSegments; i++) {
        ropeIndices.push(i, i + 1)
      }

      const ropeGeometry = new Cesium.Geometry({
        attributes: {
          position: new Cesium.GeometryAttribute({
            componentDatatype: Cesium.ComponentDatatype.DOUBLE,
            componentsPerAttribute: 3,
            values: new Float32Array(ropePositions)
          })
        },
        indices: new Uint16Array(ropeIndices),
        primitiveType: Cesium.PrimitiveType.LINES,
        boundingSphere: Cesium.BoundingSphere.fromVertices(ropePositions)
      })

      rope = new Mesh(ropeGeometry, ropeMaterial)
      meshVisualizer.add(rope)

      // Rope physic object
      const softBodyHelpers = new Ammo.btSoftBodyHelpers()
      const ropeStart = new Ammo.btVector3(ropePos.x, ropePos.y, ropePos.z)
      const ropeEnd = new Ammo.btVector3(ropePos.x, ropePos.y + ropeLength, ropePos.z)
      const ropeSoftBody = softBodyHelpers.CreateRope(physicsWorld.getWorldInfo(), ropeStart, ropeEnd, ropeNumSegments - 1, 0)
      const sbConfig = ropeSoftBody.get_m_cfg()
      sbConfig.set_viterations(10)
      sbConfig.set_piterations(10)
      ropeSoftBody.setTotalMass(ropeMass, false)
      Ammo.castObject(ropeSoftBody, Ammo.btCollisionObject)
        .getCollisionShape()
        .setMargin(margin * 3)
      physicsWorld.addSoftBody(ropeSoftBody, 1, -1)
      rope.physicsBody = ropeSoftBody
      // Disable deactivation
      ropeSoftBody.setActivationState(4)

      // The base
      const armMass = 2
      const armLength = 3
      const pylonHeight = ropePos.y + ropeLength
      const baseMaterial = createMaterial()
      pos.set(ropePos.x, 0.1, ropePos.z - armLength)
      quat.set(0, 0, 0, 1)
      const base = createParalellepiped(1, 0.2, 1, 0, pos, quat, baseMaterial)
      base.quaternion = null
      pos.set(ropePos.x, 0.5 * pylonHeight, ropePos.z - armLength)
      const pylon = createParalellepiped(0.4, pylonHeight, 0.4, 0, pos, quat, baseMaterial)
      pylon.quaternion = null

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

      // Glue the rope extremes to the ball and the arm
      const influence = 1
      ropeSoftBody.appendAnchor(0, ball.physicsBody, true, influence)
      ropeSoftBody.appendAnchor(ropeNumSegments, arm.physicsBody, true, 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 box = Cesium.BoxGeometry.fromDimensions({
        dimensions: new Cesium.Cartesian3(sx, sy, sz),
        vertexFormat: new Cesium.VertexFormat({
          position: true,
          normal: true
        })
      })
      const threeObject = new 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) {
      threeObject.position.copy(pos)
      threeObject.quaternion = new Cesium.Quaternion(quat)

      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)
    }

    function initInput() {
      window.addEventListener(
        "keydown",
        function (event) {
          switch (event.keyCode) {
            // Q
            case 81:
              armMovement = 1
              break

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

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

    function updatePhysics(deltaTime) {
      // Hinge control
      hinge.enableAngularMotor(true, 1.5 * armMovement, 50)

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

      // Update rope
      const softBody = rope.physicsBody
      const ropePositions = rope.geometry.attributes.position.values
      const numVerts = ropePositions.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()
        ropePositions[indexFloat++] = nodePos.x()
        ropePositions[indexFloat++] = nodePos.y()
        ropePositions[indexFloat++] = nodePos.z()
      }
      rope.geometry.attributes.position.needsUpdate = 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())
          if (objThree.quaternion) {
            objThree.quaternion.set(q.x(), q.y(), q.z(), q.w())
          }
          objThree.modelMatrixNeedsUpdate = true
        }
      }
    }

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

      startTime = new Date()
    }
    setTimeout(function () {
      if (!init) {
        // - Init -

        initPhysics()

        createObjects()

        initInput()

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