#pragma once
 
#ifndef TCG_TRIANGULATE_HPP
#define TCG_TRIANGULATE_HPP
 
// tcg includes
#include "../triangulate.h"
#include "../traits.h"
#include "../point_ops.h"
 
// OS-specific includes
#ifdef WIN32
#include "windows.h"
#include <GL/glu.h>
#elif MACOSX
#include <GLUT/glut.h>
#elif LINUX
#include <GL/glut.h>
#include <cstring>
#endif
 
#ifndef TCG_GLU_CALLBACK
#ifdef WIN32
#define TCG_GLU_CALLBACK void(CALLBACK *)()
#else
#define TCG_GLU_CALLBACK void (*)()
#endif
#endif
 
#ifndef CALLBACK
#define CALLBACK
#endif
 
namespace tcg {
 
//**************************************************************************************
//    GLU Tessellator Callbacks
//**************************************************************************************
 
namespace detail {
 
template <typename mesh_type>
struct CBackData {
  mesh_type *m_mesh;
  int m_triangle[3];
  int m_i;
};
 
//============================================================================
 
// NOTE: must be declared with CALLBACK directive
template <typename mesh_type>
void CALLBACK tessBegin(GLenum type, void *polygon_data) {
  assert(type == GL_TRIANGLES);
 
  CBackData<mesh_type> *data = (CBackData<mesh_type> *)polygon_data;
  data->m_i                  = 0;
}
 
//----------------------------------------------------------------------------
 
template <typename mesh_type>
void CALLBACK tessEnd(void *polygon_data) {
  CBackData<mesh_type> *data = (CBackData<mesh_type> *)polygon_data;
  assert(data->m_i == 0);
}
 
//----------------------------------------------------------------------------
 
template <typename mesh_type, typename vertex_type>
void CALLBACK tessVertex(void *vertex_data, void *polygon_data) {
  typedef typename mesh_type::vertex_type::point_type point_type;
 
  CBackData<mesh_type> *data = (CBackData<mesh_type> *)polygon_data;
  vertex_type *vData         = (vertex_type *)vertex_data;
 
  GLdouble(&pos)[3] =
      TriMeshStuff::glu_vertex_traits<vertex_type>::vertex3d(*vData);
  int &idx = TriMeshStuff::glu_vertex_traits<vertex_type>::index(*vData);
 
  if (idx < 0) {
    data->m_mesh->addVertex(
        typename mesh_type::vertex_type(point_type(pos[0], pos[1])));
    idx = data->m_mesh->verticesCount() - 1;
  }
 
  data->m_triangle[data->m_i] = idx;
  data->m_i                   = (data->m_i + 1) % 3;
 
  if (data->m_i == 0)
    data->m_mesh->addFace(data->m_triangle[0], data->m_triangle[1],
                          data->m_triangle[2]);
}
 
//----------------------------------------------------------------------------
 
// Supplied to ensure that triangle primitives are always of type GL_TRIANGLE
template <typename mesh_type>
void CALLBACK edgeFlag(GLboolean flag) {}
 
}  // namespace tcg::detail
 
//**************************************************************************************
//    Polygon triangulation
//**************************************************************************************
 
namespace detail {
 
template <typename Func>
void gluRegister(GLUtesselator *tess, GLenum which, Func *func) {
  gluTessCallback(tess, which, (TCG_GLU_CALLBACK)func);
}
 
}  // namespace tcg::detail
 
//---------------------------------------------------------------------------
 
template <typename ForIt, typename ContainersReader>
void gluTriangulate(ForIt tribeBegin, ForIt tribeEnd,
                    ContainersReader &meshes_reader) {
  using namespace detail;
 
  typedef typename tcg::traits<typename ForIt::value_type>::pointed_type
      family_type;
  typedef typename tcg::traits<typename family_type::value_type>::pointed_type
      polygon_type;
  typedef typename polygon_type::value_type vertex_type;
 
  typedef typename tcg::container_reader_traits<ContainersReader> output;
  typedef
      typename tcg::traits<typename output::value_type>::pointed_type mesh_type;
 
  GLUtesselator *tess = gluNewTess();  // create a tessellator
  assert(tess);
 
  // Declare callbacks
 
  // NOTE: On g++, it seems that at this point each of the callbacks still have
  // undefined type.
  // We use the above gluRegister template to force the compiler to generate
  // these types.
 
  gluRegister(tess, GLU_TESS_BEGIN_DATA, tessBegin<mesh_type>);
  gluRegister(tess, GLU_TESS_END_DATA, tessEnd<mesh_type>);
  gluRegister(tess, GLU_TESS_VERTEX_DATA, tessVertex<mesh_type, vertex_type>);
  gluRegister(tess, GLU_TESS_EDGE_FLAG, edgeFlag<mesh_type>);
 
  output::openContainer(meshes_reader);
 
  // Iterate the tribe. For every polygons family, associate one output mesh
  for (ForIt it = tribeBegin; it != tribeEnd; ++it) {
    // Build the output mesh and initialize stuff
    mesh_type *mesh = new mesh_type;
 
    CBackData<mesh_type> cbData;  // Callback Data about the mesh
    cbData.m_mesh = mesh;
 
    // Tessellate the family
    gluTessBeginPolygon(tess, (void *)&cbData);
 
    typename family_type::iterator ft, fEnd = (*it)->end();
    for (ft = (*it)->begin(); ft != fEnd; ++ft) {
      gluTessBeginContour(tess);
 
      typename polygon_type::iterator pt, pEnd = (*ft)->end();
      for (pt = (*ft)->begin(); pt != pEnd; ++pt)
        gluTessVertex(
            tess, TriMeshStuff::glu_vertex_traits<vertex_type>::vertex3d(*pt),
            (void *)&*pt);
 
      gluTessEndContour(tess);
    }
 
    gluTessEndPolygon(tess);  // Invokes the family tessellation
 
    output::addElement(meshes_reader, mesh);
  }
 
  gluDeleteTess(tess);  // delete after tessellation
 
  output::closeContainer(meshes_reader);
}
 
//**************************************************************************************
//    Mesh refinement
//**************************************************************************************
 
namespace detail {
 
template <typename mesh_type>
inline void touchEdge(std::vector<UCHAR> &buildEdge, mesh_type &mesh, int e) {
  typename mesh_type::edge_type &ed = mesh.edge(e);
  int f1 = ed.face(0), f2 = ed.face(1);
 
  if (f1 >= 0) {
    typename mesh_type::face_type &f = mesh.face(f1);
    buildEdge[f.edge(0)] = 1, buildEdge[f.edge(1)] = 1,
    buildEdge[f.edge(2)] = 1;
  }
  if (f2 >= 0) {
    typename mesh_type::face_type &f = mesh.face(f2);
    buildEdge[f.edge(0)] = 1, buildEdge[f.edge(1)] = 1,
    buildEdge[f.edge(2)] = 1;
  }
}
 
//---------------------------------------------------------------------------
 
template <typename mesh_type>
inline void touchVertex(std::vector<UCHAR> &buildEdge, mesh_type &mesh, int v) {
  // Sign all adjacent edges and adjacent faces' edges to v
  typename mesh_type::vertex_type &vx = mesh.vertex(v);
  const tcg::list<int> &incidentEdges = vx.edges();
  tcg::list<int>::const_iterator it;
 
  for (it = incidentEdges.begin(); it != incidentEdges.end(); ++it)
    touchEdge(buildEdge, mesh, *it);
}
 
//================================================================================
 
template <typename mesh_type>
class BoundaryEdges {
  std::vector<UCHAR> m_boundaryVertices;
  const mesh_type &m_mesh;
 
public:
  BoundaryEdges(const mesh_type &mesh) : m_mesh(mesh) {
    const tcg::list<typename mesh_type::edge_type> &edges = mesh.edges();
    const tcg::list<typename mesh_type::vertex_type> &vertices =
        mesh.vertices();
 
    m_boundaryVertices.resize(vertices.nodesCount(), 0);
 
    typename tcg::list<typename mesh_type::edge_type>::const_iterator it;
    for (it = edges.begin(); it != edges.end(); ++it) {
      if (it->face(0) < 0 || it->face(1) < 0) {
        m_boundaryVertices[it->vertex(0)] = true;
        m_boundaryVertices[it->vertex(1)] = true;
      }
    }
  }
  ~BoundaryEdges() {}
 
