package edu.jsu.leathrum.mathlets.shared;
import java.awt.Graphics2D;
import java.awt.geom.*;
import java.awt.Color;
import java.awt.Shape;
import java.awt.event.*;

public abstract class AGraphPanel3dFacets extends AGraphPanel3d {

  public AGraphPanel3dFacets () {
    super();
  }

public abstract class AGraphCanvas3dFacets extends AGraphCanvas3d {
  
  public AGraphCanvas3dFacets(int initialWidth, int initialHeight) {
    super(initialWidth,initialHeight);
  }

  public GraphModelFacets model = new GraphModelFacets();

public class GraphModelFacets {

private class Facet {
  DoubleTriad facet[];
  int numpoints=0;
  Color baseColor = Color.blue;

  public Facet() {
    facet = new DoubleTriad[10];
  }

  public Facet(Color q) {
    facet = new DoubleTriad[10];
    baseColor = q;
  }

  public void setBaseColor(Color q) {
    baseColor = q;
  }

  DoubleTriad midpoint = new DoubleTriad(0,0,0);

  public void add(DoubleTriad t) {
    facet[numpoints]=t;
    numpoints++;
    midpoint = new DoubleTriad(0,0,0);
    for (int i=0; i<numpoints; i++) {
      midpoint.x += facet[i].x;
      midpoint.y += facet[i].y;
      midpoint.z += facet[i].z;
    }
    midpoint.x = midpoint.x/numpoints;
    midpoint.y = midpoint.y/numpoints;
    midpoint.z = midpoint.z/numpoints;
    if (!(numpoints<facet.length)) {
      DoubleTriad newfacet[] = new DoubleTriad[facet.length+10];
      for (int i=0; i<facet.length; i++) newfacet[i]=facet[i];
      facet = newfacet;
    }
  }

  public void add(double x, double y, double z) {
    add(new DoubleTriad(x,y,z));
  }

  public void paintFacet(Graphics2D g) {
    int frontRed = baseColor.getRed(), 
        frontGreen = baseColor.getGreen(), 
        frontBlue = baseColor.getBlue(); 
    int backRed = (int) (0xDF+0.125*frontRed),
        backGreen = (int) (0xDF+0.125*frontGreen),
        backBlue = (int) (0xDF+0.125*frontBlue);
    
    GeneralPath edge = new GeneralPath();
    if (numpoints > 0) {
      Point2D.Double p = c.project(facet[0]);
      edge.moveTo((float) p.x, (float) p.y);
      for (int i=1; i<numpoints; i++) {
        p = c.project(facet[i]);
        edge.lineTo((float) p.x, (float) p.y);
      }
      edge.closePath();
    }
    
    double grey =  0.5-(getOffset())/(1.8*maxxyz);
    int newred = (int) ((1-grey)*frontRed+grey*backRed);
    int newgreen = (int) ((1-grey)*frontGreen+grey*backGreen);
    int newblue = (int) ((1-grey)*frontBlue+grey*backBlue);

    g.setPaint(new Color((int) (0xBF+0.25*newred), (int) (0xBF+0.25*newgreen),
                         (int) (0xBF+0.25*newblue)));
    Shape s = c.tr.createTransformedShape(edge);
    g.fill(s);
    g.setPaint(new Color(newred, newgreen, newblue));
    g.setPaint(baseColor);
    g.draw(s);
  }

  private double offset = 0.0;

  public void recalcOffset() {
    //double a, b, cc;
    //a = b = cc = facet[0].x*c.ca*c.sb+facet[0].y*c.sa*c.sb+facet[0].z*c.cb;
    //for (int i=1; i<numpoints; i++) {
    //  b = facet[i].x*c.ca*c.sb+facet[i].y*c.sa*c.sb+facet[i].z*c.cb;
    //  cc += b;
    //  if (b>a) a=b;
   // }
    //offset = ((cc/numpoints)+a)/2;
    offset = c.dotview(midpoint);
  }

