package graphics;

import java.util.ArrayList;

public class Shape implements Cloneable
{
  //num of latitudes/longitudes
  //(should be overridden)
  protected int M = 1;
  protected int N = 1;

  protected double[][] vertices; //nv * 6
  protected boolean[] vFlags; //was vertex calculated?
  protected int[][] faces; //nf * 4

  protected ArrayList[] vertex2faces; //lists of faces including each vertex

  //whether to wrap around M
  protected boolean wrap = true;

  //the shape's transformation matrix
  public Matrix3D matrix;

  //center of the object - not used here 
  public double[] center;

  //shape's colors
  private double shininess;
  private int[] diffuseColor = {0,0,0};
  private int[] specularColor = {0,0,0};

  //how much of the shape to draw
  public double uStart = 0.0, uEnd = 1.0, vStart = 0.0, vEnd = 1.0;

  Shape()
  {
    init();
  }

  Shape(int newM, int newN)
  {
    M = newM;  N = newN;

    init();
  }

  protected void init()
  {
    matrix = new Matrix3D();

    center = new double[3];

    vertices = new double[M * N][6];
    faces = new int[M * (N-1)][4];

    //System.err.println("nv = " + numVertices());
    //System.err.println("nf = " + numFaces());
  }

  //deep copy vertices and faces
  public Object clone()
  {
    Shape newShape = new Shape(M, N);

    for (int i=0; i<vertices.length; i++)
      newShape.setVertex(i, vertices[i]);

    for (int i=0; i<faces.length; i++)
      newShape.setFace(i, faces[i]);

    return newShape;
  }

  public int numVertices() { return vertices.length; }
  public int numFaces() { return faces.length; }
  public double[] getVertex(int idx) { return vertices[idx]; }
  public int[] getFace(int idx) { return faces[idx]; }
  public void setVertex(int idx,  double[] vertex)
  {
    vertices[idx] = (double [])vertex.clone();
  }
  public void setFace(int idx,  int[] face)
  {
    faces[idx] = (int [])face.clone();
  }

  //transform by matrix
  //Warning: this function PERMANENTLY transforms all points in shape
  //Clone the shape if you want to maintain the original points...
  public void transform()
  {
    Matrix3D normalMatrix = new Matrix3D();
    normalMatrix.copy(matrix);
    normalMatrix.inverse();
    normalMatrix.transpose();

    //System.err.println("In Shape.transform: matrix = ");
    //System.err.println(matrix);

    for (int i=0; i<vertices.length; i++)
    {
      double[] newVertex = new double[3];

      matrix.transform(vertices[i], newVertex);

      //copy back to vertices
      for (int j=0; j<3; j++) vertices[i][j] = newVertex[j];

      //now do the normal
      double[] oldNormal = new double[3];
      for (int j=0; j<3; j++) oldNormal[j] = vertices[i][j+3];
      double[] newNormal = new double[3];

      normalMatrix.transform(oldNormal, newNormal);

      Vector3 n = new Vector3(newNormal);
      n.normalize();

      //copy back to normal
      for (int j=0; j<3; j++) vertices[i][j+3] = n.get(j);
    }
  }

  protected int vertexIndex(int m, int n)
  {
    return m*N + n;
  }

  protected int faceIndex(int m, int n)
  {
    return m*(N-1) + n;
  }

  //convert u/v pair to xyz point
  //OVERRIDE THIS FUNCTION
  protected double[] calculatePoint(double u, double v)
  {
    double[] point = {0, 0, 0, 0, 0, 0};
    return point;
  }

