/*    - ArrayList 1 rayList (line(x1,y1,x2,y2))
*     - ArrayList 2 reflectedList  (line(x1,y1,x2,y2))
*     - ArrayList 3 rays & Reflected
*     - Schnittpunkte ausrechnen von ArrayList 3 mit ArrayList 2
*     - jeweils Distanz zu nächsten Punkt von allen Punkten ausrechen
*     - Fitness = delta grösste Distanz - delta kleinste Distanz; 
*       je kleiner der Wert der Fitness desto ausgeglichener ist das Strahlenbild, 
*       ...umso ausgeglichener ist die Akustik der Form
*/


class FitnessCalculator
{
  
  FitnessCalculator()
  {
  }
  
 
  
  /*
  *  Methode calculateFitness
  *  kombiniert intersect und calculateDistance und errechnet die Fitness
  */
  
  float calculateFitness()               
  {
    float  fitness, smallestElement, currElement, largestElement;                  // Variablen    
    
    ArrayList allIntersectionPts = intersectList();                                // ArrayList alle Schnittpunkte
    float[] allDistances = calculateDistance(allIntersectionPts);                  // neue ArrayListe; enthält alle Distanzen zwischen den Schnittpunkten
    fitness = allDistances[1] - allDistances[0];                                   // Fitness = Grösste Distanz zwischen 2 Punkten minus die kleinste Distanz zwischen 2 Punkten
    return fitness;
  }
  
  /*
  *   Funktion intersect
  *
  */
  
