/*******************************************************************************
 * Copyright (c) 2013, Daniel Murphy
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 	* Redistributions of source code must retain the above copyright notice,
 * 	  this list of conditions and the following disclaimer.
 * 	* Redistributions in binary form must reproduce the above copyright notice,
 * 	  this list of conditions and the following disclaimer in the documentation
 * 	  and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 ******************************************************************************/
package org.jbox2d.collision;

import org.jbox2d.collision.shapes.ChainShape;
import org.jbox2d.collision.shapes.CircleShape;
import org.jbox2d.collision.shapes.EdgeShape;
import org.jbox2d.collision.shapes.PolygonShape;
import org.jbox2d.collision.shapes.Shape;
import org.jbox2d.common.MathUtils;
import org.jbox2d.common.Rot;
import org.jbox2d.common.Settings;
import org.jbox2d.common.Vec2;
import org.jbox2d.common.Transform;

// updated to rev 100
/**
 * This is non-static for faster pooling. To get an instance, use the {@link SingletonPool}, don't
 * construct a distance object.
 * 
 * @author Daniel Murphy
 */
public class Distance {
  public static final int MAX_ITERS = 20;

  public static int GJK_CALLS = 0;
  public static int GJK_ITERS = 0;
  public static int GJK_MAX_ITERS = 20;

  /**
   * GJK using Voronoi regions (Christer Ericson) and Barycentric coordinates.
   */
  private class SimplexVertex {
    public final Vec2 wA = new Vec2(); // support point in shapeA
    public final Vec2 wB = new Vec2(); // support point in shapeB
    public final Vec2 w = new Vec2(); // wB - wA
    public float a; // barycentric coordinate for closest point
    public int indexA; // wA index
    public int indexB; // wB index

    public void set(SimplexVertex sv) {
      wA.set(sv.wA);
      wB.set(sv.wB);
      w.set(sv.w);
      a = sv.a;
      indexA = sv.indexA;
      indexB = sv.indexB;
    }
  }

  /**
   * Used to warm start Distance. Set count to zero on first call.
   * 
   * @author daniel
   */
  public static class SimplexCache {
    /** length or area */
    public float metric;
    public int count;
    /** vertices on shape A */
    public final int indexA[] = new int[3];
    /** vertices on shape B */
    public final int indexB[] = new int[3];

    public SimplexCache() {
      metric = 0;
      count = 0;
      indexA[0] = Integer.MAX_VALUE;
      indexA[1] = Integer.MAX_VALUE;
      indexA[2] = Integer.MAX_VALUE;
      indexB[0] = Integer.MAX_VALUE;
      indexB[1] = Integer.MAX_VALUE;
      indexB[2] = Integer.MAX_VALUE;
    }

    public void set(SimplexCache sc) {
      System.arraycopy(sc.indexA, 0, indexA, 0, indexA.length);
      System.arraycopy(sc.indexB, 0, indexB, 0, indexB.length);
      metric = sc.metric;
      count = sc.count;
    }
  }

  private class Simplex {
    public final SimplexVertex m_v1 = new SimplexVertex();
    public final SimplexVertex m_v2 = new SimplexVertex();
    public final SimplexVertex m_v3 = new SimplexVertex();
    public final SimplexVertex vertices[] = {m_v1, m_v2, m_v3};
    public int m_count;

