#pragma once

#include <algorithm>
#include <cassert>
#include <cmath>
#include <memory>
#include <vector>

namespace earcut {
namespace util {

// #nocov start

template <std::size_t I, typename T> struct nth {
  inline static typename std::tuple_element<I, T>::type
  get(const T& t) { return std::get<I>(t); };
};

}

namespace detail {

template <typename N = uint32_t>
class Earcut {
public:

  std::vector< N > indices;
  std::vector< double > xyzcoords;
  std::size_t vertices = 0;
  std::size_t stride = 0;

  template <typename Polygon >
  void operator()(const Polygon& points);

private:
  struct Node {
    Node(N index, std::vector< double > coords_) : i(index), coords(coords_) {}
    //Node(N index, double x_, double y_ : i(index), x(x_), y(y_) {}
    Node(const Node&) = delete;
    Node& operator=(const Node&) = delete;
    Node(Node&&) = delete;
    Node& operator=(Node&&) = delete;

    const N i;
    const std::vector< double > coords;  // must have at least 2 dimensions
    const double x = coords[0];
    const double y = coords[1];

    // previous and next vertice nodes in a polygon ring
    Node* prev = nullptr;
    Node* next = nullptr;

    // z-order curve value
    int32_t z = 0;

    // previous and next nodes in z-order
    Node* prevZ = nullptr;
    Node* nextZ = nullptr;

    // indicates whether this is a steiner point
    bool steiner = false;
  };

  template <typename Ring> Node* linkedList(const Ring& points, const bool clockwise);
  Node* filterPoints(Node* start, Node* end = nullptr);
  template <typename Polygon> void earcutLinked(Node* ear, const Polygon& points, int pass = 0);
  bool isEar(Node* ear);
  bool isEarHashed(Node* ear);
  Node* cureLocalIntersections(Node* start);
  template <typename Polygon> void splitEarcut(Node* start, const Polygon& points);
  template <typename Polygon> Node* eliminateHoles(const Polygon& points, Node* outerNode);
  void eliminateHole(Node* hole, Node* outerNode);
  Node* findHoleBridge(Node* hole, Node* outerNode);
  bool sectorContainsSector(const Node* m, const Node* p);
  void indexCurve(Node* start);
  Node* sortLinked(Node* list);
  int32_t zOrder(const double x_, const double y_);
  Node* getLeftmost(Node* start);
  bool pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const;
  bool isValidDiagonal(Node* a, Node* b);
  double area(const Node* p, const Node* q, const Node* r) const;
  bool equals(const Node* p1, const Node* p2);
  bool intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2);
  bool onSegment(const Node* p, const Node* q, const Node* r);
  int sign(double val);
  bool intersectsPolygon(const Node* a, const Node* b);
  bool locallyInside(const Node* a, const Node* b);
  bool middleInside(const Node* a, const Node* b);
  Node* splitPolygon(Node* a, Node* b);
  template <typename Point> Node* insertNode(std::size_t i, const Point& p, Node* last);
  void removeNode(Node* p);

  bool hashing;
  double minX, maxX;
  double minY, maxY;
  double inv_size = 0;

