import processing.opengl.*;
import processing.opengl.*;
import anar.*;
 
// import geometry.Point3D;
 
 
 
import rad.*;
 
 
 
	/*
	 * Example for Anar library by Guillaume LaBelle + Julien Nembrini
	 * http://anar.ch
	 */
 
 
 
	Obj   myObject;
 
	Param angle    = new Param(0.3f);
	Param invAngle = new Param( -angle.get());
 
 
	// /////////////////////////////////
	// /////////////////////////////////
	// /////////////////////////////////
 
	void setup(){
 
		// size(screen.width,screen.height,OPENGL);
		size(1000,500,OPENGL);
		Anar.init(this);
		Anar.drawAxis(true);
 
		simThread = new RadEngine(this,10f);
 
 
		generatorTranslationLimitedSet();
		generatorRotationLimitedSet();
		generatorInit();
 
		generatorAddOneFace();
 
		Face.globalRender = new RenderFaceDoubleSide(new AColor(255,180,180),new AColor(220));
	}
 
	// /////////////////////////////////
	// /////////////////////////////////
	// /////////////////////////////////
 
 
	void draw(){
		if(frameCount%2==0)
			background(255);
		else
			background(254);
 
		myObject.draw();
		if(isAddingFace)
			generatorAddOneFace();
 
		// angle.set(angle.get()+0.01f);
		// invAngle.set( -angle.get());
	}
 
 
	boolean isAddingFace = true;
 
 
	void keyPressed(){
 
		switch(key){
		case 'q':
			simThread.simulate(myObject);
			simThread.runNow();
			isSimRunning = true;
			if(isSimRunning)
				isSimRunning = false;
			break;
		case ' ':
			generatorAddOneFace();
			break;
		case 'w':
			//        MetaRad.switchRender(myObject);
			break;
		case 'e':
			//        MetaRad.switchToAverageRender(myObject);
			break;
		case 'p':
			Scene.autoSeek = false;
			break;
		case 'o':
			isAddingFace = (isAddingFace) ? false:true;
			break;
		case 'r':
			angle.set(0);
			invAngle.set( -angle.get());
			break;
		case 't':
			angle.set(0.3f);
			invAngle.set( -angle.get());
			break;
		case 'a':
			TextIO.write( ((Object)this).getClass().getName()+".lsp",myObject.toAutocad());
			break;
 
		}
 
	}
 
 
	// /////////////////////////////////
	// /////////////////////////////////
	// /////////////////////////////////
	Transform[] sides;
 
	void generatorTranslationLimitedSet(){
		// We limit the set of transforms to three different
		// It will produce a limited set of different patterns
 
		// The elementary operation
		Translate modulor = new Translate(Anar.PtNull(0,0,1));
 
 
		// Create 3 subsequent Transform from this one
		// I use TransformLinear to combine them as a group
		Transform side0 = new Transform();
		side0.add(modulor);
 
		Transform side1 = new Transform();
		side1.add(modulor);
		side1.add(modulor);
 
		Transform side2 = new Transform();
		side2.add(modulor);
		side2.add(modulor);
		side2.add(modulor);
 
		// Then I have three different transforms from the first one
		// They have different lengths
		// Remark, I ends up with only one parameter
 
 
		// Combine them in a table (it will be usefull when randomized)
		// Here I need to remember that 0 is short, 1 normal and 2 is long
		sides = new Transform[3];
		sides[0] = side0;
		sides[1] = side1;
		sides[2] = side2;
	}
 
 
	// /////////////////////////////////
	// /////////////////////////////////
	// /////////////////////////////////
 
	Transform[] rotations;
 
	void generatorRotationLimitedSet(){
		// It's good for sides
		// Now let's create a rotation (let's keep it simple with only one rotation)
		// On the chantier, it correspond to uniforms clips between panels
 
		// I need to create a RotateZ as it will be used inside Allingn
		// Allign will allign an axis to Z coordinate then apply a transform and
		// Come back to initial state
		RotateZ myRotation = new RotateZ(angle);
		RotateZ myInvRotation = new RotateZ(invAngle);
 
		Transform rotation_2 = new Transform();
		rotation_2.add(myInvRotation);
		rotation_2.add(myInvRotation);
 
		Transform rotation_1 = new Transform();
		rotation_1.add(myInvRotation);
 
		Transform rotation0 = new Transform();
 
		Transform rotation1 = new Transform();
		rotation1.add(myRotation);
 
		Transform rotation2 = new Transform();
		rotation2.add(myRotation);
		rotation2.add(myRotation);
 
		rotations = new Transform[5];
		rotations[0] = rotation_2;
		rotations[1] = rotation_1;
		rotations[2] = rotation0;
		rotations[3] = rotation1;
		rotations[4] = rotation2;
	}
 
 
	// /////////////////////////////////
	// /////////////////////////////////
	// /////////////////////////////////
 
 
	Pts ptsA = new Pts();
	Pts ptsB = new Pts();
 
	void generatorInit(){
		myObject = new Obj();
 
		ptsA = new Pts();
		ptsB = new Pts();
 
		ptsA.color(new AColor(0,0,255));
		ptsB.color(new AColor(255,150,150));
 
		// I need two initial points
		// This is where I set the side length of the whole thing
		Pt originA = Anar.Pt(0,0,0,"originA");
		Pt originB = Anar.Pt(0,10,0,"originB");
 
		// Add them to the list
		ptsA.add(originA);
		ptsB.add(originB);
 
		// (Update) We need those POints to orient the translation
		PtDER originAA = Anar.Pt(originA);
		PtDER originBB = Anar.Pt(originB);
 
		originAA.apply(sides[0]);
		originBB.apply(sides[0]);
 
		// Add them to the list
		ptsA.add(originAA);
		ptsB.add(originBB);
 
		// As the form is an inerplay between aNewPoint and a previousPt
		// I<ll create two fields to track them
		// Note, it's not derrived, it is the point itself (Pt previousA =
		// Anar.Pt(originA))
		previousA = originAA;
		previousB = originBB;
 
		previousAA = originA;
		previousBB = originB;
 
	}
 
 
	// /////////////////////////////////
	// /////////////////////////////////
	// /////////////////////////////////
 
	Pt  previousA;
	Pt  previousB;
	Pt  previousAA;
	Pt  previousBB;
 
	int delta     = 0;
	int faceCount = 0;
 
	void generatorAddOneFace(){
 
		PtDER newPtA = Anar.Pt(previousA,"A"+faceCount);
		PtDER newPtB = Anar.Pt(previousB,"B"+faceCount++);
 
		// Choose one translations from our set.
		// (we won't accept delta to be too long as we want to keep the set of faces
		// to a small set of cases
		int lengthA, lengthB; // Correspond to sides[0,1,2]
 
		do{
			lengthA = (int)random(sides.length);
			lengthB = (int)random(sides.length);
		} while (Math.abs(lengthA-lengthB+delta)>3); // Here I limit the maximum
		// sitance between paths (both
		// ways)
 
		// Update new delta state
		delta += lengthA-lengthB;
 
 
		// Create Rotation from an axis (eachPoint is different
		// allign need an axis of rotation (defined here by the two old resulting
		// points (previuos)
		// axis = previousA,previousB
		Transform rotmp = rotations[(int) ((float)Math.random()*rotations.length)];
 
		Transform axisRotateA = new Transform(previousA,previousB,rotmp);
		Transform axisRotateB = new Transform(previousA,previousB,rotmp);
 
 
		// Create a Translation alligned with the previous
		// Remember that we don't know how is oriented the last face
		Transform orientedTranslationA = new Transform(previousAA,previousA,sides[lengthA]);
		Transform orientedTranslationB = new Transform(previousBB,previousB,sides[lengthB]);
 
 
		// Apply to rotation to the translation
		Transform comboA = new Transform();
		comboA.add(orientedTranslationA);
		comboA.add(axisRotateA); // From the beginning
 
 
		Transform comboB = new Transform();
		comboB.add(orientedTranslationB);
		comboB.add(axisRotateB); // From the beginning
 
 
		// Here's where evrything is set together pt with transform
		newPtA.apply(comboA);
		newPtB.apply(comboB);
 
		// Put all that in that containers
		ptsA.add(newPtA);
		ptsB.add(newPtB);
 
		// Swap Previuos
		previousAA = previousA;
		previousBB = previousB;
 
		previousA = newPtA;
		previousB = newPtB;
 
		// myObject = null;
		myObject = new SweepTwoPaths(ptsA,ptsB);
 
		// http://www.javaworld.com/javaworld/javaqa/1999-08/04-qa-leaks.html
		// http://www.ibm.com/developerworks/java/library/j-leaks/
		// Java HeapSpace May Come from this...
		// Runtime r = Runtime.getRuntime();
		// long freeMem = r.freeMemory();
		// Anar.println("FreeHeapMem: " + freeMem);
		// Anar.println("-------------------");
	}
 
 
	// /////////////////////////////////
	// /////////////////////////////////
	// /////////////////////////////////
	// So Rad
	boolean   isSimRunning = true;
 
	RadEngine simThread;
 
 
	@Override
	void radSimDone() {
		isSimRunning = false;
		// SwitchRender
	}
 
	// /////////////////////////////////
	// /////////////////////////////////
	// /////////////////////////////////
 
 
	/**
	 */
 
		int   A, B;
		float energy;
 
		Element(int _A, int _B, float _e){
			A = _A;
			B = _B;
			energy = _e;
		}
	}