#ifndef EDGEMESH_HPP
#define EDGEMESH_HPP
#include "beam.hpp"
#include "polymesh.hpp"
#include "utilities.hpp"
#include "vcgtrimesh.hpp"
#include <vcg/complex/complex.h>
#include <vector>
#include <wrap/io_trimesh/import.h>
#include <wrap/nanoply/include/nanoplyWrapper.hpp>

using EdgeIndex = size_t;

class VCGEdgeMeshEdgeType;
class VCGEdgeMeshVertexType;

struct VCGEdgeMeshUsedTypes
    : public vcg::UsedTypes<vcg::Use<VCGEdgeMeshVertexType>::AsVertexType,
                            vcg::Use<VCGEdgeMeshEdgeType>::AsEdgeType> {};

class VCGEdgeMeshVertexType
    : public vcg::Vertex<VCGEdgeMeshUsedTypes, vcg::vertex::Coord3d,
                         vcg::vertex::Normal3d, vcg::vertex::BitFlags,
                         vcg::vertex::VEAdj> {};
class VCGEdgeMeshEdgeType
    : public vcg::Edge<VCGEdgeMeshUsedTypes, vcg::edge::VertexRef,
                       vcg::edge::BitFlags, vcg::edge::EEAdj,
                       vcg::edge::VEAdj> {};

class VCGEdgeMesh : public vcg::tri::TriMesh<std::vector<VCGEdgeMeshVertexType>,
                                             std::vector<VCGEdgeMeshEdgeType>> {
  const std::string plyPropertyBeamDimensionsID{"beam_dimensions"};
  const std::string plyPropertyBeamMaterialID{"beam_material"};
  VCGEdgeMesh::PerEdgeAttributeHandle<CylindricalElementDimensions>
      handleBeamDimensions;
  VCGEdgeMesh::PerEdgeAttributeHandle<ElementMaterial> handleBeamMaterial;

protected:
  Eigen::MatrixX2i eigenEdges;
  Eigen::MatrixX3d eigenVertices;
  Eigen::MatrixX3d eigenEdgeNormals;
  std::string label{"No_name"};

  void getEdges(Eigen::MatrixX2i &edges);
  void getVertices(Eigen::MatrixX3d &vertices);

public:
  VCGEdgeMesh();
  template <typename MeshElement>
  size_t getIndex(const MeshElement &meshElement) {
    return vcg::tri::Index<VCGEdgeMesh>(*this, meshElement);
  }
  void updateEigenEdgeAndVertices();
  void copy(VCGEdgeMesh &mesh);

  void getEdges(Eigen::MatrixX3d &edgeStartingPoints,
                Eigen::MatrixX3d &edgeEndingPoints) const;

  Eigen::MatrixX3d getNormals() const;

  bool loadUsingDefaultLoader(const std::string &plyFilename);
  bool hasProperty(const std::vector<nanoply::PlyProperty> &v,
                   const std::string &propertyName);

  bool
  hasPlyEdgeProperty(const std::string &plyFilename,
                     const std::vector<nanoply::PlyProperty> &edgeProperties,
                     const std::string &plyEdgePropertyName);

  bool plyFileHasAllRequiredFields(const std::string &plyFilename);

  bool loadUsingNanoply(const std::string &plyFilename);

  bool loadFromPly(const std::string plyFilename);

  bool savePly(const std::string plyFilename);

  bool createGrid(const size_t squareGridDimension);
  bool createGrid(const size_t desiredWidth, const size_t desiredHeight);
  void createSpiral(const float &degreesOfArm, const size_t &numberOfSamples);

  Eigen::MatrixX2i getEigenEdges() const;
  Eigen::MatrixX3d getEigenVertices() const;
  Eigen::MatrixX3d getEigenEdgeNormals() const;
  std::vector<CylindricalElementDimensions> getBeamDimensions() const;
  std::vector<ElementMaterial> getBeamMaterial() const;
  void printVertexCoordinates(const size_t &vi) const;
  void registerForDrawing() const;

  std::string getLabel() const;
  void setLabel(const std::string &value);

private:
  void GeneratedRegularSquaredPattern(
      const double angleDeg, std::vector<std::vector<vcg::Point2d>> &pattern,
      const size_t &desiredNumberOfSamples);
};

using VectorType = VCGEdgeMesh::CoordType;
using CoordType = VCGEdgeMesh::CoordType;
using VertexPointer = VCGEdgeMesh::VertexPointer;
using EdgePointer = VCGEdgeMesh::EdgePointer;
using ConstVCGEdgeMesh = VCGEdgeMesh;

#endif // EDGEMESH_HPP