    public void readCache(SimplexCache cache, DistanceProxy proxyA, Transform transformA,
        DistanceProxy proxyB, Transform transformB) {
      assert (cache.count <= 3);

      // Copy data from cache.
      m_count = cache.count;

      for (int i = 0; i < m_count; ++i) {
        SimplexVertex v = vertices[i];
        v.indexA = cache.indexA[i];
        v.indexB = cache.indexB[i];
        Vec2 wALocal = proxyA.getVertex(v.indexA);
        Vec2 wBLocal = proxyB.getVertex(v.indexB);
        Transform.mulToOutUnsafe(transformA, wALocal, v.wA);
        Transform.mulToOutUnsafe(transformB, wBLocal, v.wB);
        v.w.set(v.wB).subLocal(v.wA);
        v.a = 0.0f;
      }

      // Compute the new simplex metric, if it is substantially different than
      // old metric then flush the simplex.
      if (m_count > 1) {
        float metric1 = cache.metric;
        float metric2 = getMetric();
        if (metric2 < 0.5f * metric1 || 2.0f * metric1 < metric2 || metric2 < Settings.EPSILON) {
          // Reset the simplex.
          m_count = 0;
        }
      }

      // If the cache is empty or invalid ...
      if (m_count == 0) {
        SimplexVertex v = vertices[0];
        v.indexA = 0;
        v.indexB = 0;
        Vec2 wALocal = proxyA.getVertex(0);
        Vec2 wBLocal = proxyB.getVertex(0);
        Transform.mulToOutUnsafe(transformA, wALocal, v.wA);
        Transform.mulToOutUnsafe(transformB, wBLocal, v.wB);
        v.w.set(v.wB).subLocal(v.wA);
        m_count = 1;
      }
    }

    public void writeCache(SimplexCache cache) {
      cache.metric = getMetric();
      cache.count = m_count;

      for (int i = 0; i < m_count; ++i) {
        cache.indexA[i] = (vertices[i].indexA);
        cache.indexB[i] = (vertices[i].indexB);
      }
    }

    private final Vec2 e12 = new Vec2();

    public final void getSearchDirection(final Vec2 out) {
      switch (m_count) {
        case 1:
          out.set(m_v1.w).negateLocal();
          return;
        case 2:
          e12.set(m_v2.w).subLocal(m_v1.w);
          // use out for a temp variable real quick
          out.set(m_v1.w).negateLocal();
          float sgn = Vec2.cross(e12, out);

          if (sgn > 0f) {
            // Origin is left of e12.
            Vec2.crossToOutUnsafe(1f, e12, out);
            return;
          } else {
            // Origin is right of e12.
            Vec2.crossToOutUnsafe(e12, 1f, out);
            return;
          }
        default:
          assert (false);
          out.setZero();
          return;
      }
    }

    // djm pooled
    private final Vec2 case2 = new Vec2();
    private final Vec2 case22 = new Vec2();

    /**
     * this returns pooled objects. don't keep or modify them
     * 
     * @return
     */
    public void getClosestPoint(final Vec2 out) {
      switch (m_count) {
        case 0:
          assert (false);
          out.setZero();
          return;
        case 1:
          out.set(m_v1.w);
          return;
        case 2:
          case22.set(m_v2.w).mulLocal(m_v2.a);
          case2.set(m_v1.w).mulLocal(m_v1.a).addLocal(case22);
          out.set(case2);
          return;
        case 3:
          out.setZero();
          return;
        default:
          assert (false);
          out.setZero();
          return;
      }
    }

    // djm pooled, and from above
    private final Vec2 case3 = new Vec2();
    private final Vec2 case33 = new Vec2();

    public void getWitnessPoints(Vec2 pA, Vec2 pB) {
      switch (m_count) {
        case 0:
          assert (false);
          break;

        case 1:
          pA.set(m_v1.wA);
          pB.set(m_v1.wB);
          break;

        case 2:
          case2.set(m_v1.wA).mulLocal(m_v1.a);
          pA.set(m_v2.wA).mulLocal(m_v2.a).addLocal(case2);
          // m_v1.a * m_v1.wA + m_v2.a * m_v2.wA;
          // *pB = m_v1.a * m_v1.wB + m_v2.a * m_v2.wB;
          case2.set(m_v1.wB).mulLocal(m_v1.a);
          pB.set(m_v2.wB).mulLocal(m_v2.a).addLocal(case2);

          break;

        case 3:
          pA.set(m_v1.wA).mulLocal(m_v1.a);
          case3.set(m_v2.wA).mulLocal(m_v2.a);
          case33.set(m_v3.wA).mulLocal(m_v3.a);
          pA.addLocal(case3).addLocal(case33);
          pB.set(pA);
          // *pA = m_v1.a * m_v1.wA + m_v2.a * m_v2.wA + m_v3.a * m_v3.wA;
          // *pB = *pA;
          break;

        default:
          assert (false);
          break;
      }
    }

