/**
  * MyPolygon.java
  *
  * rappresenta un poligono convesso. Realizza l'interfaccia Polygon.java.
  * @author A. Luchetta
  * @version 18-Nov-2006
  */

public abstract class MyPolygon implements Polygon
{
   private final int MIN_NUMBER_OF_LINES = 3; 

   private static String[] NOME_POLIGONO = { "non un poligono",   // 0 lati
                                             "non un poligono",   // 1 lato
                                             "non un poligono",   // 2 lati
                                             "triangolo",         // 3 lati
                                             "quadrilatero",      // 4 lati
                                             "pentagono",         // 5 lati
                                             "esagono",           // 6 lati
                                             "eptagono",          // 7 lati
                                             "ottagono",          // 8 lati
                                             "ennagono",          // 9 lati
                                             "decagono",          // 10 lati
                                             "endecagono",        // 11 lati
                                             "dodecagono"};       // 12 lati

   private MyPoint2D[] points;

   /**
      Costruttore. Definisce un poligono mediante i suoi vertici.
      @param p array di vertici del poligono
   */
   public MyPolygon(MyPoint2D[] p)
   {
      if (p == null || p.length < MIN_NUMBER_OF_LINES)
         throw new IllegalArgumentException("Non e' un poligono: n. lati < " + MIN_NUMBER_OF_LINES);
         
      points = p;
   }
   
   /**
      restituisce un array contenente i lati del poligono
      @return un array contenente i lati del poligono
   */
   public double[] getLines()
   {
      double[] lines = new double[points.length];
      
      for (int i = 0; i < points.length - 1; i++)
         lines[i] = points[i].distance(points[1 + 1]);

      lines[lines.length - 1] = points[points.length - 1].distance(points[0]);

      return lines;
   }

   /**
      restituisce un array contenente i vertici del poligono
      @return array contenente i vertici del poligono
   */
   public MyPoint2D[] getPoints()
   {
      MyPoint2D[] p = new MyPoint2D[points.length];
      
      System.arraycopy(points, 0, p, 0, points.length);

      return p;
   }

   /**
      restituisce un vertice del poligono
      @param index indice del punto nel poligono
      @return il punto di indice index
   */
   public MyPoint2D getPoint(int index)
   {
      if (index >= points.length)
         throw new IllegalArgumentException();
         
      return points[index];
   }

   /**
      calcola il perimetro del poligono.
      @return il perimetro del poligono
   */
   public double perimeter()
   {
      double perimetro = points[points.length - 1].distance(points[0]);
      for (int i = 0; i < points.length - 1; i++)
         perimetro += points[i].distance(points[i + 1]);
         
      return perimetro;
   }
   
   /**
      calcola l'area del poligono. Il metodo e' astratto. Dal punto di vista
      matematico la conoscenza dei vertici e' sufficiente per determinare
      l'area del triangolo. Nell'esercizio si preferisce lasciare il calcolo
      dell'area alle sottoclassi.
      @return l'area del poligono
   */
   public abstract double area();
   
   /**
      compara due poligoni. Il criterio di confronto e' l'area.
      @return l'area del poligono
   */
   public int compareTo(Polygon p)
   {
      if (area() == p.area())
         return 0;
      if (area() < p.area())
         return -1;
      return 1;
   }
   
   /**
      descrizione testuale nel formato NOME_ POLIGONO p1 p2 ... pn, dove
      p1 ..., pn sono i vertici del poligono
      @return l'area del poligono
   */
   public String toString()
   {
      String polygonName = "";
      if (points.length < NOME_POLIGONO.length)
         polygonName = NOME_POLIGONO[points.length];
      else
         polygonName =  points.length + "-gono";

      String pointsStr = "";
      for (int i = 0; i < points.length; i++)
         pointsStr += points[i] + " ";
         
      return polygonName + " " + pointsStr + " area " + area();
   }
}