  template <typename T, typename Alloc = std::allocator<T>>
  class ObjectPool {
  public:
    ObjectPool() { }
    ObjectPool(std::size_t blockSize_) {
      reset(blockSize_);
    }
    ~ObjectPool() {
      clear();
    }
    template <typename... Args>
    T* construct(Args&&... args) {
      if (currentIndex >= blockSize) {
        currentBlock = alloc_traits::allocate(alloc, blockSize);
        allocations.emplace_back(currentBlock);
        currentIndex = 0;
      }
      T* object = &currentBlock[currentIndex++];
      alloc_traits::construct(alloc, object, std::forward<Args>(args)...);
      return object;
    }
    void reset(std::size_t newBlockSize) {
      for (auto allocation : allocations) {
        alloc_traits::deallocate(alloc, allocation, blockSize);
      }
      allocations.clear();
      blockSize = std::max<std::size_t>(1, newBlockSize);
      currentBlock = nullptr;
      currentIndex = blockSize;
    }
    void clear() { reset(blockSize); }
  private:
    T* currentBlock = nullptr;
    std::size_t currentIndex = 1;
    std::size_t blockSize = 1;
    std::vector<T*> allocations;
    Alloc alloc;
    typedef typename std::allocator_traits<Alloc> alloc_traits;
  };
  ObjectPool<Node> nodes;
};

template <typename N > template <typename Polygon>
void Earcut<N>::operator()(const Polygon& points) {
  // reset
  indices.clear();
  xyzcoords.clear();
  vertices = 0;

  if (points.empty()) return;

  double x;
  double y;
  int threshold = 80;
  std::size_t len = 0;

  for (size_t i = 0; threshold >= 0 && i < points.size(); i++) {
    threshold -= static_cast<int>(points[i].size());
    len += points[i].size();
  }


  //estimate size of nodes and indices
  nodes.reset(len * 3 / 2);
  indices.reserve(len + points[0].size());
  stride = points[0][0].size();

  xyzcoords.reserve( ( len + points[0].size() ) * stride );

  Node* outerNode = linkedList(points[0], true);
  if (!outerNode || outerNode->prev == outerNode->next) return;

  if (points.size() > 1) outerNode = eliminateHoles(points, outerNode);

  // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
  hashing = threshold < 0;
  if (hashing) {
    Node* p = outerNode->next;
    minX = maxX = outerNode->x;
    minY = maxY = outerNode->y;
    do {
      x = p->x;
      y = p->y;
      minX = std::min<double>(minX, x);
      minY = std::min<double>(minY, y);
      maxX = std::max<double>(maxX, x);
      maxY = std::max<double>(maxY, y);
      p = p->next;
    } while (p != outerNode);

    // minX, minY and size are later used to transform coords into integers for z-order calculation
    inv_size = std::max<double>(maxX - minX, maxY - minY);
    inv_size = inv_size != .0 ? (1. / inv_size) : .0;
  }

  earcutLinked(outerNode, points);

  nodes.clear();
}

// create a circular doubly linked list from polygon points in the specified winding order
template <typename N> template <typename Ring>
typename Earcut<N>::Node*
Earcut<N>::linkedList(const Ring& points, const bool clockwise) {
  //using Point = typename Ring::value_type;
  double sum = 0;
  const std::size_t len = points.size();
  std::size_t i, j;
  Node* last = nullptr;

  // calculate original winding order of a polygon ring
  for (i = 0, j = len > 0 ? len - 1 : 0; i < len; j = i++) {
    const auto& p1 = points[i];
    const auto& p2 = points[j];

    const double p20 = p2[0];
    const double p10 = p1[0];
    const double p11 = p1[1];
    const double p21 = p2[1];

    sum += (p20 - p10) * (p11 + p21);
  }

  // link points into circular doubly-linked list in the specified winding order
  if (clockwise == (sum > 0)) {
    for (i = 0; i < len; i++) last = insertNode(vertices + i, points[i], last);
  } else {
    for (i = len; i-- > 0;) last = insertNode(vertices + i, points[i], last);
  }

  if (last && equals(last, last->next)) {
    removeNode(last);
    last = last->next;
  }

  vertices += len;

  return last;
}

// eliminate colinear or duplicate points
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::filterPoints(Node* start, Node* end) {
  if (!end) end = start;

  Node* p = start;
  bool again;
  do {
    again = false;

    if (!p->steiner && (equals(p, p->next) || area(p->prev, p, p->next) == 0)) {
      removeNode(p);
      p = end = p->prev;

      if (p == p->next) break;
      again = true;

    } else {
      p = p->next;
    }
  } while (again || p != end);

  return end;
}

// main ear slicing loop which triangulates a polygon (given as a linked list)
template <typename N> template <typename Polygon>
void Earcut<N>::earcutLinked(Node* ear, const Polygon& points, int pass) {
  if (!ear) return;

  // interlink polygon nodes in z-order
  if (!pass && hashing) indexCurve(ear);

  Node* stop = ear;
  Node* prev;
  Node* next;

  int iterations = 0;

  // iterate through ears, slicing them one by one
  while (ear->prev != ear->next) {
    iterations++;
    prev = ear->prev;
    next = ear->next;

    if (hashing ? isEarHashed(ear) : isEar(ear)) {

      indices.emplace_back(prev->i);
      indices.emplace_back(ear->i);
      indices.emplace_back(next->i);

      std::vector< double > p_coords = prev->coords;
      std::vector< double > e_coords = ear->coords;
      std::vector< double > n_coords = next->coords;

      for( std::size_t i = 0; i < p_coords.size(); ++i ) {
        xyzcoords.emplace_back( p_coords[i] );
      }

      for( std::size_t i = 0; i < e_coords.size(); ++i ) {
        xyzcoords.emplace_back( e_coords[i] );
      }

      for( std::size_t i = 0; i < n_coords.size(); ++i ) {
        xyzcoords.emplace_back( n_coords[i] );
      }

      removeNode(ear);

      // skipping the next vertice leads to less sliver triangles
      ear = next->next;
      stop = next->next;

      continue;
    }

    ear = next;

    // if we looped through the whole remaining polygon and can't find any more ears
    if (ear == stop) {
      // try filtering points and slicing again
      if (!pass) earcutLinked(filterPoints(ear), points, 1);

      // if this didn't work, try curing all small self-intersections locally
      else if (pass == 1) {
        ear = cureLocalIntersections(filterPoints(ear));
        earcutLinked(ear, points, 2);

        // as a last resort, try splitting the remaining polygon into two
      } else if (pass == 2) splitEarcut(ear, points);

      break;
    }
  }
}

// check whether a polygon node forms a valid ear with adjacent nodes
template <typename N>
bool Earcut<N>::isEar(Node* ear) {
  const Node* a = ear->prev;
  const Node* b = ear;
  const Node* c = ear->next;

  if (area(a, b, c) >= 0) return false; // reflex, can't be an ear

  // now make sure we don't have other points inside the potential ear
  Node* p = ear->next->next;

  while (p != ear->prev) {
    if (pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
        area(p->prev, p, p->next) >= 0) return false;
    p = p->next;
  }

  return true;
}

template <typename N>
bool Earcut<N>::isEarHashed(Node* ear) {
  const Node* a = ear->prev;
  const Node* b = ear;
  const Node* c = ear->next;

  if (area(a, b, c) >= 0) return false; // reflex, can't be an ear

  // triangle bbox; min & max are calculated like this for speed
  const double minTX = std::min<double>(a->x, std::min<double>(b->x, c->x));
  const double minTY = std::min<double>(a->y, std::min<double>(b->y, c->y));
  const double maxTX = std::max<double>(a->x, std::max<double>(b->x, c->x));
  const double maxTY = std::max<double>(a->y, std::max<double>(b->y, c->y));

  // z-order range for the current triangle bbox;
  const int32_t minZ = zOrder(minTX, minTY);
  const int32_t maxZ = zOrder(maxTX, maxTY);

  // first look for points inside the triangle in increasing z-order
  Node* p = ear->nextZ;

  while (p && p->z <= maxZ) {
    if (p != ear->prev && p != ear->next &&
        pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
        area(p->prev, p, p->next) >= 0) return false;
    p = p->nextZ;
  }

  // then look for points in decreasing z-order
  p = ear->prevZ;

  while (p && p->z >= minZ) {
    if (p != ear->prev && p != ear->next &&
        pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
        area(p->prev, p, p->next) >= 0) return false;
    p = p->prevZ;
  }

  return true;
}

// go through all polygon nodes and cure small local self-intersections
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::cureLocalIntersections(Node* start) {
  Node* p = start;
  do {
    Node* a = p->prev;
    Node* b = p->next->next;

    // a self-intersection where edge (v[i-1],v[i]) intersects (v[i+1],v[i+2])
    if (!equals(a, b) && intersects(a, p, p->next, b) && locallyInside(a, b) && locallyInside(b, a)) {
      indices.emplace_back(a->i);
      indices.emplace_back(p->i);
      indices.emplace_back(b->i);

      xyzcoords.emplace_back(a->x);
      xyzcoords.emplace_back(a->y);

      xyzcoords.emplace_back(p->x);
      xyzcoords.emplace_back(p->y);

      xyzcoords.emplace_back(b->x);
      xyzcoords.emplace_back(b->y);

      // remove two nodes involved
      removeNode(p);
      removeNode(p->next);

      p = start = b;
    }
    p = p->next;
  } while (p != start);

  return filterPoints(p);
}

// try splitting polygon into two and triangulate them independently
template <typename N> template <typename Polygon>
void Earcut<N>::splitEarcut(Node* start, const Polygon& points) {
  // look for a valid diagonal that divides the polygon into two
  Node* a = start;
  do {
    Node* b = a->next->next;
    while (b != a->prev) {
      if (a->i != b->i && isValidDiagonal(a, b)) {
        // split the polygon in two by the diagonal
        Node* c = splitPolygon(a, b);

        // filter colinear points around the cuts
        a = filterPoints(a, a->next);
        c = filterPoints(c, c->next);

        // run earcut on each half
        earcutLinked(a, points);
        earcutLinked(c, points);
        return;
      }
      b = b->next;
    }
    a = a->next;
  } while (a != start);
}

// link every hole into the outer loop, producing a single-ring polygon without holes
template <typename N> template <typename Polygon>
typename Earcut<N>::Node*
Earcut<N>::eliminateHoles(const Polygon& points, Node* outerNode) {
  const size_t len = points.size();

  std::vector<Node*> queue;
  for (size_t i = 1; i < len; i++) {
    Node* list = linkedList(points[i], false);
    if (list) {
      if (list == list->next) list->steiner = true;
      queue.push_back(getLeftmost(list));
    }
  }
  std::sort(queue.begin(), queue.end(), [](const Node* a, const Node* b) {
    return a->x < b->x;
  });

  // process holes from left to right
  for (size_t i = 0; i < queue.size(); i++) {
    eliminateHole(queue[i], outerNode);
    outerNode = filterPoints(outerNode, outerNode->next);
  }

  return outerNode;
}

// find a bridge between vertices that connects hole with an outer ring and and link it
template <typename N>
void Earcut<N>::eliminateHole(Node* hole, Node* outerNode) {
  outerNode = findHoleBridge(hole, outerNode);
  if (outerNode) {
    Node* b = splitPolygon(outerNode, hole);

    // filter out colinear points around cuts
    filterPoints(outerNode, outerNode->next);
    filterPoints(b, b->next);
  }
}

// David Eberly's algorithm for finding a bridge between hole and outer polygon
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::findHoleBridge(Node* hole, Node* outerNode) {
  Node* p = outerNode;
  double hx = hole->x;
  double hy = hole->y;
  double qx = -std::numeric_limits<double>::infinity();
  Node* m = nullptr;

  // find a segment intersected by a ray from the hole's leftmost Vertex to the left;
  // segment's endpoint with lesser x will be potential connection Vertex
  do {
    if (hy <= p->y && hy >= p->next->y && p->next->y != p->y) {
      double x = p->x + (hy - p->y) * (p->next->x - p->x) / (p->next->y - p->y);
      if (x <= hx && x > qx) {
        qx = x;
        if (x == hx) {
          if (hy == p->y) return p;
          if (hy == p->next->y) return p->next;
        }
        m = p->x < p->next->x ? p : p->next;
      }
    }
    p = p->next;
  } while (p != outerNode);

  if (!m) return 0;

  if (hx == qx) return m; // hole touches outer segment; pick leftmost endpoint

  // look for points inside the triangle of hole Vertex, segment intersection and endpoint;
  // if there are no points found, we have a valid connection;
  // otherwise choose the Vertex of the minimum angle with the ray as connection Vertex

  const Node* stop = m;
  double tanMin = std::numeric_limits<double>::infinity();
  double tanCur = 0;

  p = m;
  double mx = m->x;
  double my = m->y;

  do {
    if (hx >= p->x && p->x >= mx && hx != p->x &&
        pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p->x, p->y)) {

      tanCur = std::abs(hy - p->y) / (hx - p->x); // tangential

      if (locallyInside(p, hole) &&
          (tanCur < tanMin || (tanCur == tanMin && (p->x > m->x || sectorContainsSector(m, p))))) {
        m = p;
        tanMin = tanCur;
      }
    }

    p = p->next;
  } while (p != stop);

