#include <iostream>
#include <array>
#include <vector>
#include "io_primitive.h"
#include "math/math_defs.hpp"
#include "mimalloc.h"
#include "primitive_descriptor.h"

#include <solve.h>

int main()
{
    helixline_axis_descriptor_t axis_desc{};
    axis_desc.axis_start        = {0, 0, 0};
    axis_desc.axis_end          = {0, 0, 13};
    axis_desc.is_righthanded    = true;
    axis_desc.radius            = 1.;
    axis_desc.advance_per_round = 1;
    axis_desc.start_direction   = {1, 0, 0};

    // polyline_axis_descriptor_t axis_desc{};
    // std::vector                points_{
    //     vector3d{0, 0, 0},
    //     vector3d{0, 1, 1}
    // };
    // axis_desc.point_number = 2;
    // axis_desc.points       = points_.data();
    // std::vector bulges_{std::tan(pi / 8)};
    // axis_desc.bulge_number     = 1;
    // axis_desc.bulges           = bulges_.data();
    // axis_desc.reference_normal = {1, 0, 0};
    // axis_desc.is_closed        = false;

    polyline_pattern_descriptor_t pattern_desc{};
    pattern_desc.anchor = {0, 0};
    std::vector points{
        vector2d{-.1, 0},
        vector2d{.1,  0},
        vector2d{-.1, 0}
    };
    pattern_desc.point_number = 3;
    pattern_desc.points       = points.data();
    std::vector bulges{1., 1.};
    pattern_desc.bulge_number = 2;
    pattern_desc.bulges       = bulges.data();

    auto primitive_data_center = create_primitive_data_center();
    auto pattern               = create_pattern(primitive_data_center, &pattern_desc, PATTERN_TYPE_POLYLINE);
    auto axis                  = create_extrude_axis(primitive_data_center, &axis_desc, AXIS_TYPE_EXTRUDE_HELIXLINE);
    auto extrude               = create_param_primitive(&axis, &pattern, primitive_data_center, PRIMITIVE_TYPE_EXTRUDE);
    std::cout << "primitive created..." << std::endl;

    auto runtime_blobtree = create_blobtree();
    auto node_iter1       = blobtree_add_primitive_node(runtime_blobtree, extrude);
    auto baked_blobtree   = bake_blobtree(runtime_blobtree);
    destroy_blobtree(runtime_blobtree);

    std::cout << "blobtree created..." << std::endl;

    s_settings settings{};
    settings.resolution                         = 32;
    settings.scene_aabb_margin                  = 1e-5;
    settings.restricted_primitive_bounding_test = true;
    settings.integrand_density                  = 32;
    auto solver                                 = create_solver(baked_blobtree, settings);

    auto result = generate_polymesh(solver);
    // auto integrator = generate_integral_scheme(solver);
    print_statistics(solver);

    // integrand_handle_t handle{1., 0, 0, 0};
    // std::cout << "surface area: " << calculate_surface_integrand(integrator, handle) << std::endl;
    // std::cout << "volume: " << calculate_volume_integrand(integrator, handle) << std::endl;
    // std::cout << "baseline (by polymesh): \n";
    // auto baseline_integral = polymesh_area_and_volume(solver);
    // std::cout << "surface area: " << baseline_integral.area << std::endl;
    // std::cout << "volume: " << baseline_integral.volume << std::endl;

    destroy_solver(solver);
    destroy_baked_blobtree(baked_blobtree);
    destroy_primitive(extrude);
    destroy_primitive_data_center(primitive_data_center);

    return 0;
}