    // djm pooled, from above
    public float getMetric() {
      switch (m_count) {
        case 0:
          assert (false);
          return 0.0f;

        case 1:
          return 0.0f;

        case 2:
          return MathUtils.distance(m_v1.w, m_v2.w);

        case 3:
          case3.set(m_v2.w).subLocal(m_v1.w);
          case33.set(m_v3.w).subLocal(m_v1.w);
          // return Vec2.cross(m_v2.w - m_v1.w, m_v3.w - m_v1.w);
          return Vec2.cross(case3, case33);

        default:
          assert (false);
          return 0.0f;
      }
    }

    // djm pooled from above
    /**
     * Solve a line segment using barycentric coordinates.
     */
    public void solve2() {
      // Solve a line segment using barycentric coordinates.
      //
      // p = a1 * w1 + a2 * w2
      // a1 + a2 = 1
      //
      // The vector from the origin to the closest point on the line is
      // perpendicular to the line.
      // e12 = w2 - w1
      // dot(p, e) = 0
      // a1 * dot(w1, e) + a2 * dot(w2, e) = 0
      //
      // 2-by-2 linear system
      // [1 1 ][a1] = [1]
      // [w1.e12 w2.e12][a2] = [0]
      //
      // Define
      // d12_1 = dot(w2, e12)
      // d12_2 = -dot(w1, e12)
      // d12 = d12_1 + d12_2
      //
      // Solution
      // a1 = d12_1 / d12
      // a2 = d12_2 / d12
      final Vec2 w1 = m_v1.w;
      final Vec2 w2 = m_v2.w;
      e12.set(w2).subLocal(w1);

      // w1 region
      float d12_2 = -Vec2.dot(w1, e12);
      if (d12_2 <= 0.0f) {
        // a2 <= 0, so we clamp it to 0
        m_v1.a = 1.0f;
        m_count = 1;
        return;
      }

      // w2 region
      float d12_1 = Vec2.dot(w2, e12);
      if (d12_1 <= 0.0f) {
        // a1 <= 0, so we clamp it to 0
        m_v2.a = 1.0f;
        m_count = 1;
        m_v1.set(m_v2);
        return;
      }

      // Must be in e12 region.
      float inv_d12 = 1.0f / (d12_1 + d12_2);
      m_v1.a = d12_1 * inv_d12;
      m_v2.a = d12_2 * inv_d12;
      m_count = 2;
    }

    // djm pooled, and from above
    private final Vec2 e13 = new Vec2();
    private final Vec2 e23 = new Vec2();
    private final Vec2 w1 = new Vec2();
    private final Vec2 w2 = new Vec2();
    private final Vec2 w3 = new Vec2();

