#ifndef EDGEMESH_HPP
#define EDGEMESH_HPP
#include "beam.hpp"
#include "mesh.hpp"
#include "utilities.hpp"
#include <array>
#include <optional>
#include <vcg/complex/complex.h>
#include <vector>

#ifdef POLYSCOPE_DEFINED
#include <polyscope/curve_network.h>
#endif

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::Color4b, 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>>,
      public Mesh
{
protected:
    Eigen::MatrixX2i eigenEdges;
    Eigen::MatrixX3d eigenVertices;
    Eigen::MatrixX3d eigenEdgeNormals;

    void computeEdges(Eigen::MatrixX2i &edges);
    void computeVertices(Eigen::MatrixX3d &vertices);

public:
    VCGEdgeMesh();
    template<typename MeshElement>
    size_t getIndex(const MeshElement &meshElement)
    {
        return vcg::tri::Index<VCGEdgeMesh>(*this, meshElement);
    }
    void updateEigenEdgeAndVertices();
    /*
             * The copy function shold be a virtual function of the base interface Mesh class.
             * https://stackoverflow.com/questions/2354210/can-a-class-member-function-template-be-virtual
             * use type erasure (?)
             * */
    bool copy(VCGEdgeMesh &mesh);

    void set(const std::vector<double> &vertexPositions, const std::vector<int> &edges);

    void removeDuplicateVertices();
    virtual void deleteDanglingVertices();
    virtual void deleteDanglingVertices(
        vcg::tri::Allocator<VCGEdgeMesh>::PointerUpdater<VertexPointer> &pu);

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

    Eigen::MatrixX3d getNormals() const;

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

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

    bool load(const std::filesystem::path &meshFilePath) override;
    bool save(const std::filesystem::path &meshFilePath = std::filesystem::path()) override;

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

    Eigen::MatrixX2i getEigenEdges() const;
    std::vector<vcg::Point2i> computeEdges();

    Eigen::MatrixX3d getEigenVertices() const;
    Eigen::MatrixX3d getEigenEdgeNormals() const;
    void printVertexCoordinates(const size_t &vi) const;
#ifdef POLYSCOPE_DEFINED
    polyscope::CurveNetwork *registerForDrawing(
        const std::optional<std::array<double, 3>> &desiredColor = std::nullopt,
        const double &desiredRadius = 0.001,
        const bool &shouldEnable = true);
    void unregister() const;
    void drawInitialFrames(polyscope::CurveNetwork *polyscopeHandle_initialMesh) const;
#endif
    void removeDuplicateVertices(
        vcg::tri::Allocator<VCGEdgeMesh>::PointerUpdater<VertexPointer> &pu_vertices,
        vcg::tri::Allocator<VCGEdgeMesh>::PointerUpdater<EdgePointer> &pu_edges);

    void centerMesh()
    {
        CoordType centerOfMass(0, 0, 0);

        for (const auto &v : vert) {
            centerOfMass = centerOfMass + v.cP();
        }
        centerOfMass = centerOfMass / VN();
        for (auto &v : vert) {
            v.P() = v.cP() - centerOfMass;
        }
    }

    void markVertices(const std::vector<size_t> &vertsToMark);

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

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

#endif // EDGEMESH_HPP