  return m;
}

// whether sector in vertex m contains sector in vertex p in the same coordinates
template <typename N>
bool Earcut<N>::sectorContainsSector(const Node* m, const Node* p) {
  return area(m->prev, m, p->prev) < 0 && area(p->next, m, m->next) < 0;
}

// interlink polygon nodes in z-order
template <typename N>
void Earcut<N>::indexCurve(Node* start) {
  assert(start);
  Node* p = start;

  do {
    p->z = p->z ? p->z : zOrder(p->x, p->y);
    p->prevZ = p->prev;
    p->nextZ = p->next;
    p = p->next;
  } while (p != start);

  p->prevZ->nextZ = nullptr;
  p->prevZ = nullptr;

  sortLinked(p);
}

// Simon Tatham's linked list merge sort algorithm
// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::sortLinked(Node* list) {
  assert(list);
  Node* p;
  Node* q;
  Node* e;
  Node* tail;
  int i, numMerges, pSize, qSize;
  int inSize = 1;

  for (;;) {
    p = list;
    list = nullptr;
    tail = nullptr;
    numMerges = 0;

    while (p) {
      numMerges++;
      q = p;
      pSize = 0;
      for (i = 0; i < inSize; i++) {
        pSize++;
        q = q->nextZ;
        if (!q) break;
      }

      qSize = inSize;

      while (pSize > 0 || (qSize > 0 && q)) {

        if (pSize == 0) {
          e = q;
          q = q->nextZ;
          qSize--;
        } else if (qSize == 0 || !q) {
          e = p;
          p = p->nextZ;
          pSize--;
        } else if (p->z <= q->z) {
          e = p;
          p = p->nextZ;
          pSize--;
        } else {
          e = q;
          q = q->nextZ;
          qSize--;
        }

        if (tail) tail->nextZ = e;
        else list = e;

        e->prevZ = tail;
        tail = e;
      }

      p = q;
    }

    tail->nextZ = nullptr;

    if (numMerges <= 1) return list;

    inSize *= 2;
  }
}

