import graphics.*;

//handles low level rendering
class RayTracerApplet extends MISApplet
{
  protected int[][][] framebuffer, bgbuffer; //2D array of RGB values

  protected Shape[] shapes;
  protected Light[] lights;
  protected int[] ambient = {0,0,0};

  protected double F;

  protected boolean doReflections = true, doRefraction = true;

  //so we don't get stack overflow
  private int MAX_RECURSION = 5;

  public void initialize()
  {
    super.initialize();

    framebuffer = new int[H][W][3]; //rgb values
    bgbuffer = new int[H][W][3]; //rgb values
  }

  public void initFrame(long time)
  {
    for (int w=0; w<W; w++)
    for (int h=0; h<H; h++)
    {
      //copy from background buffer to framebuffer
      framebuffer[h][w][0] = bgbuffer[h][w][0]; framebuffer[h][w][1] = bgbuffer[h][w][1]; framebuffer[h][w][2] = bgbuffer[h][w][2];
    }

    animate(time);
    doRayTrace();
  }

  //just copy from framebuffer...
  public void setPixel(int x, int y, int rgb[])
  {
    rgb[0] = framebuffer[y][x][0];
    rgb[1] = framebuffer[y][x][1];
    rgb[2] = framebuffer[y][x][2];
  }

  //OVERRIDE THIS
  protected void animate(long time) {}

  //returns whether we hit anything, and sets rgb if we did
  private boolean rayTrace(Vector3 v, Vector3 w, double[] rgb, double refIndex, int ttl)
  {
    if (ttl == 0) return false;

    //"infinity"
    double t = Double.POSITIVE_INFINITY;

    //temporary vectors to hold intersection data
    Vector3 p = new Vector3();
    Vector3 n = new Vector3();
    Vector3 pos = null, normal = null;

    int shapeIndex = -1; //which shape did we hit?

    for (int i=0; i<shapes.length; i++)
    {
      double[] roots = shapes[i].testRay(v, w, p, n);

      //was there an intersection?
      if (roots == null) continue;

      //pick smaller (nearer) root
      double t1 = min(roots);

      //is this the closest shape so far?
      if (t1 < t)
      {
        t = t1;
        shapeIndex = i;
        pos = p;
        normal = n;
      }
    }

    //nothing?
    if (shapeIndex < 0) return false;

    //do phong shading at that point (color @ surface point of nearest object)
    double[] tmp = shapes[shapeIndex].shade(pos, normal, lights, shapes, ambient);
    rgb[0] = tmp[0]; rgb[1] = tmp[1]; rgb[2] = tmp[2];

    double[] rgb2 = {0,0,0};
    Vector3 v2, w2;

    //do reflections
    if (doReflections)
    {
      //w' = w - 2 (w • n) n 
      w2 = new Vector3(normal);
      w2.scale(-2 * w.dot(normal));
      w2.add(w);
      w2.normalize();

      //v' = S + ε w' (just off the surface, in the direction of w')
      v2 = new Vector3(w2);
      v2.scale(0.001);
      v2.add(pos);

      //don't mix in color if we didn't hit anything
      if (rayTrace(v2, w2, rgb2, refIndex, ttl-1))
      {
        //mix reflection color with surface color
        rgb[0] = lerp(shapes[shapeIndex].reflectiveness, rgb[0], rgb2[0]);
        rgb[1] = lerp(shapes[shapeIndex].reflectiveness, rgb[1], rgb2[1]);
        rgb[2] = lerp(shapes[shapeIndex].reflectiveness, rgb[2], rgb2[2]);
      }
    }

    if (doRefraction)
    {
      //if (shapes[shapeIndex].transparency)
      Vector3 s1 = new Vector3(normal); //s1 = (w dot n) * n
      s1.scale(w.dot(normal));
      Vector3 c1 = new Vector3(s1); //c1 = w - s1 OR n - s1
      c1.scale(-1);
      //c1.add(normal);
      c1.add(w);

      //snell's law (sin1 = |s1|)
      double sin1 = s1.magnitude();
      double sin2 = (refIndex/shapes[shapeIndex].refIndex) * sin1;
      //cos^2 + sin^2 = 1
      double cos1 = Math.sqrt(1 - sin1*sin1);
      double cos2 = Math.sqrt(1 - sin2*sin2);

      //calculate component vectors to get new w
      Vector3 s2 = new Vector3(s1);
      //s2.scale(sin2/sin1);
      s2.scale(cos2/cos1);

      Vector3 c2 = new Vector3(c1);
      //c2.scale(cos2/cos1);
      c2.scale(sin2/sin1);

      w2 = new Vector3(s2);
      w2.add(c2);

      //v' = S + ε w' (just off the surface, in the direction of w')
      v2 = new Vector3(w2);
      v2.scale(0.001);
      v2.add(pos);

      //note - new refractive index is shape's index
      if (rayTrace(v2, w2, rgb2, shapes[shapeIndex].refIndex, ttl-1))
      {
        //mix reflection color with surface color
        rgb[0] = lerp(shapes[shapeIndex].transparency, rgb[0], rgb2[0]);
        rgb[1] = lerp(shapes[shapeIndex].transparency, rgb[1], rgb2[1]);
        rgb[2] = lerp(shapes[shapeIndex].transparency, rgb[2], rgb2[2]);
      }
    }

    return true;
  }
  //default arguments
  private boolean rayTrace(Vector3 v, Vector3 w, double[] rgb) {return rayTrace(v, w, rgb, 1.0, MAX_RECURSION);}

  private void doRayTrace()
  {
    double w2 = W/2.0;
    double h2 = H/2.0;

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

    for (int i = 0 ; i < W ; i++)
    for (int j = 0 ; j < H ; j++)
    {
      Vector3 w = new Vector3(
        (i - w2) / w2, // x
        (h2 - j) / h2, // y
        -F             // z
      );
//System.err.println(w);

      w.normalize();

      double[] rgb = {0,0,0};
      rayTrace(v, w, rgb);

      framebuffer[j][i][0] = (int)rgb[0]; framebuffer[j][i][1] = (int)rgb[1]; framebuffer[j][i][2] = (int)rgb[2];
    }
  }

  //min of array of #'s
  //not sure if this exists already...
  private double min(double[] numbers)
  {
    double m = numbers[0];
    for (int i=1; i < numbers.length; i++)
      m = Math.min(m, numbers[i]);

    return m;
  }

  private double lerp(double t, double a, double b)
  {
    return a + t*(b-a);
  }
}