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);


// /////////////////////////////////
// /////////////////////////////////
// /////////////////////////////////

void setup(){

    size(screen.width,screen.height,OPENGL);
    // size(1000,500,OPENGL);
  Anar.init(this);
  // Camera.drawAxis = true;

  simThread = new RadEngine(this,10f);
  myObject = generatorDeploy();

  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(frameCount%1000==750) angle.set(0);
  // if(frameCount%1000==999) angle.set(0.3f);
}


// /////////////////////////////////
// /////////////////////////////////
// /////////////////////////////////


Obj generatorDeploy(){

  // /////////////////////////////////
  // /////////////////////////////////
  // INIT SOME CONTAINERS
  Obj outputFmz = new Obj();


  // /////////////////////////////////
  // /////////////////////////////////
  // PREPARE TRANSFORMS

  // 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,5));


  // 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
  Transform[] sides = new Transform[3];
  sides[0] = side0;
  sides[1] = side1;
  sides[2] = side2;


  // 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);

  Transform rotation0 = new Transform();

  Transform rotation1 = new Transform();
  rotation1.add(myRotation);

  Transform rotation2 = new Transform();
  rotation2.add(myRotation);
  rotation2.add(myRotation);

  Transform[] rotations = new Transform[3];
  rotations[0] = rotation0;
  rotations[1] = rotation1;
  rotations[2] = rotation2;


  // /////////////////////////////////
  // /////////////////////////////////
  // ASSIGN TRANSFORMS

  // I<ll create to lines and combine them later
  Pts ptsA = new Pts();
  Pts ptsB = new Pts();

  // 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,15,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))
  Pt previousA = originAA;
  Pt previousB = originBB;

  Pt previousAA = originA;
  Pt previousBB = originB;


  // Ineed also to track the difference between both (number of times betweens
  // modulos)
  // At the beginning they are both alligns
  // -1 means that ptsB is from a distance 1 of modulor less than ptsA
  // 2 means that ptsB is from a distance 2 of modulor more than ptsA
  int delta = 0;

  for (int i = 0; i<1000; i++){
    // Create a points from previous (i label them - optional)
    PtDER newPtA = Anar.Pt(previousA,"A"+i);
    PtDER newPtB = Anar.Pt(previousB,"B"+i);

    // 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()*3)];

    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);

    // Alternative (if we don't want to apply the rotation
    // Use this to see only the translation effect on a plane
    // newPtA.set(sides[lengthA]);
    // newPtB.set(sides[lengthB]);


    // Put all that in that containers
    ptsA.add(newPtA);
    ptsB.add(newPtB);

    // Swap Previuos
    previousAA = previousA;
    previousBB = previousB;

    previousA = newPtA;
    previousB = newPtB;
  }


  // /////////////////////////////////
  // /////////////////////////////////
  // RETURN EVRYTHING

  // cREATE FACES FROM TWO LINES WITH SAME NUMBERS OF POINTS
  outputFmz = new SweepTwoPaths(ptsA,ptsB);

  // Cosmetik
  // print(ptsA);
  // print(ptsB);
  // print(outputFmz.primitiveToString());
  // TextIO.writeTextFile("test.lsp",outputFmz.toAutocad());

  ptsA.color(new AColor(0,0,255));
  ptsB.color(new AColor(0,150,150));

  Anar.camTarget(outputFmz);

  return outputFmz;
}


// /////////////////////////////////
// /////////////////////////////////
// /////////////////////////////////
// So Rad
boolean   isSimRunning = true;

RadEngine simThread;


@Override
void radSimDone() {
	    isSimRunning = false;
	    // SwitchRender
	
}

void keyPressed(){

  switch(key){
    case 'q':
      simThread.simulate(myObject);
      simThread.runNow();
      isSimRunning = true;
    break;
    case ' ':
      myObject = generatorDeploy();
    break;
    case 'w':
//        MetaRad.switchRender(myObject);
    break;
    case 'e':
//        MetaRad.switchToAverageRender(myObject);
    break;
    case 'p':
      Scene.autoSeek = false;
    break;
  }
}

// /////////////////////////////////
// /////////////////////////////////
// /////////////////////////////////