#include <memory>

#include <pybind11/pybind11.h>
#include <pybind11/eigen.h>
#include <pybind11/stl.h>

#include <Mesh.h>
#include <MeshUtils/AttributeUtils.h>
#include <MeshUtils/ObtuseTriangleRemoval.h>
#include <MeshUtils/ShortEdgeRemoval.h>
#include <MeshUtils/MeshUtils.h>
#include <MeshUtils/MeshSeparator.h>
#include <MeshUtils/MeshChecker.h>
#include <MeshUtils/Boundary.h>
#include <MeshUtils/PointLocator.h>
#include <MeshUtils/Subdivision.h>
#include <MeshUtils/DuplicatedVertexRemoval.h>
#include <MeshUtils/IsolatedVertexRemoval.h>
#include <MeshUtils/LongEdgeRemoval.h>
#include <MeshUtils/FinFaceRemoval.h>
#include <MeshUtils/DegeneratedTriangleRemoval.h>
#include <MeshUtils/FaceUtils.h>

namespace py = pybind11;
using namespace PyMesh;
using namespace pybind11::literals;

void init_MeshUtils(py::module& m) {
    m.def("convert_to_vertex_attribute",
            &AttributeUtils::convert_to_vertex_attribute);
    m.def("convert_to_vertex_attribute_from_name",
            &AttributeUtils::convert_to_vertex_attribute_from_name);
    m.def("convert_to_face_attribute",
            &AttributeUtils::convert_to_face_attribute);
    m.def("convert_to_face_attribute_from_name",
            &AttributeUtils::convert_to_face_attribute_from_name);
    m.def("convert_to_voxel_attribute",
            &AttributeUtils::convert_to_voxel_attribute);
    m.def("convert_to_voxel_attribute_from_name",
            &AttributeUtils::convert_to_voxel_attribute_from_name);
    m.def("extract_exterior_faces",
            &MeshUtils::extract_exterior_faces);
    m.def("is_colinear_2D", &FaceUtils::is_colinear_2D);
    m.def("is_colinear_3D", &FaceUtils::is_colinear_3D);
    m.def("get_degenerated_faces", &FaceUtils::get_degenerated_faces);

    py::class_<ObtuseTriangleRemoval>(m, "ObtuseTriangleRemoval")
        .def(py::init<MatrixFr&, MatrixIr&>())
        .def("run", &ObtuseTriangleRemoval::run)
        .def("get_vertices", &ObtuseTriangleRemoval::get_vertices)
        .def("get_faces", &ObtuseTriangleRemoval::get_faces);

    py::class_<ShortEdgeRemoval>(m, "ShortEdgeRemoval")
        .def(py::init<const MatrixFr&, const MatrixIr&>())
        .def("set_importance", &ShortEdgeRemoval::set_importance)
        .def("run", &ShortEdgeRemoval::run)
        .def("get_vertices", &ShortEdgeRemoval::get_vertices)
        .def("get_faces", &ShortEdgeRemoval::get_faces)
        .def("get_face_indices", &ShortEdgeRemoval::get_face_indices);

    py::class_<MeshSeparator> separator(m, "MeshSeparator");
    separator.def(py::init<const MatrixI&>())
        .def("set_connectivity_type", &MeshSeparator::set_connectivity_type)
        .def("separate", &MeshSeparator::separate)
        .def("get_component", &MeshSeparator::get_component)
        .def("get_sources", &MeshSeparator::get_sources)
        .def("clear", &MeshSeparator::clear);

    py::enum_<MeshSeparator::ConnectivityType>(separator, "ConnectivityType")
        .value("VERTEX", MeshSeparator::ConnectivityType::VERTEX)
        .value("FACE", MeshSeparator::ConnectivityType::FACE)
        .value("VOXEL", MeshSeparator::ConnectivityType::VOXEL)
        .export_values();

    py::class_<MeshChecker>(m, "MeshChecker")
        .def(py::init<const MatrixFr&, const MatrixIr&, const MatrixIr&>())
        .def("is_vertex_manifold", &MeshChecker::is_vertex_manifold)
        .def("is_edge_manifold", &MeshChecker::is_edge_manifold)
        .def("is_closed", &MeshChecker::is_closed)
        .def("has_edge_with_odd_adj_faces",
                &MeshChecker::has_edge_with_odd_adj_faces)
        .def("is_oriented", &MeshChecker::is_oriented)
        .def("has_complex_boundary", &MeshChecker::has_complex_boundary)
        .def("get_num_boundary_edges", &MeshChecker::get_num_boundary_edges)
        .def("get_num_boundary_loops", &MeshChecker::get_num_boundary_loops)
        .def("get_boundary_edges", &MeshChecker::get_boundary_edges)
        .def("get_boundary_loops", &MeshChecker::get_boundary_loops)
        .def("get_genus", &MeshChecker::get_genus)
        .def("get_euler_characteristic",
                &MeshChecker::get_euler_characteristic)
        .def("get_num_connected_components",
                &MeshChecker::get_num_connected_components)
        .def("get_num_connected_surface_components",
                &MeshChecker::get_num_connected_surface_components)
        .def("get_num_connected_volume_components",
                &MeshChecker::get_num_connected_volume_components)
        .def("get_num_isolated_vertices",
                &MeshChecker::get_num_isolated_vertices)
        .def("get_num_duplicated_faces",
                &MeshChecker::get_num_duplicated_faces)
        .def("compute_signed_volume_from_surface",
                &MeshChecker::compute_signed_volume_from_surface);

    py::class_<PointLocator>(m, "PointLocator")
        .def(py::init<Mesh::Ptr>())
        .def("locate", &PointLocator::locate)
        .def("get_enclosing_voxels", &PointLocator::get_enclosing_voxels)
        .def("get_barycentric_coords", &PointLocator::get_barycentric_coords)
        .def("clear", &PointLocator::clear);

    py::class_<Subdivision, std::shared_ptr<Subdivision> >(m, "Subdivision")
        .def_static("create", &Subdivision::create)
        .def("subdivide", &Subdivision::subdivide)
        .def("get_subdivision_matrices()",
                &Subdivision::get_subdivision_matrices)
        .def("get_vertices", &Subdivision::get_vertices)
        .def("get_faces", &Subdivision::get_faces)
        .def("get_face_indices", &Subdivision::get_face_indices)
        .def("get_num_vertices", &Subdivision::get_num_vertices)
        .def("get_num_faces", &Subdivision::get_num_faces);

    py::class_<DuplicatedVertexRemoval>(m, "DuplicatedVertexRemoval")
        .def(py::init<const MatrixFr&, const MatrixIr&>())
        .def("run", &DuplicatedVertexRemoval::run)
        .def("get_vertices", &DuplicatedVertexRemoval::get_vertices)
        .def("get_faces", &DuplicatedVertexRemoval::get_faces)
        .def("set_importance_level",
                &DuplicatedVertexRemoval::set_importance_level)
        .def("get_index_map", &DuplicatedVertexRemoval::get_index_map);

    py::class_<IsolatedVertexRemoval>(m, "IsolatedVertexRemoval")
        .def(py::init<const MatrixFr&, const MatrixIr&>())
        .def("run", &IsolatedVertexRemoval::run)
        .def("get_vertices", &IsolatedVertexRemoval::get_vertices)
        .def("get_faces", &IsolatedVertexRemoval::get_faces)
        .def("get_ori_vertex_indices",
                &IsolatedVertexRemoval::get_ori_vertex_indices);

    py::class_<LongEdgeRemoval>(m, "LongEdgeRemoval")
        .def(py::init<const MatrixFr&, const MatrixIr&>())
        .def("run", &LongEdgeRemoval::run, "max_length"_a, "recursive"_a=true)
        .def("get_vertices", &LongEdgeRemoval::get_vertices)
        .def("get_faces", &LongEdgeRemoval::get_faces);

    py::class_<FinFaceRemoval>(m, "FinFaceRemoval")
        .def(py::init<const MatrixFr&, const MatrixIr&>())
        .def("set_fins_only", &FinFaceRemoval::set_fins_only)
        .def("run", &FinFaceRemoval::run)
        .def("get_vertices", &FinFaceRemoval::get_vertices)
        .def("get_faces", &FinFaceRemoval::get_faces)
        .def("get_face_indices", &FinFaceRemoval::get_face_indices);

    py::class_<DegeneratedTriangleRemoval>(m, "DegeneratedTriangleRemoval")
        .def(py::init<const MatrixFr&, const MatrixIr&>())
        .def("run", &DegeneratedTriangleRemoval::run)
        .def("get_vertices", &DegeneratedTriangleRemoval::get_vertices)
        .def("get_faces", &DegeneratedTriangleRemoval::get_faces)
        .def("get_ori_face_indices",
                &DegeneratedTriangleRemoval::get_ori_face_indices);

}