  void setBoundaryVertex(int v) {
    m_boundaryVertices.resize(m_mesh.vertices().nodesCount(), 0);
    m_boundaryVertices[v] = 1;
  }
 
  bool isBoundaryVertex(int v) const {
    return v < int(m_boundaryVertices.size()) && m_boundaryVertices[v];
  }
  bool isBoundaryEdge(int e) const {
    const typename mesh_type::edge_type &ed = m_mesh.edge(e);
    return ed.face(0) < 0 || ed.face(1) < 0;
  }
};
 
}  // namespace tcg::detail
 
//=============================================================================
 
template <typename mesh_type>
void TriMeshStuff::DefaultEvaluator<mesh_type>::actionSort(
    const mesh_type &mesh, int e,
    typename ActionEvaluator<mesh_type>::Action *actionSequence) {
  typedef ActionEvaluator<mesh_type> ActionEvaluator;
 
  int count = 0;
  memset(actionSequence, ActionEvaluator::NONE,
         3 * sizeof(typename ActionEvaluator::Action));
 
  // Try to minimize the edge length deviation in e's neighbourhood
  const typename mesh_type::edge_type &ed = mesh.edge(e);
  int f1 = ed.face(0), f2 = ed.face(1);
  const TPointD *v1, *v2, *v3, *v4;
  double length[6];
 
  v1 = &mesh.vertex(ed.vertex(0)).P();
  v2 = &mesh.vertex(ed.vertex(1)).P();
 
  length[0]        = norm(*v2 - *v1);
  double lengthMax = length[0], lengthMin = length[0];
 
  if (f1 >= 0) {
    v3        = &mesh.vertex(mesh.otherFaceVertex(f1, e)).P();
    length[1] = norm(*v3 - *v1);
    length[2] = norm(*v3 - *v2);
    lengthMax = std::max({lengthMax, length[1], length[2]});
    lengthMin = std::min({lengthMin, length[1], length[2]});
  }
 
  if (f2 >= 0) {
    v4        = &mesh.vertex(mesh.otherFaceVertex(f2, e)).P();
    length[3] = norm(*v4 - *v1);
    length[4] = norm(*v4 - *v2);
    lengthMax = std::max({lengthMax, length[3], length[4]});
    lengthMin = std::min({lengthMin, length[3], length[4]});
  }
 
  if (f1 >= 0 && f2 >= 0) {
    // Build the edge lengths
    length[5] = norm(*v4 - *v3);
 
    // Evaluate swap - take the triangles with least maximum mean boundary edge
    double m1 = (length[0] + length[1] + length[2]) / 3.0;
    double m2 = (length[0] + length[3] + length[4]) / 3.0;
    double m3 = (length[5] + length[1] + length[3]) / 3.0;
    double m4 = (length[5] + length[2] + length[4]) / 3.0;
 
    if (std::max(m3, m4) < std::max(m1, m2) - 1e-5)
      actionSequence[count++] = ActionEvaluator::SWAP;
 
    // NOTE: The original swap evaluation was about maximizing the minimal face
    // angle.
    // However, this requires quite some cross products - the above test is
    // sufficiently
    // simple and has a similar behaviour.
 
    // Evaluate collapse
    if (length[0] < m_collapseValue)
      actionSequence[count++] = ActionEvaluator::COLLAPSE;
  }
 
  // Evaluate split
  if (length[0] > m_splitValue)
    actionSequence[count++] = ActionEvaluator::SPLIT;
}
 
//=============================================================================
 
namespace detail {
 
template <typename mesh_type>
inline bool testSwap(const mesh_type &mesh, int e) {
  // Retrieve adjacent faces
  const typename mesh_type::edge_type &ed = mesh.edge(e);
 
  int f1 = ed.face(0), f2 = ed.face(1);
  if (f1 < 0 || f2 < 0) return false;
 
  // Retrieve the 4 adjacent vertices
  const typename mesh_type::vertex_type &v1 = mesh.vertex(ed.vertex(0));
  const typename mesh_type::vertex_type &v2 = mesh.vertex(ed.vertex(1));
  const typename mesh_type::vertex_type &v3 =
      mesh.vertex(mesh.otherFaceVertex(f1, ed.getIndex()));
  const typename mesh_type::vertex_type &v4 =
      mesh.vertex(mesh.otherFaceVertex(f2, ed.getIndex()));
 
  // Make sure that vertex v4 lies between the semiplane generated by v3v1 and
  // v3v2
  TPointD a(v1.P() - v3.P()), b(v2.P() - v3.P());
 
  double normA = norm(a), normB = norm(b);
  if (normA < 1e-5 || normB < 1e-5) return false;
 
  a = a * (1.0 / normA);
  b = b * (1.0 / normB);
 
  TPointD c(v4.P() - v1.P()), d(v4.P() - v2.P());
 
  double normC = norm(c), normD = norm(d);
  if (normC < 1e-5 || normD < 1e-5) return false;
 
  c = c * (1.0 / normC);
  d = d * (1.0 / normD);
 
  double crossAC = point_ops::cross(a, c);
  int signAC     = crossAC < -1e-5 ? -1 : crossAC > 1e-5 ? 1 : 0;
  double crossBD = point_ops::cross(b, d);
  int signBD     = crossBD < -1e-5 ? -1 : crossBD > 1e-5 ? 1 : 0;
 
  return signAC == -signBD;
}
 
//----------------------------------------------------------------------------
 
// Tests edge e for admissibility of ad edge collapse. Edge e must not have
// adjacent
// faces with boundary components.
// Furthermore, we must test that faces adjacent to f1 and f2 keep e on the same
// side of
// the line passing through v3v1 and v3v2.
template <typename mesh_type>
inline bool testCollapse(const mesh_type &mesh, int e,
                         const BoundaryEdges<mesh_type> &boundary) {
  // Any face adjacent to e must have no boundary edge
  const typename mesh_type::edge_type &ed = mesh.edge(e);
  int f1 = ed.face(0), f2 = ed.face(1);
 
  if (f1 < 0 || f2 < 0) return false;
 
  int v1 = mesh.edge(e).vertex(0), v2 = mesh.edge(e).vertex(1);
  if (boundary.isBoundaryVertex(v1) || boundary.isBoundaryVertex(v2))
    return false;
 
  // Test faces adjacent to v1 or v2. Since one of their vertices will change,
  // we must make sure that their
  //'side' does not change too.
  int v = mesh.otherFaceVertex(f1, e);
  int l = mesh.edgeInciding(v1, v);
  int f =
      mesh.edge(l).face(0) == f1 ? mesh.edge(l).face(1) : mesh.edge(l).face(0);
  int vNext = mesh.otherFaceVertex(f, l);
 
  while (f != f2) {
    // Test face f
    if (tsign(point_ops::cross(mesh.vertex(vNext).P() - mesh.vertex(v).P(),
                               mesh.vertex(v2).P() - mesh.vertex(v).P())) !=
        tsign(point_ops::cross(mesh.vertex(vNext).P() - mesh.vertex(v).P(),
                               mesh.vertex(v1).P() - mesh.vertex(v).P())))
      return false;
 
    // Update vars
    v = vNext;
    l = mesh.edgeInciding(v1, v);
    f = mesh.edge(l).face(0) == f ? mesh.edge(l).face(1) : mesh.edge(l).face(0);
    vNext = mesh.otherFaceVertex(f, l);
  }
 
  // Same with respect to v2
  v = mesh.otherFaceVertex(f1, e);
  l = mesh.edgeInciding(v2, v);
  f = mesh.edge(l).face(0) == f1 ? mesh.edge(l).face(1) : mesh.edge(l).face(0);
  vNext = mesh.otherFaceVertex(f, l);
 
  while (f != f2) {
    // Test face f
    if (tsign(point_ops::cross(mesh.vertex(vNext).P() - mesh.vertex(v).P(),
                               mesh.vertex(v2).P() - mesh.vertex(v).P())) !=
        tsign(point_ops::cross(mesh.vertex(vNext).P() - mesh.vertex(v).P(),
                               mesh.vertex(v1).P() - mesh.vertex(v).P())))
      return false;
 
    // Update vars
    v = vNext;
    l = mesh.edgeInciding(v2, v);
    f = mesh.edge(l).face(0) == f ? mesh.edge(l).face(1) : mesh.edge(l).face(0);
    vNext = mesh.otherFaceVertex(f, l);
  }
 
  return true;
}
 
}  // namespace tcg::detail
 
//----------------------------------------------------------------------------
 
template <typename mesh_type>
void refineMesh(mesh_type &mesh, TriMeshStuff::ActionEvaluator<mesh_type> &eval,
                unsigned long maxActions) {
  using namespace detail;
 
  typedef TriMeshStuff::ActionEvaluator<mesh_type> Evaluator;
  typedef typename Evaluator::Action Action;
 
  // DIAGNOSTICS_TIMER("simplifyMesh");
 
  // Build boundary edges. They will not be altered by the simplification
  // procedure.
  detail::BoundaryEdges<mesh_type> boundary(mesh);
  Action actions[3], *act, *actEnd = actions + 3;
 
  tcg::list<Edge> &edges = mesh.edges();
  tcg::list<Edge>::iterator it;
 
  // DIAGNOSTICS_SET("Simplify | Vertex count (before simplify)",
  // mesh.vertexCount());
  // DIAGNOSTICS_SET("Simplify | Edges count (before simplify)", edges.size());
 
  // Build a vector of the edges to be analyzed
  std::vector<UCHAR> buildEdge(edges.nodesCount(), 1);
  int touchedIdx;
  bool boundaryEdge;
 
cycle:
 
  if (maxActions-- == 0) return;
 
  // Analyze mesh for possible updates. Perform the first one.
  for (it = edges.begin(); it != edges.end(); ++it) {
    if (!buildEdge[it.m_idx]) continue;
 
    boundaryEdge = boundary.isBoundaryEdge(it.m_idx);
 
    eval.actionSort(mesh, it.m_idx, actions);
 
    for (act = actions; act < actEnd; ++act) {
      // Try to perform the i-th action
      if (*act == Evaluator::NONE)
        break;
 
      else if (!boundaryEdge && *act == Evaluator::SWAP &&
               testSwap(mesh, it.m_idx)) {
        touchedIdx = mesh.swapEdge(it.m_idx);
        touchEdge(buildEdge, mesh, touchedIdx);
 
        goto cycle;
      } else if (!boundaryEdge && *act == Evaluator::COLLAPSE &&
                 testCollapse(mesh, it.m_idx, boundary)) {
        touchedIdx = mesh.collapseEdge(it.m_idx);
        touchVertex(buildEdge, mesh, touchedIdx);
 
        goto cycle;
      } else if (*act == Evaluator::SPLIT) {
        Edge &ed = mesh.edge(it.m_idx);
        touchVertex(buildEdge, mesh, ed.vertex(0));
        touchVertex(buildEdge, mesh, ed.vertex(1));
 
        touchedIdx = mesh.splitEdge(it.m_idx);
        if (buildEdge.size() < edges.size()) buildEdge.resize(edges.size());
 
        touchVertex(buildEdge, mesh, touchedIdx);
        if (boundaryEdge) boundary.setBoundaryVertex(touchedIdx);
 
        goto cycle;
      }
    }
 
    buildEdge[it.m_idx] = 0;
  }
 
  // DIAGNOSTICS_SET("Simplify | Vertex count (after simplify)",
  // mesh.vertexCount());
  // DIAGNOSTICS_SET("Simplify | Edges count (after simplify)", edges.size());
}
 
}  // namespace tcg
 
#endif  // TCG_TRIANGULATE_HPP