    /**
     * Solve a line segment using barycentric coordinates.<br/>
     * Possible regions:<br/>
     * - points[2]<br/>
     * - edge points[0]-points[2]<br/>
     * - edge points[1]-points[2]<br/>
     * - inside the triangle
     */
    public void solve3() {
      w1.set(m_v1.w);
      w2.set(m_v2.w);
      w3.set(m_v3.w);

      // Edge12
      // [1 1 ][a1] = [1]
      // [w1.e12 w2.e12][a2] = [0]
      // a3 = 0
      e12.set(w2).subLocal(w1);
      float w1e12 = Vec2.dot(w1, e12);
      float w2e12 = Vec2.dot(w2, e12);
      float d12_1 = w2e12;
      float d12_2 = -w1e12;

      // Edge13
      // [1 1 ][a1] = [1]
      // [w1.e13 w3.e13][a3] = [0]
      // a2 = 0
      e13.set(w3).subLocal(w1);
      float w1e13 = Vec2.dot(w1, e13);
      float w3e13 = Vec2.dot(w3, e13);
      float d13_1 = w3e13;
      float d13_2 = -w1e13;

      // Edge23
      // [1 1 ][a2] = [1]
      // [w2.e23 w3.e23][a3] = [0]
      // a1 = 0
      e23.set(w3).subLocal(w2);
      float w2e23 = Vec2.dot(w2, e23);
      float w3e23 = Vec2.dot(w3, e23);
      float d23_1 = w3e23;
      float d23_2 = -w2e23;

      // Triangle123
      float n123 = Vec2.cross(e12, e13);

      float d123_1 = n123 * Vec2.cross(w2, w3);
      float d123_2 = n123 * Vec2.cross(w3, w1);
      float d123_3 = n123 * Vec2.cross(w1, w2);

      // w1 region
      if (d12_2 <= 0.0f && d13_2 <= 0.0f) {
        m_v1.a = 1.0f;
        m_count = 1;
        return;
      }

      // e12
      if (d12_1 > 0.0f && d12_2 > 0.0f && d123_3 <= 0.0f) {
        float inv_d12 = 1.0f / (d12_1 + d12_2);
        m_v1.a = d12_1 * inv_d12;
        m_v2.a = d12_2 * inv_d12;
        m_count = 2;
        return;
      }

      // e13
      if (d13_1 > 0.0f && d13_2 > 0.0f && d123_2 <= 0.0f) {
        float inv_d13 = 1.0f / (d13_1 + d13_2);
        m_v1.a = d13_1 * inv_d13;
        m_v3.a = d13_2 * inv_d13;
        m_count = 2;
        m_v2.set(m_v3);
        return;
      }

      // w2 region
      if (d12_1 <= 0.0f && d23_2 <= 0.0f) {
        m_v2.a = 1.0f;
        m_count = 1;
        m_v1.set(m_v2);
        return;
      }

      // w3 region
      if (d13_1 <= 0.0f && d23_1 <= 0.0f) {
        m_v3.a = 1.0f;
        m_count = 1;
        m_v1.set(m_v3);
        return;
      }

      // e23
      if (d23_1 > 0.0f && d23_2 > 0.0f && d123_1 <= 0.0f) {
        float inv_d23 = 1.0f / (d23_1 + d23_2);
        m_v2.a = d23_1 * inv_d23;
        m_v3.a = d23_2 * inv_d23;
        m_count = 2;
        m_v1.set(m_v3);
        return;
      }

      // Must be in triangle123
      float inv_d123 = 1.0f / (d123_1 + d123_2 + d123_3);
      m_v1.a = d123_1 * inv_d123;
      m_v2.a = d123_2 * inv_d123;
      m_v3.a = d123_3 * inv_d123;
      m_count = 3;
    }
  }

  /**
   * A distance proxy is used by the GJK algorithm. It encapsulates any shape. TODO: see if we can
   * just do assignments with m_vertices, instead of copying stuff over
   * 
   * @author daniel
   */
  public static class DistanceProxy {
    public final Vec2[] m_vertices;
    public int m_count;
    public float m_radius;
    public final Vec2[] m_buffer;

    public DistanceProxy() {
      m_vertices = new Vec2[Settings.maxPolygonVertices];
      for (int i = 0; i < m_vertices.length; i++) {
        m_vertices[i] = new Vec2();
      }
      m_buffer = new Vec2[2];
      m_count = 0;
      m_radius = 0f;
    }

