// cloth rendering
// simulate
// setup scene

const MASS = 0.1;

class Particle {
  constructor(x, y, z, mass) {
    this.position = new THREE.Vector3(x, y, z);
    this.previous = new THREE.Vector3(x, y, z);
    this.acceleration = new THREE.Vector3(0, 0, 0);
    this.mass = mass;
  }
  addForce(force) {

  }
  verlet(dt) {

  }
}

class Cloth {
  constructor(width, height, numPointsWidth, numPointsHeight) {
    this.width = width;
    this.height = height;
    this.numPointsWidth = numPointsWidth;
    this.numPointsHeight = numPointsHeight;

    /**
     * distance between two vertices horizontally/vertically
     * divide by the number of points minus one
     * because there are (n - 1) lines between n vertices
     */
    let stepWidth = width / (numPointsWidth - 1);
    let stepHeight = height / (numPointsHeight - 1);

    /**
     * iterate over the number of vertices in x/y axis
     * and add a new Particle to "particles"
     */
    this.particles = [];
    for (let y = 0; y < numPointsHeight; y++) {
      for (let x = 0; x < numPointsWidth; x++) {
        this.particles.push(
          new Particle(
            (x - ((numPointsWidth-1)/2)) * stepWidth,
            height - (y + ((numPointsHeight-1)/2)) * stepHeight,
            0,
            MASS)
        );
      }
    }
  }
  generateGeometry() {
    const geometry = new THREE.BufferGeometry();

    const vertices = [];
    const normals = [];
    const indices = [];

    for (let particle of this.particles) {
      vertices.push(
        particle.position.x,
        particle.position.y,
        particle.position.z);
    }

    const numPointsWidth = this.numPointsWidth;
    const numPointsHeight = this.numPointsHeight;

    /**
     * helper function to calculate index of vertex
     * in "vertices" array based on its x and y positions
     * in the mesh
     * @param {number} x - x index of vertex
     * @param {number} y - y index of vertex
     */
    function getVertexIndex(x, y) {
      return y * numPointsWidth + x;
    }

    /**
     * generate faces based on 4 vertices
     * and 6 springs each
     */
    for (let y = 0; y < numPointsHeight - 1; y++) {
      for (let x = 0; x < numPointsWidth - 1; x++) {
        indices.push(
          getVertexIndex(x, y),
          getVertexIndex(x+1, y),
          getVertexIndex(x+1, y+1)
        );
        indices.push(
          getVertexIndex(x, y),
          getVertexIndex(x+1, y+1),
          getVertexIndex(x, y+1)
        );
      }
    }

    geometry.setIndex(indices);
    geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
    //geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
    geometry.computeBoundingSphere();
    geometry.computeVertexNormals();

    return geometry;
  }
  updateGeometry(geometry) {

  }
}