// z-order of a Vertex given coords and size of the data bounding box
template <typename N>
int32_t Earcut<N>::zOrder(const double x_, const double y_) {
  // coords are transformed into non-negative 15-bit integer range
  int32_t x = static_cast<int32_t>(32767.0 * (x_ - minX) * inv_size);
  int32_t y = static_cast<int32_t>(32767.0 * (y_ - minY) * inv_size);

  x = (x | (x << 8)) & 0x00FF00FF;
  x = (x | (x << 4)) & 0x0F0F0F0F;
  x = (x | (x << 2)) & 0x33333333;
  x = (x | (x << 1)) & 0x55555555;

  y = (y | (y << 8)) & 0x00FF00FF;
  y = (y | (y << 4)) & 0x0F0F0F0F;
  y = (y | (y << 2)) & 0x33333333;
  y = (y | (y << 1)) & 0x55555555;

  return x | (y << 1);
}

// find the leftmost node of a polygon ring
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::getLeftmost(Node* start) {
  Node* p = start;
  Node* leftmost = start;
  do {
    if (p->x < leftmost->x || (p->x == leftmost->x && p->y < leftmost->y))
      leftmost = p;
    p = p->next;
  } while (p != start);

  return leftmost;
}

// check if a point lies within a convex triangle
template <typename N>
bool Earcut<N>::pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const {
  return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
    (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
    (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
}

// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
template <typename N>
bool Earcut<N>::isValidDiagonal(Node* a, Node* b) {
  return a->next->i != b->i && a->prev->i != b->i && !intersectsPolygon(a, b) && // dones't intersect other edges
    ((locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
    (area(a->prev, a, b->prev) != 0.0 || area(a, b->prev, b) != 0.0)) || // does not create opposite-facing sectors
    (equals(a, b) && area(a->prev, a, a->next) > 0 && area(b->prev, b, b->next) > 0)); // special zero-length case
}

// signed area of a triangle
template <typename N>
double Earcut<N>::area(const Node* p, const Node* q, const Node* r) const {
  return (q->y - p->y) * (r->x - q->x) - (q->x - p->x) * (r->y - q->y);
}

// check if two points are equal
template <typename N>
bool Earcut<N>::equals(const Node* p1, const Node* p2) {
  return p1->x == p2->x && p1->y == p2->y;
}

// check if two segments intersect
template <typename N>
bool Earcut<N>::intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2) {
  int o1 = sign(area(p1, q1, p2));
  int o2 = sign(area(p1, q1, q2));
  int o3 = sign(area(p2, q2, p1));
  int o4 = sign(area(p2, q2, q1));

  if (o1 != o2 && o3 != o4) return true; // general case

  if (o1 == 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
  if (o2 == 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
  if (o3 == 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
  if (o4 == 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2

  return false;
}

// for collinear points p, q, r, check if point q lies on segment pr
template <typename N>
bool Earcut<N>::onSegment(const Node* p, const Node* q, const Node* r) {
  return q->x <= std::max<double>(p->x, r->x) &&
    q->x >= std::min<double>(p->x, r->x) &&
    q->y <= std::max<double>(p->y, r->y) &&
    q->y >= std::min<double>(p->y, r->y);
}

template <typename N>
int Earcut<N>::sign(double val) {
  return (0.0 < val) - (val < 0.0);
}

// check if a polygon diagonal intersects any polygon segments
template <typename N>
bool Earcut<N>::intersectsPolygon(const Node* a, const Node* b) {
  const Node* p = a;
  do {
    if (p->i != a->i && p->next->i != a->i && p->i != b->i && p->next->i != b->i &&
        intersects(p, p->next, a, b)) return true;
    p = p->next;
  } while (p != a);

  return false;
}

// check if a polygon diagonal is locally inside the polygon
template <typename N>
bool Earcut<N>::locallyInside(const Node* a, const Node* b) {
  return area(a->prev, a, a->next) < 0 ?
  area(a, b, a->next) >= 0 && area(a, a->prev, b) >= 0 :
  area(a, b, a->prev) < 0 || area(a, a->next, b) < 0;
}

// check if the middle Vertex of a polygon diagonal is inside the polygon
template <typename N>
bool Earcut<N>::middleInside(const Node* a, const Node* b) {
  const Node* p = a;
  bool inside = false;
  double px = (a->x + b->x) / 2;
  double py = (a->y + b->y) / 2;
  do {
    if (((p->y > py) != (p->next->y > py)) && p->next->y != p->y &&
        (px < (p->next->x - p->x) * (py - p->y) / (p->next->y - p->y) + p->x))
      inside = !inside;
    p = p->next;
  } while (p != a);

  return inside;
}

// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits
// polygon into two; if one belongs to the outer ring and another to a hole, it merges it into a
// single ring
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::splitPolygon(Node* a, Node* b) {
  // Node* a2 = nodes.construct(a->i, a->x, a->y);
  // Node* b2 = nodes.construct(b->i, b->x, b->y);

  Node* a2 = nodes.construct(a->i, a->coords);
  Node* b2 = nodes.construct(b->i, b->coords);

  Node* an = a->next;
  Node* bp = b->prev;

  a->next = b;
  b->prev = a;

  a2->next = an;
  an->prev = a2;

  b2->next = a2;
  a2->prev = b2;

  bp->next = b2;
  b2->prev = bp;

  return b2;
}

// create a node and util::optionally link it with previous one (in a circular doubly linked list)
template <typename N> template <typename Point>
typename Earcut<N>::Node*
Earcut<N>::insertNode(std::size_t i, const Point& pt, Node* last) {
  //Node* p = nodes.construct(static_cast<N>(i), util::nth<0, Point>::get(pt), util::nth<1, Point>::get(pt));
  //Node* p = nodes.construct( static_cast<N>(i), pt[0], pt[1] );
  Node* p = nodes.construct( static_cast<N>(i), pt );

  if (!last) {
    p->prev = p;
    p->next = p;

  } else {
    assert(last);
    p->next = last->next;
    p->prev = last;
    last->next->prev = p;
    last->next = p;
  }
  return p;
}

template <typename N>
void Earcut<N>::removeNode(Node* p) {
  p->next->prev = p->prev;
  p->prev->next = p->next;

  if (p->prevZ) p->prevZ->nextZ = p->nextZ;
  if (p->nextZ) p->nextZ->prevZ = p->prevZ;
}
}

// #nocov end

template <typename N = uint32_t, typename Polygon>
SEXP earcut(const Polygon& poly) {
  earcut::detail::Earcut<N> earcut;
  earcut(poly);

  std::vector< double > coords = std::move( earcut.xyzcoords );
  std::vector< N > indices = std::move( earcut.indices );

  if( coords.size() == 0 ) {
    Rcpp::stop("interleave - there is an issue with earcutting this polygon, perhaps it isn't closed?");
  }

  //return Rcpp::wrap( coords );
  std::size_t stride = std::move( earcut.stride );

  return Rcpp::List::create(
    Rcpp::_["coordinates"] = Rcpp::wrap( coords ),
    Rcpp::_["indices"] = Rcpp::wrap( indices ),
    Rcpp::_["stride"] = stride
  );

}

}  // earcut
