/*
 * Copyright (c) 2012 matheusdev
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package org.matheusdev.test;

import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_LINE_LOOP;
import static org.lwjgl.opengl.GL11.GL_MODELVIEW;
import static org.lwjgl.opengl.GL11.GL_PROJECTION;
import static org.lwjgl.opengl.GL11.glBegin;
import static org.lwjgl.opengl.GL11.glClear;
import static org.lwjgl.opengl.GL11.glColor3f;
import static org.lwjgl.opengl.GL11.glEnd;
import static org.lwjgl.opengl.GL11.glLoadIdentity;
import static org.lwjgl.opengl.GL11.glMatrixMode;
import static org.lwjgl.opengl.GL11.glOrtho;
import static org.lwjgl.opengl.GL11.glVertex2f;
import static org.lwjgl.opengl.GL11.glViewport;

import javax.swing.JOptionPane;

import mdesl.graphics.SpriteBatch;

import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.matheusdev.util.FastRand;
import org.matheusdev.util.collision.Circle;
import org.matheusdev.util.collision.Collision;
import org.matheusdev.util.collision.Poly;
import org.matheusdev.util.collision.Quad;
import org.matheusdev.util.gameloop.GameLoop;
import org.matheusdev.util.gameloop.GameLooper;
import org.matheusdev.util.vecmath.Vec2;
import org.matheusdev.util.vecmath.Vec3;

/**
 * @author matheusdev
 *
 */
public class SATTest implements GameLooper {

   public static int objects;

   public static void main(String[] args) {
      do {
         try {
            objects = Integer.parseInt(JOptionPane.showInputDialog(
                  "How much Polygons? (each one will have 8 vertices)\n" +
                  "This window will return, if you enter invalid values."));
         } catch (Exception e) {}
      } while (objects <= 0);
      new GameLoop(new SATTest(), GameLoop.Type.LIMITED_DELTA, 60).start();
   }

   protected Poly[] polys;
   protected boolean[] collisions;
   protected Quad quad = new Quad(
         new Vec2(), 160, 160);

   protected SpriteBatch batch;
   protected boolean colliding;

   public SATTest() {
   }

   /* (non-Javadoc)
    * @see org.matheusdev.util.gameloop.NanoTime#getNanoTime()
    */
   @Override
   public long getNanoTime() {
      return (Sys.getTime() * 1_000_000_000) / Sys.getTimerResolution();
   }

   /* (non-Javadoc)
    * @see org.matheusdev.util.gameloop.GameLooper#init()
    */
   @Override
   public void init() {
      try {
         Display.setDisplayMode(new DisplayMode(800, 600));
         Display.create();
      } catch (LWJGLException e) {
         e.printStackTrace();
      }
      try {
         batch = new SpriteBatch();
      } catch (LWJGLException e) {
         e.printStackTrace();
      }
      resize(Display.getWidth(), Display.getHeight());

      polys = new Poly[objects];
      collisions = new boolean[objects];

      FastRand rand = new FastRand();

      for (int i = 0; i < polys.length; i++) {
         polys[i] = new Poly(
               new Vec2(-30 + rand.randFloat(-5, 5),  10 + rand.randFloat(-5, 5)),
               new Vec2(-10 + rand.randFloat(-5, 5),  30 + rand.randFloat(-5, 5)),
               new Vec2( 10 + rand.randFloat(-5, 5),  30 + rand.randFloat(-5, 5)),
               new Vec2( 30 + rand.randFloat(-5, 5),  10 + rand.randFloat(-5, 5)),
               new Vec2( 30 + rand.randFloat(-5, 5), -10 + rand.randFloat(-5, 5)),
               new Vec2( 10 + rand.randFloat(-5, 5), -30 + rand.randFloat(-5, 5)),
               new Vec2(-10 + rand.randFloat(-5, 5), -30 + rand.randFloat(-5, 5)),
               new Vec2(-30 + rand.randFloat(-5, 5), -10 + rand.randFloat(-5, 5)));
         polys[i].getMatrix().translate(new Vec2(rand.randFloat(0, 800), rand.randFloat(0, 600)))
                        .rotate(rand.randFloat(), Vec3.UP);
         polys[i].updateFromMatrix();
      }
   }

