#ifndef FLATPATTERNGEOMETRY_HPP
#define FLATPATTERNGEOMETRY_HPP
#include "edgemesh.hpp"
#include <string>
#include <unordered_map>
#include <unordered_set>

class FlatPatternGeometry : public VCGEdgeMesh {
private:
  size_t
  computeTiledValence(const size_t &nodeIndex,
                      const std::vector<size_t> &numberOfNodesPerSlot) const;
  size_t getNodeValence(const size_t &nodeIndex) const;
  size_t getNodeSlot(const size_t &nodeIndex) const;

  const size_t fanSize{6};
  std::vector<VCGEdgeMesh::CoordType> vertices;
  const double triangleEdgeSize{1}; // radius edge
  std::unordered_map<size_t, size_t> nodeSlot;
  std::unordered_map<size_t, size_t> correspondingNode;
  std::unordered_map<size_t, size_t> nodeTiledValence;

  void
  constructCorresponginNodeMap(const std::vector<size_t> &numberOfNodesPerSlot);

  void constructNodeToTiledValenceMap(
      const std::vector<size_t> &numberOfNodesPerSlot);

public:
  FlatPatternGeometry();
  /*The following function should be a copy constructor with
   * a const argument but this is impossible due to the
   * vcglib interface.
   * */
  FlatPatternGeometry(FlatPatternGeometry &other);
  bool savePly(const std::string plyFilename);
  void add(const std::vector<vcg::Point3d> &vertices);
  void add(const std::vector<vcg::Point2i> &edges);
  void add(const std::vector<vcg::Point3d> &vertices,
           const std::vector<vcg::Point2i> &edges);
  void add(const std::vector<size_t> &numberOfNodesPerSlot,
           const std::vector<vcg::Point2i> &edges);
  static std::vector<vcg::Point3d>
  constructVertexVector(const std::vector<size_t> &numberOfNodesPerSlot,
                        const size_t &fanSize, const double &triangleEdgeSize);
  bool hasDanglingEdges(const std::vector<size_t> &numberOfNodesPerSlot);
  std::vector<vcg::Point3d> getVertices() const;
  static FlatPatternGeometry createFan(FlatPatternGeometry &pattern);
  static FlatPatternGeometry createTile(FlatPatternGeometry &pattern);
  double getTriangleEdgeSize() const;
  bool hasUntiledDanglingEdges();
  std::unordered_map<size_t, std::unordered_set<size_t>>
  getIntersectingEdges(size_t &numberOfIntersectingEdgePairs) const;

  static size_t binomialCoefficient(size_t n, size_t m) {
    assert(n >= m);
    return tgamma(n + 1) / (tgamma(m + 1) * tgamma(n - m + 1));
  }
  bool isFullyConnectedWhenTiled();

  bool hasIntersectingEdges(
      const std::string &patternBinaryRepresentation,
      const std::unordered_map<size_t, std::unordered_set<size_t>>
          &intersectingEdges);
  bool isPatternValid();
  size_t getFanSize() const;
};
#endif // FLATPATTERNGEOMETRY_HPP