public class Sphere {

	int M, N; // mesh dimensions

	double mesh[][][];
	double[] center = {0, 0, 0};
	Material material;

	double[][] color = {{0.2,0.6,0.2},{0.2,0.6,0.2},{0.2,0.6,0.2}};
	public Sphere(int m, int n) {
		M = m;
		N = n;
		mesh = new double[M][N][3];
		fillMesh();
	}

	public void printMesh() {
		System.out.print("\n");
		for (int i = 0; i < mesh.length; i++) {
			System.out.print("\n");
			for (int j=0; j < mesh[i].length; j++)
				System.out.print("{" + mesh[i][j][0] + ", " + mesh[i][j][1] + ", " + mesh[i][j][2] + "}");
		}
		System.out.print("\n");
	}

	public void reset() {
		center[0] = 0;
		center[1] = 0;
		center[2] = 0;
		fillMesh();
	};

	public void setMaterial(Material m) {
		material = m.copy();
	}

	public void bufferTo(double[][] zBuffer, double[][][] frameBuffer, Light[] lights, double focalLength) {
		//System.out.println("Center is {" + center[0] + ", " + center[1] + ", " + center[2] + "}");
		// Go over all vertices and make triangles
                for (int i = 0; i < M - 1; i++)
                        for (int j = 0; j < N - 1; j++) {

				//System.out.println("vertices for tri1: { {" + mesh[i][j][0] + ", " + mesh[i][j][1] + ", " + mesh[i][j][2] + "}, {" + mesh[i+1][j][0] + ", " + mesh[i+1][j][1] + ", " + mesh[i+1][j][2] + "}, {" + mesh[i+1][j+1][0] + ", " + mesh[i+1][j+1][1] + ", " + mesh[i+1][j+1][2] + "} }");
                                Triangle triangle1 = makeTriangle(mesh[i][j], mesh[i+1][j], mesh[i+1][j+1]);
				//System.out.println("vertices for tri2: { {" + mesh[i][j][0] + ", " + mesh[i][j][1] + ", " + mesh[i][j][2] + "}, {" + mesh[i+1][j+1][0] + ", " + mesh[i+1][j+1][1] + ", " + mesh[i+1][j+1][2] + "}, {" + mesh[i][j+1][0] + ", " + mesh[i][j+1][1] + ", " + mesh[i][j+1][2] + "} }");
                                Triangle triangle2 = makeTriangle(mesh[i][j], mesh[i+1][j+1], mesh[i][j+1]);

		                triangle1.perspectiveTransform(focalLength);
				//System.out.println("perspective Transformed");
				//triangle1.print();
                		triangle2.perspectiveTransform(focalLength);

		                triangle1.viewportTransform(zBuffer.length, zBuffer[0].length);
				//System.out.println("viewport Transformed");
				//triangle1.print();
                		triangle2.viewportTransform(zBuffer.length, zBuffer[0].length);

				//System.out.println("PRE calculateColors()");
				//triangle1.printColors();

                		triangle1.calculateColors(lights);
                		triangle2.calculateColors(lights);
				
				//System.out.println("POST calculateColors()");
				//triangle1.printColors();

				//triangle1.setPointColors(color);		
				//triangle2.setPointColors(color);		

				//System.out.println("buffer triangle 1");
				triangle1.bufferTo(zBuffer, frameBuffer);
				//System.out.println("buffer triangle 2");
				triangle2.bufferTo(zBuffer, frameBuffer);
				
                        }

	}

	private Triangle makeTriangle(double[] p0, double[] p1, double[] p2) {
		double[][] vertices = { {p0[0], p0[1], p0[2]},
					{p1[0], p1[1], p1[2]},
					{p2[0], p2[1], p2[2]} };

                double[][] normals =    {
                                                {p0[0] - center[0], p0[1] - center[1], p0[2] - center[2] },
                                                {p1[0] - center[0], p1[1] - center[1], p1[2] - center[2] },
                                                {p2[0] - center[0], p2[1] - center[1], p2[2] - center[2] }
                                        };
		// DO I NEED THIS STUFF?

                //double[] distances =    {
                                                //Math.sqrt(Math.pow(normals[0][0], 2) + Math.pow(normals[0][1], 2) + Math.pow(normals[0][2], 2)),
                                                //Math.sqrt(Math.pow(normals[1][0], 2) + Math.pow(normals[1][1], 2) + Math.pow(normals[1][2], 2)),
                                                //Math.sqrt(Math.pow(normals[2][0], 2) + Math.pow(normals[2][1], 2) + Math.pow(normals[2][2], 2)),
                                        //};

                //normals[0][0] /= distances[0];
                //normals[0][1] /= distances[0];
                //normals[0][2] /= distances[0];
//
                //normals[1][0] /= distances[1];
                //normals[1][1] /= distances[1];
                //normals[1][2] /= distances[1];
//
                //normals[2][0] /= distances[2];
                //normals[2][1] /= distances[2];
                //normals[2][2] /= distances[2];

		Triangle triangle = new Triangle();

		//System.out.println("vertices for tri: { {" + p0[0] + ", " + p0[1] + ", " + p0[2] + "}, {" + p1[0] + ", " + p1[1] + ", " + p1[2] + "}, {" + p2[0] + ", " + p2[1] + ", " + p2[2] + "} }");
		//System.out.println("normals for tri: { {" + normals[0][0] + ", " + normals[0][1] + ", " + normals[0][2] + "}, {" + normals[1][0] + ", " + normals[1][1] + ", " + normals[1][2] + "}, {" + normals[2][0] + ", " + normals[2][1] + ", " + normals[2][2] + "} }");
                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 transformedBy(Matrix3D t) {
		double[][][] transformed = new double[M][N][3];
		double[] newCenter;
		
		for (int i = 0; i < transformed.length; i++)
			for (int j = 0; j < transformed[i].length; j++) {
				transformed[i][j] = t.transform(mesh[i][j]);
			}

		newCenter = t.transform(center);
		center = newCenter;
		mesh = transformed;
	}

	private void fillMesh() {
		for (int i = 0; i < M; i++) {
			//System.out.println();
			for (int j = 0; j < N; j++) {
				double u = i / (M - 1.0);
				double v = j / (N - 1.0);

				mesh[i][j][0] = x(u, v);
				mesh[i][j][1] = y(u, v);
				mesh[i][j][2] = z(u, v);

				//System.out.print("{" + mesh[i][j][0] + ", " + mesh[i][j][1] + ", " + mesh[i][j][2] + "} ");
			}
		}
	}

	private double x(double u, double v) {
		return (
			Math.cos(2 * Math.PI * u) * Math.cos(Math.PI * v - (Math.PI / 2)));
	}

	private double y(double u, double v) {
		return (Math.sin(Math.PI * v - (Math.PI / 2)));
	}

	private double z(double u, double v) {
		return (
			-1
				* Math.sin(2 * Math.PI * u)
				* Math.cos(Math.PI * v - (Math.PI / 2)));
	}

}