import { Points, Mesh, MeshBasicMaterial, VertexColors, TrianglesDrawMode } from 'three'

import { scene } from '../renderer'

import DRACOLoader from '../../util/vendor/DRACOLoader'
import GeometryHelper from '../../util/vendor/geometryHelper'

import { getBboxScaleAndCentroid } from './util'

import { FACE_SCALE } from '../constants'

DRACOLoader.setDecoderPath('/assets/js/vendor/draco/')

const dracoLoader = new DRACOLoader()
DRACOLoader.getDecoderModule()

export function load(name) {
  dracoLoader.setVerbosity(1)
  dracoLoader.setDrawMode(TrianglesDrawMode)
  dracoLoader.setSkipDequantization('position', true)
  dracoLoader.load('/assets/data/faces/' + name + '.drc', dracoDidLoad)
}

export function update(name) {
  load(name)
}

function setDequantizationForMaterial(material, bufferGeometry) {
  material.onBeforeCompile = (shader) => {
    // Add uniform variables needed for dequantization.
    const posAttribute = bufferGeometry.attributes.position
    shader.uniforms.normConstant = { value: posAttribute.maxRange / (1 << posAttribute.numQuantizationBits) }
    shader.uniforms.minPos = { value: posAttribute.minValues }

    shader.vertexShader = 'uniform float maxRange;\n' +
                          'uniform float normConstant;\n' +
                          'uniform vec3 minPos;\n' +
                          shader.vertexShader
    shader.vertexShader = shader.vertexShader.replace(
      '#include <begin_vertex>',
      'vec3 transformed = minPos + position * normConstant;'
    )
  }
}

function dracoDidLoad(bufferGeometry) {
  const material = new MeshBasicMaterial({ vertexColors: VertexColors })
  material.wireframe = true
  // If the position attribute is quantized, modify the material to perform
  // dequantization on the GPU.
  if (bufferGeometry.attributes.position.isQuantized) {
    setDequantizationForMaterial(material, bufferGeometry)
  }

  let geometry
  // Point cloud does not have face indices.
  if (bufferGeometry.index === null) {
    geometry = new Points(bufferGeometry, material)
  } else {
    if (bufferGeometry.attributes.normal === undefined) {
      const geometryHelper = new GeometryHelper()
      geometryHelper.computeVertexNormals(bufferGeometry)
    }
    geometry = new Mesh(bufferGeometry, material)
    geometry.drawMode = dracoLoader.drawMode
  }

  // Compute range of the geometry coordinates for proper rendering.
  bufferGeometry.computeBoundingBox()
  const bbox = bufferGeometry.boundingBox
  const { scale, midX, midY, midZ } = getBboxScaleAndCentroid(bbox, bufferGeometry.attributes.position)
  geometry.scale.multiplyScalar(scale * FACE_SCALE)
  geometry.position.x = -midX * scale
  geometry.position.y = -midY * scale
  geometry.position.z = -midZ * scale
  geometry.frustumCulled = false
  // geometry.castShadow = true
  // geometry.receiveShadow = true

  const selectedObject = scene.getObjectByName("my_mesh")
  scene.remove(selectedObject)
  geometry.name = "my_mesh"
  scene.add(geometry)
}