   public void resize(int w, int h) {
      glViewport(0, 0, w, h);
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      glOrtho(0, w, h, 0, -1, 1);
      glMatrixMode(GL_MODELVIEW);
      batch.resize(w, h);
   }

   /* (non-Javadoc)
    * @see org.matheusdev.util.gameloop.GameLooper#isCloseRequested()
    */
   @Override
   public boolean isCloseRequested() {
      return Display.isCloseRequested();
   }

   protected float rotation = 0;
   protected float time = 0;

   /* (non-Javadoc)
    * @see org.matheusdev.util.gameloop.GameLooper#tick(double)
    */
   @Override
   public void tick(double delta) {
      time += (float) delta;
      int mx = Mouse.getX();
      int my = (Display.getHeight() + 1) - Mouse.getY();

      int dwheel = Mouse.getDWheel();
      if (dwheel > 0) {
         rotation += 0.1;
      } else if (dwheel < 0) {
         rotation -= 0.1;
      }
      quad.getMatrix()
            .identity().translate(new Vec2(mx, my)).rotate(rotation, Vec3.UP);
      quad.updateFromMatrix();


      for (int i = 0; i < collisions.length; i++) {
         collisions[i] = false;
      }
      Collision.axesTested = 0;
      Collision.objectsTested = 0;
      long time = (Sys.getTime() * 1_000) / Sys.getTimerResolution();
      colliding = false;
      for (int i = 0; i < polys.length; i++) {
         if (Collision.polyVsPoly(quad, polys[i])) {
            collisions[i] = true;
            colliding = true;
         }
      }
      System.out.println("Time taken: " + (((Sys.getTime() * 1_000) / Sys.getTimerResolution())-time) + ", axis tested: " + Collision.axesTested + ", objects tested: " + Collision.objectsTested);
   }

   private int count = 0;

   /* (non-Javadoc)
    * @see org.matheusdev.util.gameloop.GameLooper#render(double)
    */
   @Override
   public void render(double fps) {
      glClear(GL_COLOR_BUFFER_BIT);

      glColor3f(1, 1, 1);
      for (int i = 0; i < polys.length; i++) {
         if (collisions[i]) {
            glColor3f(1, 0, 0);
         } else {
            glColor3f(1, 1, 1);
         }
         drawVertices(polys[i].getTransformedVertices());
      }
      if (colliding) {
         glColor3f(1, 0, 0);
      } else {
         glColor3f(1, 1, 1);
      }
      drawVertices(quad.getTransformedVertices());

      if (count == 60) {
         count = 0;
         System.out.println("Rendered, fps: " + fps);
      }
      count++;
      Display.update();
   }

   public void drawVertices(Vec2[] vertices) {
      glBegin(GL_LINE_LOOP);
      for (Vec2 vertex : vertices) {
         glVertex2f(vertex.x, vertex.y);
      }
      glEnd();
   }

   public void drawCircle(Circle circ, float interval) {
      float oneSegment = ((float) Math.PI / 180f) * interval;
      Vec2 vec = new Vec2(circ.getRadius(), 0);
      glBegin(GL_LINE_LOOP);
      for (float i = 0; i < 360f; i += interval) {
         glVertex2f(vec.x + circ.getCenter().x, vec.y + circ.getCenter().y);
         vec.rotateRad(oneSegment);
      }
      glEnd();
   }

   /* (non-Javadoc)
    * @see org.matheusdev.util.gameloop.GameLooper#dispose()
    */
   @Override
   public void dispose() {
      Display.destroy();
   }

}