  //calculate all vertices/faces for the shape
  public void calculate()
  {
    //keeps track of what vertices were set
    vFlags = new boolean[vertices.length];
    for (int i = 0; i < vFlags.length; i++)
      vFlags[i] = false;

    int mStart = (int)(uStart * M), mEnd = (int)(uEnd * M);
    int nStart = (int)(vStart * N), nEnd = (int)(vEnd * N) - 1;

    double du = 1.0/M, dv = 1.0/N;

    int skippedFaces = 0;

    //for (double u = uStart; u < uEnd; u += du)
    //for (double v = vStart; v < vEnd; v += dv)
    for (int m = mStart; m < mEnd; m++)
    for (int n = nStart; n < nEnd; n++)
    {
      //int m = (int)(u * M); int n = (int)(v * N);
//System.err.println("m = "+m+", n = "+n);

      //vertices are counter-clockwise
      int[] face = new int[4];
      face[0] = vertexIndex(m  , n  );
      face[1] = vertexIndex(m+1, n  );
      face[2] = vertexIndex(m+1, n+1);
      face[3] = vertexIndex(m  , n+1);

      //points will wrap around M so use modulus
      if (wrap)
      {
        for (int i=0; i<face.length; i++)
          face[i] %= vertices.length;
      }
      else
      {
        boolean skipFace = false;
        for (int i=0; i<face.length; i++)
          if (face[i] != face[i] % vertices.length) skipFace = true;

        if (skipFace)
        {
          skippedFaces++;
          continue;
        }
      }

      //calculate the vertices
      double u  = m/(double)M;
      double u1 = (m+1)/(double)M;
      double v  = n/((double)N-1);
      double v1 = (n+1)/((double)N-1);
      //double u1 = u + du;
      //double v1 = v + dv;

      //add vertices to the vertex array
      //if vertex was already calculated, don't recalculate it
      if (!vFlags[ face[0] ])
        vertices[ face[0] ] = calculatePoint(u , v );
      if (!vFlags[ face[1] ])
        vertices[ face[1] ] = calculatePoint(u1, v );
      if (!vFlags[ face[2] ])
        vertices[ face[2] ] = calculatePoint(u1, v1);
      if (!vFlags[ face[3] ])
        vertices[ face[3] ] = calculatePoint(u , v1);

      vFlags[ face[0] ] = vFlags[ face[1] ] =
      vFlags[ face[2] ] = vFlags[ face[3] ] = true;

      //add face to the face array
      //face index is the same as first vertex index
      int fi = faceIndex(m,n);
      faces[fi] = face;
    }

    //discard any skipped faces
    int[][] faces2 = new int[faces.length - skippedFaces][4];
    for (int fi=0; fi<faces2.length; fi++) faces2[fi] = faces[fi];
    faces = faces2;

    calculateNormals();

    //dumpFaces();
    //dumpVertices();
  }

  //generates list of faces by vertex
  protected void verts2faces()
  {
    vertex2faces = new ArrayList[vertices.length];

    for (int vi = 0; vi < vertices.length; vi++)
    {
      vertex2faces[vi] = new ArrayList();

      for (int fi = 0; fi < faces.length; fi++)
      {
        for (int i = 0; i < faces[fi].length; i++) //go thru each face
        {
          //is the current vertex in the face?
          if (faces[fi][i] == vi)
          {
            vertex2faces[vi].add( new Integer(fi) );
            break; //next face
          }
        }
      }
    }
  }