  public double getOffset() {
    return offset;
  }
} // end Facet, inner class of GraphModel

  Facet model[];
  int numfacets = 0;
  double maxxyz;
  Color baseColor;

  public GraphModelFacets() {
    model = new Facet[50];
    maxxyz=Math.max(c.xmax-c.xmin,Math.max(c.ymax-c.ymin,c.zmax-c.zmin));
  }

  public void add(double x, double y, double z) {
    model[numfacets-1].add(x,y,z);
  }

  public void add(DoubleTriad p) {
    add(p.x,p.y,p.z);
  }

  public void newfacet() {
    model[numfacets] = new Facet(baseColor);
    numfacets++;
    if (!(numfacets<model.length)) {
      Facet newmodel[] = new Facet[model.length+50];
      for (int i=0; i<model.length; i++) newmodel[i] = model[i];
      model = newmodel;
    }
  }

  public void setBaseColor(Color q) {
    baseColor = q;
  }


  public void paintModel(Graphics2D g) {
    for (int i=0; i<numfacets; i++) model[i].recalcOffset();
    QuickSortFacets(0,numfacets-1);
    for (int i=0; i<numfacets; i++) model[i].paintFacet(g);
  }

  private void QuickSortFacets(int lo0, int hi0) {
      int lo = lo0;
      int hi = hi0;
      double mid;

      if ( hi0 > lo0)
      {
         mid = model[(lo0 + hi0)/2].getOffset();
         while( lo <= hi )
         {
	     while((lo < hi0) && (model[lo].getOffset() < mid))
		 ++lo;
	     while((hi > lo0) && (model[hi].getOffset() > mid))
		 --hi;
            if(lo <= hi)
            {
               swap(lo, hi);
               ++lo;
               --hi;
            }
         }
         if(lo0 < hi)
            QuickSortFacets(lo0, hi);
         if(lo < hi0)
            QuickSortFacets(lo, hi0);
      }
  }
  
  private void swap(int i, int j) {
      Facet T;
      T = model[i];
      model[i] = model[j];
      model[j] = T;
  }

} // end GraphModel, inner class of AGraphCanvas3d

  // utility method in AGraphCanvas3d to add triangular facet
  public void dofacet(DoubleTriad a, DoubleTriad b, DoubleTriad cc) {
    if ((a.x>=c.xmin) && (a.x<=c.xmax) &&
        (!Double.isInfinite(a.x)) && (!Double.isNaN(a.x)) &&
	(b.x>=c.xmin) && (b.x<=c.xmax) &&
        (!Double.isInfinite(b.x)) && (!Double.isNaN(b.x)) &&
	(cc.x>=c.xmin) && (cc.x<=c.xmax) &&
        (!Double.isInfinite(cc.x)) && (!Double.isNaN(cc.x)) &&
        (a.y>=c.ymin) && (a.y<=c.ymax) &&
        (!Double.isInfinite(a.y)) && (!Double.isNaN(a.y)) &&
	(b.y>=c.ymin) && (b.y<=c.ymax) &&
        (!Double.isInfinite(b.y)) && (!Double.isNaN(b.y)) &&
	(cc.y>=c.ymin) && (cc.y<=c.ymax) &&
        (!Double.isInfinite(cc.y)) && (!Double.isNaN(cc.y)) &&
        (a.z>=c.zmin) && (a.z<=c.zmax) &&
        (!Double.isInfinite(a.z)) && (!Double.isNaN(a.z)) &&
	(b.z>=c.zmin) && (b.z<=c.zmax) &&
        (!Double.isInfinite(b.z)) && (!Double.isNaN(b.z)) &&
	(cc.z>=c.zmin) && (cc.z<=c.zmax) &&
        (!Double.isInfinite(cc.z)) && (!Double.isNaN(cc.z))) {
      model.newfacet();
      model.add(a);
      model.add(b);
      model.add(cc);
    }
  }

} // end AGraphCanvas3dFacets, inner class of AGraphPanel3dFacets

}