    /**
     * Initialize the proxy using the given shape. The shape must remain in scope while the proxy is
     * in use.
     */
    public final void set(final Shape shape, int index) {
      switch (shape.getType()) {
        case CIRCLE:
          final CircleShape circle = (CircleShape) shape;
          m_vertices[0].set(circle.m_p);
          m_count = 1;
          m_radius = circle.m_radius;

          break;
        case POLYGON:
          final PolygonShape poly = (PolygonShape) shape;
          m_count = poly.m_count;
          m_radius = poly.m_radius;
          for (int i = 0; i < m_count; i++) {
            m_vertices[i].set(poly.m_vertices[i]);
          }
          break;
        case CHAIN:
          final ChainShape chain = (ChainShape) shape;
          assert (0 <= index && index < chain.m_count);

          m_buffer[0] = chain.m_vertices[index];
          if (index + 1 < chain.m_count) {
            m_buffer[1] = chain.m_vertices[index + 1];
          } else {
            m_buffer[1] = chain.m_vertices[0];
          }

          m_vertices[0].set(m_buffer[0]);
          m_vertices[1].set(m_buffer[1]);
          m_count = 2;
          m_radius = chain.m_radius;
          break;
        case EDGE:
          EdgeShape edge = (EdgeShape) shape;
          m_vertices[0].set(edge.m_vertex1);
          m_vertices[1].set(edge.m_vertex2);
          m_count = 2;
          m_radius = edge.m_radius;
          break;
        default:
          assert (false);
      }
    }

    /**
     * Get the supporting vertex index in the given direction.
     * 
     * @param d
     * @return
     */
    public final int getSupport(final Vec2 d) {
      int bestIndex = 0;
      float bestValue = Vec2.dot(m_vertices[0], d);
      for (int i = 1; i < m_count; i++) {
        float value = Vec2.dot(m_vertices[i], d);
        if (value > bestValue) {
          bestIndex = i;
          bestValue = value;
        }
      }

      return bestIndex;
    }

    /**
     * Get the supporting vertex in the given direction.
     * 
     * @param d
     * @return
     */
    public final Vec2 getSupportVertex(final Vec2 d) {
      int bestIndex = 0;
      float bestValue = Vec2.dot(m_vertices[0], d);
      for (int i = 1; i < m_count; i++) {
        float value = Vec2.dot(m_vertices[i], d);
        if (value > bestValue) {
          bestIndex = i;
          bestValue = value;
        }
      }

      return m_vertices[bestIndex];
    }

    /**
     * Get the vertex count.
     * 
     * @return
     */
    public final int getVertexCount() {
      return m_count;
    }

    /**
     * Get a vertex by index. Used by Distance.
     * 
     * @param index
     * @return
     */
    public final Vec2 getVertex(int index) {
      assert (0 <= index && index < m_count);
      return m_vertices[index];
    }
  }

  private Simplex simplex = new Simplex();
  private int[] saveA = new int[3];
  private int[] saveB = new int[3];
  private Vec2 closestPoint = new Vec2();
  private Vec2 d = new Vec2();
  private Vec2 temp = new Vec2();
  private Vec2 normal = new Vec2();

