/**
 *     DOUBLE BLACK DIAMOND        DOUBLE BLACK DIAMOND
 *
 *         //\\   //\\                 //\\   //\\  
 *        ///\\\ ///\\\               ///\\\ ///\\\
 *        \\\/// \\\///               \\\/// \\\///
 *         \\//   \\//                 \\//   \\//
 *
 *        EXPERTS ONLY!!              EXPERTS ONLY!!
 *
 * This file implements the mapping functions needed to lay out the physical
 * cubes and the output ports on the panda board. It should only be modified
 * when physical changes or tuning is being done to the structure.
 */

public Model buildModel() {

  // Shorthand helpers for specifying wiring more quickly
  final Cube.Wiring WFL = Cube.Wiring.FRONT_LEFT;
  final Cube.Wiring WFR = Cube.Wiring.FRONT_RIGHT;
  final Cube.Wiring WRL = Cube.Wiring.REAR_LEFT;
  final Cube.Wiring WRR = Cube.Wiring.REAR_RIGHT;

  // Utility value if you need the height of a cube shorthand
  final float CH = Cube.EDGE_HEIGHT;
  final float CW = Cube.EDGE_WIDTH ;

  // Positions for the bass box
  final float BBY = BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH;
  final float BBX = 56;
  final float BBZ = 2;

  // The model is represented as an array of towers. The cubes in the tower
  // are represenented relatively. Each tower has an x, y, z reference position,
  // which is typically the base cube's bottom left corner.
  //
  // Following that is an array of floats. A 2-d array contains an x-offset
  // and a z-offset from the previous reference position. Typically the first cube
  // will just be {0, 0}. Each successive cube uses the position of the previous
  // cube as its reference.
  //
  // A 3-d array contains an x-offset, a z-offset, and a rotation about the
  // y-axis.
  //
  // The cubes automatically increment their y-position by Cube.EDGE_HEIGHT.

  // To-Do:  (Mark Slee, Alex Green, or Ben Morrow):   The Cube # is determined by the order in this list.
  // "raw object index" is serialized by running through towermapping and then individual cube mapping below.
  //  We can do better than this.  The raw object index should be obvious from the code-- looking through the
  //  rendered simulation and counting through cubes in mapping mode is grossly inefficient. 

  // Single cubes can be constructed directly here if you need them
  Cube[] singleCubes = new Cube[] {
    // new Cube(15, int( Cube.EDGE_HEIGHT), 39, 0, 10, 0,  WRL),     // Back left channel behind speaker
    // new Cube(x, y, z, rx, ry, rz, wiring),
    // new Cube(0,0,0,0,225,0, WRR),
  };

  // The bass box!
  BassBox bassBox = BassBox.noBassBox(); // no bass box at all

  // The speakers!
  List<Speaker> speakers = Arrays.asList(new Speaker[] {
    // Each speaker parameter is x, y, z, rotation, the left speaker comes first
    // new Speaker(TRAILER_WIDTH - Speaker.EDGE_WIDTH + 8, 6, 3, -15)
  }
  );

  List<StaggeredTower> scubes = new ArrayList<StaggeredTower>();        

  float[] pos = new float[3];
  pos[0] = 50;
  pos[2] = 100;
  scubes.add(new StaggeredTower(//tower 1
    pos[0], // x
    0, // y
    pos[2], // z
    0, 4, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));


  pos[0] += 25;
  pos[2] -= 10;
  scubes.add(new StaggeredTower(// tower 2
    pos[0], // x
    15, // y
    pos[2], // z
    0, 4, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));

  pos[0] += 25;
  pos[2] += -12.5;
  scubes.add(new StaggeredTower(//tower 3
    pos[0], // x
    0, // y
    pos[2], // z
    0, 5, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));

  pos[0] += -32.75;
  pos[2] += -13;
  scubes.add(new StaggeredTower(//tower 4
    pos[0], // x
    0, // y
    pos[2], // z
    0, 6, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));

  pos[0] += 26;
  pos[2] += -16;
  scubes.add(new StaggeredTower(//tower 5
    pos[0], // x
    15, // y
    pos[2], // z
    0, 6, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));

  pos[0] += 26;
  pos[2] += -4.5;
  scubes.add(new StaggeredTower(//tower 6
    pos[0], // x
    0, // y
    pos[2], // z
    0, 6, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));

  pos[0] += -56.5;
  pos[2] += -6.5;
  scubes.add(new StaggeredTower(// tower 7
    pos[0], // x
    15, // y
    pos[2], // z
    0, 4, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));

  pos[0] += 26;
  pos[2] += -16.5;     
  scubes.add(new StaggeredTower(//tower 8
    pos[0], // x
    0, // y
    pos[2], // z
    0, 5, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));

  pos[0] += 27;
  pos[2] += -4.5;
  scubes.add(new StaggeredTower(//tower 9
    pos[0], // x
    15, // y
    pos[2], // z
    0, 5, new Cube.Wiring[] { 
      WRR, WRR, WRR, WRR, WRR, WRR
    }
  ));


  //////////////////////////////////////////////////////////////////////
  //      BENEATH HERE SHOULD NOT REQUIRE ANY MODIFICATION!!!!        //
  //////////////////////////////////////////////////////////////////////

  // These guts just convert the shorthand mappings into usable objects
  List<Tower> towerList = new ArrayList<Tower>();
  List<Cube> tower;
  Cube[] cubes = new Cube[200];
  int cubeIndex = 1;  

  for (Cube cube : singleCubes) {
    cubes[cubeIndex++] = cube;
  }
  for (StaggeredTower st : scubes) {
    tower = new ArrayList<Cube>();
    for (int i = 0; i < st.n; i++) {
      Cube.Wiring w = (i < st.wiring.length) ? st.wiring[i] : WRR;
      tower.add(cubes[cubeIndex++] = new Cube(st.x, st.y + CH* 4/3.*i, st.z, 0, st.r, 0, w));
    }
    towerList.add(new Tower(tower));
  }   

  return new Model(towerList, cubes, bassBox, speakers);
}

class StaggeredTower {
  public final float x, y, z, r;
  public final int n;
  public final Cube.Wiring[] wiring;
  StaggeredTower(float _x, float _y, float _z, float _r, int _n) { 
    this(_x, _y, _z, _r, _n, new Cube.Wiring[] {
    }
    );
  }
  StaggeredTower(float _x, float _y, float _z, float _r, int _n, Cube.Wiring[] _wiring) { 
    x=_x; 
    y=_y; 
    z=_z; 
    r=_r; 
    n=_n; 
    wiring=_wiring;
  }
}