class Line { 
  // the Line object contains an array of Balls 
  // and methods to addBalls, to moveBalls (spring), to drawBalls and generic run method
  Target t; 
  Vector3D startLoc ;
  Vector3D target;
  int ballCount; 
  ArrayList ballArray = new ArrayList(); // resizeable array
  boolean grow; 
  Spring s = new Spring (0.1, .92, 9.9);// stiffness, damping, mass
  Spring ts = new Spring (0.1, .98, 8);
  int parentLinePos;
  int parentBallNum;
  float lineWidth ;//15;//.1;
  float maxWidth ;//= random (30) + 6;
  float lineExpandAmount;// =  maxWidth / 100;//0.08;
  Attributes lineType; // store the attributes of the line // 
  //////////////////////////////////////////////////////////////////////////
  float blurInc;// = t.plantType.blurAmount; // distance between each shape
  float blurFraction; 
  float _alpha;// = 280;//220;//180;//100;//180;//120; 
  color fillColor; 
  /// 'spin' controls the angle at which the line is drawn. 90 = flat (relative to the screen) 
  float spin;
  float spinInc;
  float spinIncTarget;// =random (20);//7;// 7;// random (-6, 2); // target for unfolding lines 
  ////////////////////////////////////////////
  float sineStart; 
  float minWidth;
  float magDistort_top, magDistort_base;  // elements to distort the top and base of the line
  float myAliveTime; // time allocated before decay starts
  /////////////////////////////////////////////////////////////////////
  Line (Attributes atts, Target t_, int currentLine, int parentLine) { 
    lineType = atts;
    t = t_;
    startLoc = new Vector3D (t.loc.x, t.loc.y);
    ballArray.add (new Ball (startLoc)); 

    target = new Vector3D (t.loc.x, t.loc.y);
    grow = true;
    findParents (parentLine);
    //////// use Attributes lineType  to define width and colour //// 
    maxWidth = lineType.maxW;/////
    lineWidth = maxWidth*.8; // start the width as a fraction of the maxWithd 
    lineExpandAmount =  maxWidth / 500;//500;// set a speed to expand leaf // \
    ////// SET COLOUR OF LINE ////////
    if (lineType.followParentColor) { 
      fillColor = lineType.fillColor; // THIS IS AN ALTERNATIVE: TO BE ABLE TO MAKE LINE FOLLOW IT'S PARENT ///
    } 
    else { 
      fillColor = lineType.colorBlend (lineType.c1, lineType.c2, random (1)); // EACH LINE HAS IT'S OWN RANDOM VALUE/// 
    }
    ////////////////////////////////////////////////////
    _alpha = t.plantType._alpha;
    blurInc = t.plantType.blurAmount; // distance between each shape
    blurFraction = t.plantType.blurAlphaFraction;
    setTargets();
    /////////////////////////
    sineStart = atts.sineStart; 
    minWidth = atts.minWidth; 
    magDistort_top =  random (atts.shapeNoise);// random (maxWidth / 5);
    magDistort_base = 0;// random (atts.mChange); // set to 0 (base distortion not needed) ///
    myAliveTime = t.plantType.aliveTime;
    //myAliveTime = atts.aliveTime;
  } 
  ////////////////////////////////////////////////
  void findParents (int parent) { 
    // store the posistion of parent line in the line array.
    parentLinePos = parent;
    // save number of ball when line has been added 
    if (parentLinePos > 0){
      parentBallNum = l[parentLinePos].ballCount;
    } 
    ///////////////////////////////////////////////////////// 
  }
  void setTargets () { 
    // set spin value  // spinInc (segments of line) and spin (whole line)
    if (lineType.type == "petal") { 
      //// SET DEVIATION TO A SET VALUE FOR ENTIRE FLOWER OR SET INDIVIDUALLTY FOR EACH PETAL
      spinIncTarget = lineType.parent.flowerDeviation;  // DEVIATE ENTIRE FLOWER 
      spinIncTarget +=  random (lineType.deviation); // DEVIATE INDIVIDUAL PETALS  
      spinInc = 50;// amount by which each part of the petal is translated
      //spin = 90;//random (40, 90);//90;//50;// 90 angle (relative to screen) at which the petal is drawn (90 == 'flat') 
    } 
    /////////////////////////////////////////////
    if (lineType.type == "leaf") { 
      spinIncTarget = random (lineType.deviation);
      spinInc = spinIncTarget;
      //spin = 90; 
    }
    ///////////////////////////
    if (lineType.type != "leaf" && lineType.type != "petal") {  
      ///  a stem or something else
      spinIncTarget = 0;//random (6); 
      spinInc = 0;
      //spin = 90;// random (40, 100); // 90
    }   
    spin =  lineType.angle; /// get the angle value from the Attributes and apply as spin (angle) 90 == 'flat' 
  }
  //////////////////////////////
  void run () { 
    updateTarget ();
    makeAllBallsSpringy();
    doIdecay();
    if (grow == true) { 
      addBalls (calcDist());
    } 
    if (parentLinePos > 0) { 
      //print root co-ordiates // to check where the movement is..
      ///CHECK IF THE BALL ARRAY OF THE PARENT IS BIGGER THAN THE PARENT BALL NUM 
      // I.E. CHECK THAT THE PARENT BALL STILL EXISTS: IT HAS NOT BEEN REMOVED // 
      if (parentBallNum < l[parentLinePos].ballArray.size()) {
        Ball pb = (Ball) l[parentLinePos].ballArray.get (parentBallNum);
        float px = pb.t.x;
        float py = pb.t.y;
      }

    }
    /////// CALL UNFURL () METHOD FOR CERTAIN 'TYPES' OF LINES 
    if (lineType.type == "petal") { 
      unfurl (); // rotate line around it's axis // does this slow the whole thing down ??
    } 
    ///////////////////////////////////
    calcBallWidth();
    calcForces();
    ////////////////////////////////////
    pushMatrix ();
    drawBalls (_alpha, 0);
    popMatrix ();
    // draw two petals (blur effect) // 
    if (lineType.blur) { 
      for (int i=1; i<=t.plantType.blurNum; i++) {
        pushMatrix (); 
        drawBalls (_alpha*blurFraction*i, blurInc*i); // alpha and blur amount
        popMatrix();
      }
    }
    /////////////////////////////////
  } 
  ///////////////////////////////////
  void updateTarget () { 
    target.setXY (t.loc.x, t.loc.y);
    if (t.isAlive != true) { 
      grow = false; 
    }
  } 
  ///////////////////////////////////
  Vector3D calcDist ( ) { 
    // returns the distance between the target and the last ball 
    Ball b = (Ball) ballArray.get (ballCount);
    Vector3D d = target.sub (target, b.loc);
    return d;
  } 
  /////////////////////////////////// 
  void addBalls (Vector3D d) { 
    float totalDist = d.magnitude ();
    //// ADD BALLS ////////
    if (totalDist > MAX_DIST) { 
      //// add a point and decrease totalDist /////
      while (totalDist > MAX_DIST) {
        /// calculate the new position for new balls to be set at - based on angle
        // new ball to be postioned MaxDist from previous ball...
        float a =  d.heading2D (); 
        Ball b = (Ball) ballArray.get (ballCount);
        float x = (cos (a) * MAX_DIST) + b.loc.x; 
        float y = (sin (a) * MAX_DIST) + b.loc.y;
        ballCount ++; 
        ballArray.add  ( new Ball (new Vector3D (x, y)));
        totalDist -= MAX_DIST;
      } 
    } 
  } 
  ///////////////////////////////////////////////////
  void removeBall (Ball b) { 
    ballArray.remove (b);
  }
  /////////////////////////////////////////////////
  void removeLine () { 
    // this does not remove the line from the array // just the balls from the line ////
    for (int i=ballCount-1; i>=0; i--) { 
      Ball b = (Ball) ballArray.get (i); 
      removeBall (b);
      ballCount--;
    }
    //if (parentLinePos == 0) {
    //addLine ();
    //}
  }
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  void calcBallWidth () { 
    // use the number of balls in the array to calculate each one's widht 
    float w = sineStart; //SINESTART // this is the starting point of the sine curve (90 = the peak, 0 = the bottom)
    float magnitude_top = lineWidth; // reset magnitude for sine curve (top of leaf shape)
    float magnitude_base = lineWidth; // magnitude for base of line 
    //////////////////////////////
    for (int i=0; i<=ballCount; i++) { 
      // when calculating widthInc CONVERT 'ballCount' into a FLOAT // so that the result is also a float // not an int //
      float widthInc =  (lineType.sineLength / float (ballCount)); 
      Ball b = (Ball) ballArray.get (i); 
      /// CREATE A WIDTH FOR THE TOP AND THE BASE OF THE LINE (NON SYMETRICAL) 
      b.w_top = (sin (radians (w))*magnitude_top)+minWidth;// this end value is important /// random (-1.5, 1.5); // add a 'pulse'//
      b.w_base = (sin (radians (w))*magnitude_base)+minWidth;// 
      w +=  widthInc;
      /////  DISTORT THE SHAPE OF THE SINE CURVE //// for top edge and for base edge ///
      magnitude_top -= magDistort_top;
      /// DON'T NEED TO DISTORT TOP AND BASE (too much) // 
      magnitude_base -= magDistort_base;
      ////////////////////////////////////////////////
    }
    //////////////////////////////////////////////////////////
    if (lineWidth <= maxWidth) { 
      grow ( );
    }
    //if (lineWidth > maxWidth) { 
    //if (t.plantType.decay)  {
    // decay ();
    //spinIncTarget += t.plantType.refurlRate; // make it re- unfurl !
    // }
    //spinIncTarget += t.plantType.refurlRate; // make it re- unfurl !
    //}
  } 
  ////////////////////////////////////////////////
  void grow () { 
    lineWidth+= lineExpandAmount; // expand line
  }
  ////////////////////////////////////////////
  void decay () { 
    spinIncTarget += t.plantType.refurlRate; // make it re- unfurl !
    blurInc += t.plantType.blurRate;
    _alpha -= t.plantType.decayRate; //.8;//1.8 ;//.4;
    /////////////////////
    if (_alpha < 0) { 
      removeLine ();
    }
  }
  //////////////////////////
  void doIdecay () { 
    //t.plantType.aliveTime --; 
    myAliveTime --;
    if (myAliveTime < 0 && t.plantType.decay) {
      decay ();
    } 

  }
  /////////////////////////////////////////////
  void calcForces () { 
    // add a force to each of the balls.. 
    // find a better way to add a force for each ball (relative to mouse position??? ) 
    //Vector3D force = new Vector3D (0.1, 0.1, 0);
    //Vector3D mouse = new Vector3D (mouseX, mouseY, 0);

    if (inputSource == "CAMERA") { 
      //////////////////////////////////////////////////////////////
      //// create an array of forces ////////////////////////////
      Vector3D forceArray [];
      float accArray [];
      forceArray = new Vector3D [b.theBlobDetection.getBlobNb()];
      accArray = new float [b.theBlobDetection.getBlobNb()];
      //println ("force array length = " + forceArray.length);
      ////// fill the force array with vectors based on the soundsquare boxArray.. 
      for (int i=0; i<forceArray.length; i++) { 
        //SoundBox sbox = (SoundBox) soundsquare.boxArray.get (i);
        Blob blob = b.theBlobDetection.getBlob(i);
        //Vector3D force = new Vector3D (sbox.x, sbox.y, 0); 
        Vector3D force = new Vector3D (blob.x*width, blob.y*height, 0); 
        forceArray[i] = force; 
        //accArray[i] = sbox.acc;
        //println ("xpos for number " + i + " = " + forceArray[i].x);
      }
      //////////////////////////////////////////////////////

      for (int i=1; i<=ballCount; i++) { 
        Ball b = (Ball) ballArray.get (i); // apply force only to end
        //Vector3D force = b.loc.sub  (b.screenLoc, mouse); // find 'force' diff between ball and mouse
        /////////////////////////////////
        ///////////create a new vector which is the sum total of forces //////
        Vector3D totalForce = new Vector3D (0.00000001, 0.00000001, 0);  // MUST give this initial values (0, 0) makes things disappear
        for (int n=0; n<forceArray.length; n++) { 
          // for each item in forcearray ... 
          // 1. create a vector from the diff between it and the ball.loc ..
          // 2. add the vector to the totalForce vector .. and use this as the force 
          Vector3D forceDiff = b.loc.sub (b.screenLoc, forceArray [n]);

          //forceDiff.mult (accArray[n]); // I HAVE REMOVED THE ACCELERATION ELEMENT ?? 
          // totalForce += force 
          totalForce.add (forceDiff);
        }
        /////////////////////////////////////////////////////////////////////////
        // find the distance and the angle 
        //float d = force.magnitude ();
        float d = totalForce.magnitude ();//
        d = 1/d * 200;// inverse distance (100 become .01 and)
        //println (d);
        //  float a = force.heading2D ();
        float a = totalForce.heading2D ();
        Vector3D newForce = new Vector3D ( cos (a) * (d *.1), sin (a) * (d *.1)); 
        ////////////////////////////////////////////////////
        newForce.limit (.15);
        b.addForce (newForce);
        b.update ();
      }
    }

    if (inputSource == "MOUSE") { 
      Vector3D mouse = new Vector3D (mouseX, mouseY, 0);
      for (int i=1; i<=ballCount; i++) { 
        Ball b = (Ball) ballArray.get (i); // apply force only to end
        Vector3D force = b.loc.sub  (b.screenLoc, mouse); // find 'force' diff between ball and mouse
        /////////////////////////////////
        // find the distance and the angle 
        float d = force.magnitude ();
        d = 1/d * 200;// inverse distance (100 become .01 and)
        //println (d);
        float a = force.heading2D ();
        Vector3D newForce = new Vector3D ( cos (a) * (d *.1), sin (a) * (d *.1)); 
        ////////////////////////////////////////////////////
        newForce.limit (.15);
        b.addForce (newForce);
        b.update ();
      }

    }
  } 
  /////////////////////////////////////////////////////////////////
  void unfurl () { 
    // alter spin so that line 'opens' or closes
    float spinIncDiff = spinIncTarget - spinInc; 
    spinInc += spinIncDiff * t.plantType.unfurlSpeed; //0.1;//0.009;//0.008; 
  }
  ///////////////////////////////////////////////////////////////
  void drawBalls (float a, float blurInc_) { 
    if (fillMode) { 
      fill (fillColor, a);
    } 
    // translate line around origin //
    if (parentLinePos == 0) {     
      Ball origin = (Ball) ballArray.get (0); 
      translate (origin.loc.x, origin.loc.y);
    } 
    else { 
      //// THIS CHECKS TO SEE IF THE PARENT EXISTS /// (IT MAY HAVE BEEN DECAYED) // 
      // WHAT HAPPENS IF THE PARENT HAS GONE ?? /////////
      if (parentBallNum < l[parentLinePos].ballArray.size()) {
        Ball parent = (Ball) l[parentLinePos].ballArray.get (parentBallNum);
        translate (parent.screenLoc.x, parent.screenLoc.y);
      } 
      else { 
        /// IF PARENT HAS GONE /// TRANSLATE AROUND START BALL (0)// 
        Ball origin = (Ball) ballArray.get (0); 
        //translate (origin.loc.x, origin.loc.y);
        translate (-2000, -2000); /// THIS IS NOT IDEAL /// 
      }
    }
    ////// THIS HAS TO BE MODIFIED TO INCLUDE THE NEW ROTATION / TRANSLATION /////////////////////
    for (int i=1; i<=ballCount-0; i++) {
      Ball b = (Ball) ballArray.get (i);
      Ball prevb = (Ball) ballArray.get (i-1);
      /// MODIFICATIONS ////////////////
      float xDist = b.loc.x - prevb.loc.x; 
      float yDist = b.loc.y - prevb.loc.y; 
      //////////////////////////////////////////////////////////
      float r = sqrt (( xDist*xDist) + (yDist*yDist ));
      float direction = atan2 (yDist, xDist); 
      ////////////////////////////////////////////////////////
      // spin controls the rotational movement.......
      float x_angle = sin (radians (spin-i*spinInc)) *r; // xpos 
      float z_angle = cos (radians (spin-i*spinInc)) *r; // zpos
      //////////////////////////////////////////////////////////////
      float xpos = cos (direction) * x_angle;  
      float ypos = sin (direction) * x_angle; 
      ///////////////////////////////////////////////////////////
      translate (xpos, ypos, z_angle);
      b.screenLoc.x = screenX (0, 0, 0);//save 0, 0, 0 as an x location on the screen
      b.screenLoc.y = screenY (0, 0, 0);//sace 0, 0, 0 as a y location on the screen 
      b.screenLoc.z = screenZ (0, 0, 0);
      /////////////////////////////////////////
      // use direction to set the points of the shape.. 
      // find points on the circle at right angles (+- 90)  to the direction of the line... 
      ////////////////////////////////////////////////////////////
      // give each ball it's own edge co-ordinate //  DO THIS FOR TOP AND BOTTOM EDGES
      b.edge_top.x = cos (direction - radians (90)) * ((b.w_top/2)+blurInc_);// + blurInc_/2;  // ball, point 1 x
      b.edge_top.y = sin (direction - radians (90)) * ((b.w_top/2)+blurInc_);//  + blurInc_/2;  // ball, point 1 y; 
      b.edge_base.x = cos (direction - radians (90)) * ((b.w_base/2)+blurInc_);// + blurInc_/2;  // ball, point 1 x
      b.edge_base.y = sin (direction - radians (90)) * ((b.w_base/2)+blurInc_);//  + blurInc_/2;  // ball, point 1 y; 


      /////////////////////////////////////////
      // join the 'edge' locations INCLUDE TOP EDGE AND BOTTOM EDGE ////
      beginShape (QUADS); 
      vertex (b.edge_top.x, b.edge_top.y, 0); // top edge
      vertex (-xpos+prevb.edge_top.x, -ypos+prevb.edge_top.y, -z_angle); // top edge
      vertex (-xpos-prevb.edge_base.x, -ypos-prevb.edge_base.y, -z_angle);  // bottom edge
      vertex (-b.edge_base.x, -b.edge_base.y, 0); // bottom edge
      endShape();
      //////////////////////////////////////////////////
      //// DRAW LINES ////
      if (t.plantType.drawLines) { 
        strokeWeight (lineWidth/10);
        stroke (fillColor, a);
        line (b.edge_top.x, b.edge_top.y, 0, -xpos+prevb.edge_top.x, -ypos+prevb.edge_top.y, -z_angle); // top edge
        line (-b.edge_base.x, -b.edge_base.y, 0, -xpos-prevb.edge_base.x, -ypos-prevb.edge_base.y, -z_angle); // bottom edge 
        noStroke();
      }
      ///////////////////////////////////////////////////////////////////////////////////////
      if (t.plantType.drawCentre) {
        strokeWeight (2); 
        stroke (0,0,0); 
        line (b.screenLoc.x, b.screenLoc.y, 0,  prevb.screenLoc.x, prevb.screenLoc.y, -z_angle); 
      }
      ///////////////////
      if (sketchMode) { 
        /// DRAWS JUST THE LINES....(NO FILL)
        noFill ();
        strokeWeight (0.2);
        stroke (fillColor);
        line (b.edge_top.x, b.edge_top.y, 0, -xpos+prevb.edge_top.x, -ypos+prevb.edge_top.y, -z_angle); // top edge
        line (-b.edge_base.x, -b.edge_base.y, 0, -xpos-prevb.edge_base.x, -ypos-prevb.edge_base.y, -z_angle);// bottom edge
        noStroke();
      }

    }    
    // draw a circle at the end of the line (shape ending)
    if (ballCount > 2) {
      //Ball firstball = (Ball) ballArray.get (0); 
      //firstball.drawBall();
      Ball lastball = (Ball) ballArray.get (ballCount); 
      lastball.drawBall ();
    }
    /////////////
  } 
  ////////////////////////////////////////////

  void makeAllBallsSpringy() { 
    // cycle through of all of the balls (ballCount)  in the arrayList (ballArray);
    // appy a tension between themm
    // create a one 'off' to make the apply a spring between the first ball and it's 'parent' 
    if (parentLinePos > 0){
      ///CHECK IF THE BALL ARRAY OF THE PARENT IS BIGGER THAN THE PARENT BALL NUM 
      // I.E. CHECK THAT THE PARENT BALL STILL EXISTS: IT HAS NOT BEEN REMOVED // 
      if (parentBallNum < l[parentLinePos].ballArray.size()) {
        Ball parent = (Ball) l[parentLinePos].ballArray.get (parentBallNum);
        Ball root = (Ball) ballArray.get (0);
        s.applySpring (root, parent, true);
      }
    }
    //////////////////////
    for (int i=1 ; i<=ballCount; i++) { 
      Ball b = (Ball) ballArray.get (i);
      Ball prevB = (Ball) ballArray.get (i-1);
      s.applySpring (b, prevB, true);
      // s.applySpring  (prevB, b, true);
      Ball targetBall = new Ball (new Vector3D (b.t.x, b.t.y));
      ts.applySpring  (b, targetBall, false);
    }

  }
}