  /**
   * Compute the closest points between two shapes. Supports any combination of: CircleShape and
   * PolygonShape. The simplex cache is input/output. On the first call set SimplexCache.count to
   * zero.
   * 
   * @param output
   * @param cache
   * @param input
   */
  public final void distance(final DistanceOutput output, final SimplexCache cache,
      final DistanceInput input) {
    GJK_CALLS++;

    final DistanceProxy proxyA = input.proxyA;
    final DistanceProxy proxyB = input.proxyB;

    Transform transformA = input.transformA;
    Transform transformB = input.transformB;

    // Initialize the simplex.
    simplex.readCache(cache, proxyA, transformA, proxyB, transformB);

    // Get simplex vertices as an array.
    SimplexVertex[] vertices = simplex.vertices;

    // These store the vertices of the last simplex so that we
    // can check for duplicates and prevent cycling.
    // (pooled above)
    int saveCount = 0;

    simplex.getClosestPoint(closestPoint);
    float distanceSqr1 = closestPoint.lengthSquared();
    float distanceSqr2 = distanceSqr1;

    // Main iteration loop
    int iter = 0;
    while (iter < MAX_ITERS) {

      // Copy simplex so we can identify duplicates.
      saveCount = simplex.m_count;
      for (int i = 0; i < saveCount; i++) {
        saveA[i] = vertices[i].indexA;
        saveB[i] = vertices[i].indexB;
      }

      switch (simplex.m_count) {
        case 1:
          break;
        case 2:
          simplex.solve2();
          break;
        case 3:
          simplex.solve3();
          break;
        default:
          assert (false);
      }

      // If we have 3 points, then the origin is in the corresponding triangle.
      if (simplex.m_count == 3) {
        break;
      }

      // Compute closest point.
      simplex.getClosestPoint(closestPoint);
      distanceSqr2 = closestPoint.lengthSquared();

      // ensure progress
      if (distanceSqr2 >= distanceSqr1) {
        // break;
      }
      distanceSqr1 = distanceSqr2;

      // get search direction;
      simplex.getSearchDirection(d);

      // Ensure the search direction is numerically fit.
      if (d.lengthSquared() < Settings.EPSILON * Settings.EPSILON) {
        // The origin is probably contained by a line segment
        // or triangle. Thus the shapes are overlapped.

        // We can't return zero here even though there may be overlap.
        // In case the simplex is a point, segment, or triangle it is difficult
        // to determine if the origin is contained in the CSO or very close to it.
        break;
      }
      /*
       * SimplexVertex* vertex = vertices + simplex.m_count; vertex.indexA =
       * proxyA.GetSupport(MulT(transformA.R, -d)); vertex.wA = Mul(transformA,
       * proxyA.GetVertex(vertex.indexA)); Vec2 wBLocal; vertex.indexB =
       * proxyB.GetSupport(MulT(transformB.R, d)); vertex.wB = Mul(transformB,
       * proxyB.GetVertex(vertex.indexB)); vertex.w = vertex.wB - vertex.wA;
       */

      // Compute a tentative new simplex vertex using support points.
      SimplexVertex vertex = vertices[simplex.m_count];

      Rot.mulTransUnsafe(transformA.q, d.negateLocal(), temp);
      vertex.indexA = proxyA.getSupport(temp);
      Transform.mulToOutUnsafe(transformA, proxyA.getVertex(vertex.indexA), vertex.wA);
      // Vec2 wBLocal;
      Rot.mulTransUnsafe(transformB.q, d.negateLocal(), temp);
      vertex.indexB = proxyB.getSupport(temp);
      Transform.mulToOutUnsafe(transformB, proxyB.getVertex(vertex.indexB), vertex.wB);
      vertex.w.set(vertex.wB).subLocal(vertex.wA);

      // Iteration count is equated to the number of support point calls.
      ++iter;
      ++GJK_ITERS;

      // Check for duplicate support points. This is the main termination criteria.
      boolean duplicate = false;
      for (int i = 0; i < saveCount; ++i) {
        if (vertex.indexA == saveA[i] && vertex.indexB == saveB[i]) {
          duplicate = true;
          break;
        }
      }

      // If we found a duplicate support point we must exit to avoid cycling.
      if (duplicate) {
        break;
      }

      // New vertex is ok and needed.
      ++simplex.m_count;
    }

    GJK_MAX_ITERS = MathUtils.max(GJK_MAX_ITERS, iter);

    // Prepare output.
    simplex.getWitnessPoints(output.pointA, output.pointB);
    output.distance = MathUtils.distance(output.pointA, output.pointB);
    output.iterations = iter;

    // Cache the simplex.
    simplex.writeCache(cache);

    // Apply radii if requested.
    if (input.useRadii) {
      float rA = proxyA.m_radius;
      float rB = proxyB.m_radius;

      if (output.distance > rA + rB && output.distance > Settings.EPSILON) {
        // Shapes are still no overlapped.
        // Move the witness points to the outer surface.
        output.distance -= rA + rB;
        normal.set(output.pointB).subLocal(output.pointA);
        normal.normalize();
        temp.set(normal).mulLocal(rA);
        output.pointA.addLocal(temp);
        temp.set(normal).mulLocal(rB);
        output.pointB.subLocal(temp);
      } else {
        // Shapes are overlapped when radii are considered.
        // Move the witness points to the middle.
        // Vec2 p = 0.5f * (output.pointA + output.pointB);
        output.pointA.addLocal(output.pointB).mulLocal(.5f);
        output.pointB.set(output.pointA);
        output.distance = 0.0f;
      }
    }
  }
}