#include <solve.h>

#include <implicit_surface_network_solver.hpp>

EXTERN_C_BEGIN

API implicit_network_solver* create_solver(const baked_blobtree_t* tree, const s_settings settings) noexcept
{
    void* res = mi_malloc(sizeof(implicit_network_solver));
    ::new (res) implicit_network_solver(tree, settings);
    return (implicit_network_solver*)res;
}

API void destroy_solver(implicit_network_solver* solver) noexcept
{
    if (solver == nullptr) return;
    solver->~implicit_network_solver();
    mi_free(solver);
}

API primitive_generation_result_t generate_polymesh(implicit_network_solver* solver)
{
    primitive_generation_result_t result{};
    if (solver == nullptr) return result;

    // generate polymesh
    stl_vector_mp<Eigen::Vector3d> output_vertices{};
    stl_vector_mp<uint32_t>        output_polygon_faces{};
    stl_vector_mp<uint32_t>        output_vertex_counts_of_face{};
    solver->generate_polymesh(output_vertices, output_polygon_faces, output_vertex_counts_of_face);
    result.mesh.num_vertices = static_cast<uint32_t>(output_vertices.size());
    result.mesh.num_faces    = static_cast<uint32_t>(output_vertex_counts_of_face.size());
    vector3d* vertices       = (vector3d*)mi_malloc(sizeof(vector3d) * result.mesh.num_vertices);
    uint32_t* faces          = (uint32_t*)mi_malloc(sizeof(uint32_t) * result.mesh.num_faces);
    uint32_t* vertex_counts  = (uint32_t*)mi_malloc(sizeof(uint32_t) * result.mesh.num_faces);
    for (uint32_t i = 0; i < result.mesh.num_vertices; i++) {
        std::move(output_vertices[i].data(), output_vertices[i].data() + 3, &vertices[i].x);
    }
    std::move(output_polygon_faces.begin(), output_polygon_faces.end(), faces);
    std::move(output_vertex_counts_of_face.begin(), output_vertex_counts_of_face.end(), vertex_counts);

    result.mesh.vertices      = vertices;
    result.mesh.faces         = faces;
    result.mesh.vertex_counts = vertex_counts;
    // check success
    result.success            = (result.mesh.num_vertices > 0 && result.mesh.num_faces > 0);
    return result;
}

API void print_statistics(const implicit_network_solver* solver)
{
    if (solver == nullptr) return;
    solver->m_timers.print();
}

API void clear_statistics(implicit_network_solver* solver)
{
    if (solver == nullptr) return;
    solver->m_timers.clear();
}

EXTERN_C_END