  ArrayList intersectList ()
  {
    float lx1, ly1, lx2, ly2, rx1, ry1, rx2, ry2, t1, intersectX, intersectY;       // Variablen
    ArrayList intersectionPoints = new ArrayList();                                 // ArrayList Schnittpunkte
    ArrayList raysAndReflected = new ArrayList();                                   // ArrayList die rays und reflected enthält
    
    for (int a=0; a < rayList.size() ; a++)                                         // addiere Liste rays + reflectedList....                
    {
      raysAndReflected.add(rayList.get(a));
    }
    
    for (int b=0; b < reflectedList.size(); b++)
    {
      raysAndReflected.add(reflectedList.get(b));
    }
    
    for (int j=0; j < raysAndReflected.size(); j++)
    {
      ArrayList lines = (ArrayList)raysAndReflected.get(j);
      Vec p1 = new Vec((Vec)lines.get(0));
      Vec p2 = new Vec((Vec)lines.get(1));
    
      lx1 = p1.getX();                                                     // Koordinaten Linie auf der die Schnittpunkte liegen werden abrufen           
      ly1 = p1.getY();
      lx2 = p2.getX();
      ly2 = p2.getY();

      for (int i=0; i< reflectedList.size(); i++)                          // Schleife die alle Schnittpunkte mit den Linien in der ArrayList reflectedList testet
      {
        ArrayList reflines = (ArrayList)reflectedList.get(i);
        Vec ref1 = new Vec((Vec)reflines.get(0));                          // linie reflected aus arrayliste abfragen
        Vec ref2 = new Vec((Vec)reflines.get(1));
        
        rx1 = ref1.getX();                                                 // Koordinaten reflectedList abfragen
        ry1 = ref1.getY();
        rx2 = ref2.getX();
        ry2 = ref2.getY();

        // lx1 + t1 * (lx2 - lx1) = rx1 + t2 * (rx2-rx1)                   // Gleichsetzen der Geradengleichungen für line und reflected
        // ly1 + t1 * (ly2 - ly1) = ry1 + t2 * (ry2-ry1)

        //float t2 = ( (ry1-ly1)*(lx2-lx1) - (rx1-lx1)*(ly2-ly1) ) / ( (rx2-rx1)*(ly2-ly1) - (ry2-ry1)*(lx2-lx1) );
        //intersectX = rx1 + t2 * (rx2 - rx1);
        //intersectY = ry1 + t2 * (ry2 - ry1);

        t1 = ( (lx1-rx1)*(ry2-ry1) - (rx2-rx1)*(ly1-ry1) ) / ( (ly2-ly1)*(rx2-rx1) - (lx2-lx1)*(ry2-ry1) );       // Formel für t1 aus Gleichsetzen der Geradengleichungen
        intersectX = lx1 + t1 * (lx2 - lx1);                              // Schnittpunkt auf Gerade l x-Koordinate
        intersectY = ly1 + t1 * (ly2 - ly1);                              // Schnittpunkt auf Gerade l y-Koordinate

        boolean case1 = ((lx2 <= intersectX) && (intersectX <= lx1)) && ((ly2 <= intersectY) && (intersectY <= ly1));     // Bedingungen für Schnittpunkt um auf dem Liniensegment zu sein
        boolean case2 = ((lx2 <= intersectX) && (intersectX <= lx1)) && ((ly1 <= intersectY) && (intersectY <= ly2));
        boolean case3 = ((lx1 <= intersectX) && (intersectX <= lx2)) && ((ly1 <= intersectY) && (intersectY <= ly2));
        boolean case4 = ((lx1 <= intersectX) && (intersectX <= lx2)) && ((ly2 <= intersectY) && (intersectY <= ly1));

        if  ( case1 || case2 || case3 || case4 )                          // falls eine der 4 Bedingungen erfüllt,...
        {
          Vec intersectionPt = new Vec(intersectX,intersectY);  
          intersectionPoints.add(intersectionPt);                         // Schnittpunkt in die ArrayListe "intersectionPoints" hinzufügen   
        }
      }
    }
    return intersectionPoints;                                            // ArrayListe zurückgeben
  }

  
  /*
  *  Methode calculateDistance
  *  Distanzen zwischen einer allen Punkten einer ArrayList ausrechnen
  *  und in einer ArrayList zurückgeben
  */
  float[] calculateDistance (ArrayList intersectionPoints)                    
  {
    int n = intersectionPoints.size();
    float[] distances = new float[0];                                     // neue ArrayList Distanzen
    float[] smallestLargest = new float[2];                               // Neue ArrayList für Grösste und kleinste Distanz
    float distance,p1x,p1y,p2x,p2y,v1x,v1y,v2x,v2y; 
    float smallestDistance,currDistance,largestDistance;
    float[] currDistances = new float[0]; 
    

    for (int i=0; i < n; i++)                                             // Schleife alle Punkte der Liste aufnehmen
    {
      Vec v1 = new Vec((Vec)intersectionPoints.get(i));
      v1x = v1.getX();                                                      // Koordinaten der Punkte
      v1y = v1.getY();
      Vec v2 = new Vec((Vec)intersectionPoints.get((i+n/2)%n));
      v2x = v2.getX();                                                      // Koordinaten Punkte
      v2y = v2.getY();
      smallestDistance = sqrt(sq(v2x-v1x)+sq(v2y-v1y));                     // Formel für Abstand...kleinsten Abstand setzen...
                                                       
      Vec p1 = new Vec((Vec)intersectionPoints.get(i));
      p1x = p1.getX();                                                    // Koordinaten der Punkte
      p1y = p1.getY();
      
      for (int j=0; j < n; j++)                                           // Schleife mit allen Punkten Distanz ausrechnen
      {
        Vec p2 = new Vec((Vec)intersectionPoints.get(j));
        p2x = p2.getX();                                                  // Koordinaten Punkte
        p2y = p2.getY();
        
        currDistance = sqrt(sq(p2x-p1x)+sq(p2y-p1y)); 

        if ((smallestDistance > currDistance) && (currDistance != 0) && (currDistance > 0.5))    // wenn currDistance kleiner als smallest distance ....
        {
          smallestDistance = currDistance;                                // ...dann smallest distance auf curr Distance setzen
        }
      }
      distances = splice(distances,smallestDistance,distances.length);    // dem Array distances Wert von kleinstem Wert hinzufügen
    }
    
    distances = sort(distances);                                          // Array sortieren
    smallestLargest[0] = distances[0];                                    // Aus dem sortierten Array distances erster wert = kleinster Abstand
    smallestLargest[1] = distances[distances.length-1];                   // Aus dem sortierten Array distances letzer wert = Grösster Abstand
    return smallestLargest;                                               // ArrayList "smallestLargest" zurückgeben
  }
}