  //returns normal for a specific face
  //specified by face index
  protected Vector3 faceNormal(int fi)
  {
    int[] face = faces[fi];

    Vector3 n = new Vector3(0, 0, 0);

    //vertices in groups of 3
    //upper limit is (length-1)-2
    for (int i=0; i < face.length-3; i++)
    {
      double[] v0 = vertices[ face[i] ];
      double[] v1 = vertices[ face[i+1] ]; 
      double[] v2 = vertices[ face[i+2] ];

      Vector3 vec1 = new Vector3(v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]);
      Vector3 vec2 = new Vector3(v2[0] - v1[0], v2[1] - v1[1], v2[2] - v1[2]);

      n.add( vec1.crossProduct(vec2) );
    }
    n.normalize();
//System.err.println(n);
    return n;
  }

  public void calculateNormals()
  {
    verts2faces(); //this will speed things up

    for (int vi=0; vi < vertices.length; vi++)
    {
      Vector3 vertexNormal = new Vector3(0,0,0);

      for (int i=0; i<vertex2faces[vi].size(); i++)
      {
        int fi = ((Integer)vertex2faces[vi].get(i)).intValue(); //get index of face to compute
        vertexNormal.add( faceNormal(fi) );
      }

      vertexNormal.normalize();

      //copy normal info into vertex
      vertices[vi][3] = vertexNormal.get(0);
      vertices[vi][4] = vertexNormal.get(1);
      vertices[vi][5] = vertexNormal.get(2);
    }
  }

  public void setDiffuse(int r, int g, int b)
  {
    diffuseColor[0] = r; diffuseColor[1] = g; diffuseColor[2] = b;
  }

  public void setSpecular(double s, int r, int g, int b)
  {
    shininess = s;
    specularColor[0] = r; specularColor[1] = g; specularColor[2] = b;
  }

  //vertex shader
  public void shade(Light[] lights, int[] ambient)
  {
    for (int vi = 0; vi < vertices.length; vi++)
     {
       double x = vertices[vi][0], y = vertices[vi][1],  z = vertices[vi][2];
       double nx = vertices[vi][3], ny = vertices[vi][4],  nz = vertices[vi][5];

       Vector3 eye = new Vector3(x, y, z); //eye/camera is at the origin
       eye.normalize();
       Vector3 normal = new Vector3(nx, ny, nz);
       //normal.normalize();

//System.err.println("in shade()");
//System.err.println(nx+","+ny+","+nz);

       double r = 0, g = 0, b = 0;

       for (int li = 0; li < lights.length; li++)
       {
         //colors for this light
         double lr = 0, lg = 0, lb = 0;

         //diffuse shading
         // f is L dot N
         double fDiff = normal.dotProduct( lights[li].getDirectionVector() );
         if (fDiff < 0) fDiff = 0;

         lr += fDiff * diffuseColor[0];
         lg += fDiff * diffuseColor[1];
         lb += fDiff * diffuseColor[2];

         //specular shading
         //R = 2*f*N - L
         //Ls = [rs,gs,bs]max(0, E ∙ R)^p
         Vector3 R = new Vector3(nx, ny, nz); //copy normal vector
         R.scale(-2 * fDiff); // r is now -2fN
         R.add( lights[li].getDirectionVector() ); //r is now L - 2fN
         R.scale(-1);
         //R.normalize();

         double fSpec = Math.pow(eye.dotProduct(R), shininess); //E ∙ R
         if (fSpec < 0) fSpec = 0;
//System.err.println("fSpec = " + fSpec);

         lr += fSpec * specularColor[0];
         lg += fSpec * specularColor[1];
         lb += fSpec * specularColor[2];

         //factor in light source, but
         //scale back down (compare 0.5 * 0.5 with (128 * 128)/256)
         lr *= lights[li].color[0] / 256.0;
         lg *= lights[li].color[1] / 256.0;
         lb *= lights[li].color[2] / 256.0;

         //add the light to object's light
         r += lr; g += lg; b += lb;
       }

       //add ambient component
       r += ambient[0]; g += ambient[1]; b += ambient[2];

       if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;

//System.err.println(r+","+g+","+b);

       //copy color info back into shape
       vertices[vi][3] = r; vertices[vi][4] = g; vertices[vi][5] = b;
     }
  }

  //this is a bit of a hack for weirdly shaped surfaces
  //where normals are harder to get right
  public void flipNormals()
  {
    for (int i = 0; i < vertices.length; i++)
    {
      vertices[i][3] = -vertices[i][3];
      vertices[i][4] = -vertices[i][4];
      vertices[i][5] = -vertices[i][5];
    }
  }

  public void dumpFaces()
  {
    System.err.println("faces:");
    for (int i = 0; i < faces.length; i++)
      System.err.println("("+faces[i][0]+", "+faces[i][1]+", "+faces[i][2]+", "+faces[i][3]+")");
  }

  public void dumpVertices()
  {
    System.err.println("vertices:");
    for (int i = 0; i < vertices.length; i++)
      System.err.println("("+vertices[i][0]+", "+vertices[i][1]+", "+vertices[i][2]+", "+vertices[i][3]+", "+vertices[i][4]+", "+vertices[i][5]+")");
  }
}