package org.newdawn.slick.geom;
   
   import javax.annotation.Nonnull;
   import java.util.ArrayList;
   import java.util.List;
   
   /**
    * A polygon implementation meeting the <code>Shape</code> contract. 
    * 
   * @author Mark
   */
  public class Polygon extends Shape {
      /**
       * 
       */
      private static final long serialVersionUID = 1L;
      /** Allow duplicated points */
      private boolean allowDups = false;
      /** True if the polygon is closed */
      private boolean closed = true;
  
      /**
       * Construct a new polygon with 3 or more points. 
       * This constructor will take the first set of points and copy them after
       * the last set of points to create a closed shape.
       * 
       * @param points An array of points in x, y order.
       */
      private Polygon(@Nonnull float points[]) {
          int length = points.length;
          
          this.points = new float[length];
          maxX = -Float.MIN_VALUE;
          maxY = -Float.MIN_VALUE;
          minX = Float.MAX_VALUE;
          minY = Float.MAX_VALUE;
          x = Float.MAX_VALUE;
          y = Float.MAX_VALUE;
          
          for(int i=0;i<length;i++) {
              this.points[i] = points[i];
              if(i % 2 == 0) {
                  if(points[i] > maxX) {
                      maxX = points[i];
                  }
                  if(points[i] < minX) {
                      minX = points[i];
                  }
                  if(points[i] < x) {
                      x = points[i];
                  }
              }
              else {
                  if(points[i] > maxY) {
                      maxY = points[i];
                  }
                  if(points[i] < minY) {
                      minY = points[i];
                  }
                  if(points[i] < y) {
                      y = points[i];
                  }
              }
          }
          
          findCenter();
          calculateRadius();
          pointsDirty = true;
      }
      /**
       * Create an empty polygon
       *
       */
      public Polygon(){
          points = new float[0];
          maxX = -Float.MIN_VALUE;
          maxY = -Float.MIN_VALUE;
          minX = Float.MAX_VALUE;
          minY = Float.MAX_VALUE;
      }
      
      /**
       * Indicate if duplicate points are allow
       * 
       * @param allowDups True if duplicate points are allowed
       */
      public void setAllowDuplicatePoints(boolean allowDups) {
          this.allowDups = allowDups;
      }
      
      /**
       * Add a point to the polygon
       * 
       * @param x The x coordinate of the point
       * @param y The y coordinate of the point
       */
      public void addPoint(float x, float y) {
          if (hasVertex(x,y) && (!allowDups)) {
              return;
         }
 
         final List<Float> tempPoints = new ArrayList<>();
         for (float point : points) {
             tempPoints.add(point);
         }
         tempPoints.add(x);
         tempPoints.add(y);
         int length = tempPoints.size();
         points = new float[length];
         for(int i=0;i<length;i++) {
             points[i] = tempPoints.get(i);
         }
         if(x > maxX) {
             maxX = x;
         }
         if(y > maxY) {
             maxY = y;
         }
         if(x < minX) {
             minX = x;
         }
         if(y < minY) {
             minY = y;
         }
         findCenter();
         calculateRadius();
         
         pointsDirty = true;
     }
 
 
     /**
      * Apply a transformation and return a new shape.  This will not alter the current shape but will 
      * return the transformed shape.
      * 
      * @param transform The transform to be applied
      * @return The transformed shape.
      */
     @Nonnull
     public Shape transform(@Nonnull Transform transform) {
         checkPoints();
         
         Polygon resultPolygon = new Polygon();
         
         float result[] = new float[points.length];
         transform.transform(points, 0, result, 0, points.length / 2);
         resultPolygon.points = result;
         resultPolygon.findCenter();
         resultPolygon.closed = closed;
 
         return resultPolygon;
     }
     
     /**
      * @see org.newdawn.slick.geom.Shape#setX(float)
      */
     public void setX(float x) {
         super.setX(x);
         
         pointsDirty = false;
     }
     
     /**
      * @see org.newdawn.slick.geom.Shape#setY(float)
      */
     public void setY(float y) {
         super.setY(y);
         
         pointsDirty = false;
     }
     
     /**
      * @see org.newdawn.slick.geom.Shape#createPoints()
      */
     protected void createPoints() {
 //        This is empty since a polygon must have it's points all the time.
     }
     
     /**
      * @see org.newdawn.slick.geom.Shape#closed()
      */
     public boolean closed() {
         return closed;
     }
 
     /**
      * Indicate if the polygon should be closed
      *
      * @param closed True if the polygon should be closed
      */
     public void setClosed(boolean closed) {
         this.closed = closed;
     }
 
     /**
      * Provide a copy of this polygon
      *
      * @return A copy of this polygon
      */
     @Nonnull
     public Polygon copy() {
         float[] copyPoints = new float[points.length];
         System.arraycopy(points, 0, copyPoints, 0, copyPoints.length);
 
         return new Polygon(copyPoints);
     }
 }