public class Cube {
	final int X = 0;
	final int Y = 1;
	final int Z = 2;
	final int NX = 3;
	final int NY = 4;
	final int NZ = 5;

	Material material;

	int[][] faces = {
		{ 0, 1, 2, 3 },
		{ 4, 5, 6, 7 },
		{ 8, 9, 10, 11 },
		{ 12, 13, 14, 15 },
		{ 16, 17, 18, 19 },
		{ 20, 21, 22, 23 }
	};
		
	double[][] vertices = new double[24][6];

	public Cube() {
		reset();
	}

	public void reset() {
		double[][] unitVertices = {
			{-1,-1,-1,-1, 0, 0 },
			{-1,-1, 1,-1, 0, 0 },
			{-1, 1, 1,-1, 0, 0 },
			{-1, 1,-1,-1, 0, 0 },
			{ 1,-1,-1, 1, 0, 0 },
			{ 1, 1,-1, 1, 0, 0 },
			{ 1, 1, 1, 1, 0, 0 },
			{ 1,-1, 1, 1, 0, 0 },

			{-1,-1,-1, 0,-1, 0 },
			{ 1,-1,-1, 0,-1, 0 },
			{ 1,-1, 1, 0,-1, 0 },
			{-1,-1, 1, 0,-1, 0 },
			{-1, 1,-1, 0, 1, 0 },
			{-1, 1, 1, 0, 1, 0 },
			{ 1, 1, 1, 0, 1, 0 },
			{ 1, 1,-1, 0, 1, 0 },

			{-1,-1,-1, 0, 0,-1 },
			{-1, 1,-1, 0, 0,-1 },
			{ 1, 1,-1, 0, 0,-1 },
			{ 1,-1,-1, 0, 0,-1 },
			{-1,-1, 1, 0, 0, 1 },
			{ 1,-1, 1, 0, 0, 1 },
			{ 1, 1, 1, 0, 0, 1 },
			{-1, 1, 1, 0, 0, 1 }
		};

		vertices = unitVertices;
	}

	public void setMaterial(Material m) {
		material = m.copy();
	}
	
	public void bufferTo(double[][] zBuffer, double[][][] frameBuffer, Light[] lights, double focalLength) {

		for (int i = 0; i < faces.length; i++) {
			Triangle triangle1 = makeTriangle( vertices[faces[i][0]],
								vertices[faces[i][1]],
								vertices[faces[i][2]]);
			Triangle triangle2 = makeTriangle( vertices[faces[i][2]],
								vertices[faces[i][3]],
								vertices[faces[i][0]]);

			triangle1.perspectiveTransform(focalLength);
			triangle1.viewportTransform(zBuffer.length, zBuffer[0].length);
			triangle1.calculateColors(lights);

			//triangle1.print();

			triangle1.bufferTo(zBuffer, frameBuffer);


			triangle2.perspectiveTransform(focalLength);
			triangle2.viewportTransform(zBuffer.length, zBuffer[0].length);
			triangle2.calculateColors(lights);

			//triangle2.print();

			triangle2.bufferTo(zBuffer, frameBuffer);
		}
	}

	private Triangle makeTriangle(double[] v0, double[] v1, double[] v2) {
		Triangle triangle = new Triangle();

		double[][] vertices = 	{
						{v0[X], v0[Y], v0[Z]},
						{v1[X], v1[Y], v1[Z]},
						{v2[X], v2[Y], v2[Z]}
					};

		double[][] normals = 	{
						{v0[NX], v0[NY], v0[NZ]},
						{v1[NX], v1[NY], v1[NZ]},
						{v2[NX], v2[NY], v2[NZ]}
					};

                triangle.setVertices(vertices);
                triangle.setNormals(normals);
                triangle.setAmbientColor(material.getAmbientColor());
                triangle.setDiffuseColor(material.getDiffuseColor());
                triangle.setSpecularColor(material.getSpecularColor());
                triangle.setSpecularPower(material.specularPower);

                return triangle;

	}

	public void printVertices() {
		System.out.println("Vertices");
		for (int i = 0; i < vertices.length; i++) {
			System.out.println(i + ": {" + vertices[i][X]  + ", " + vertices[i][Y] + ", " + vertices[i][Z] + "}");
		}
	}

	public void transformedBy(Matrix3D t) {

		double[][] transformed = new double[vertices.length][6];

		for (int i = 0; i < transformed.length; i++) {
			double[] point = { vertices[i][X], vertices[i][Y], vertices[i][Z] };
			double[] transPoint = t.transform(point);

			transformed[i][X] = transPoint[0];
			transformed[i][Y] = transPoint[1];
			transformed[i][Z] = transPoint[2];
		}

		double[][] gradients = new double[faces.length][3];

		for (int i = 0; i < faces.length; i++) {
			double[] v1minusv0 = {
				transformed[faces[i][1]][X] - transformed[faces[i][0]][X],
				transformed[faces[i][1]][Y] - transformed[faces[i][0]][Y],
				transformed[faces[i][1]][Z] - transformed[faces[i][0]][Z]
			 };

			double[] v2minusv1 = {
				transformed[faces[i][2]][X] - transformed[faces[i][1]][X],
				transformed[faces[i][2]][Y] - transformed[faces[i][1]][Y],
				transformed[faces[i][2]][Z] - transformed[faces[i][1]][Z]
			 };

			gradients[i][X] = v1minusv0[Y] * v2minusv1[Z] - v1minusv0[Z] * v2minusv1[Y];
			gradients[i][Y] = v1minusv0[Z] * v2minusv1[X] - v1minusv0[X] * v2minusv1[Z];
			gradients[i][Z] = v1minusv0[X] * v2minusv1[Y] - v1minusv0[Y] * v2minusv1[X];

		}

		double[] sum = new double[3];

		for (int i = 0; i < transformed.length; i++) {

			transformed[i][NX] = 0;
			transformed[i][NY] = 0;
			transformed[i][NZ] = 0;

			for (int j = 0; j < faces.length; j++) {
				for (int k = 0; k < faces[j].length; k++) {
					if (faces[j][k] == i) {
						transformed[i][NX] = gradients[j][X];
						transformed[i][NY] = gradients[j][Y];
						transformed[i][NZ] = gradients[j][Z];
						break;
					}
				}
			}

			double magnitude = Math.sqrt( 
						transformed[i][NX] * transformed[i][NX] +
						transformed[i][NY] * transformed[i][NY] +
						transformed[i][NZ] * transformed[i][NZ]
						);

			transformed[i][NX] /= magnitude;
			transformed[i][NY] /= magnitude;
			transformed[i][NZ] /= magnitude;

			//System.out.println("normal " + i + " is {" + transformed[i][NX] + ", " + transformed[i][NY] + ", " + transformed[i][NZ] + "}");
		
		}

		vertices = transformed;
	}

}