#include <array>
#include <bitset>
#include <iostream>
#include <booluarray.hpp>


#include <cstddef>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include "bernstein.hpp"
#include "multiloop.hpp"
#include "quadrature_multipoly.hpp"
#include "binomial.hpp"

#include "real.hpp"
#include "uvector.hpp"
#include "vector"
#include "xarray.hpp"
#include <chrono>
#include <memory>

#include "organizer/primitive.hpp"
#include "organizer/organizer.hpp"


using namespace algoim::Organizer;
using namespace algoim;

void case0()
{
    // std::vector<std::shared_ptr<PrimitiveDesc>> ps;

    // mesh
    std::vector<uvector3> vertices = {uvector3(-0.8, -0.8, -0.8),
                                      uvector3(-0.8, -0.8, 0.8),
                                      uvector3(-0.8, 0.8, -0.8),
                                      uvector3(-0.8, 0.8, 0.8),
                                      uvector3(0.8, -0.8, -0.8),
                                      uvector3(0.8, -0.8, 0.8),
                                      uvector3(0.8, 0.8, -0.8),
                                      uvector3(0.8, 0.8, 0.8)

    };
    std::vector<int>      indices  = {2, 3, 1, 0, // force break here
                                      4, 0, 1, 5, //
                                      4, 6, 2, 0, //
                                      6, 7, 3, 2, //
                                      7, 6, 4, 5, //
                                      3, 7, 5, 1};
    std::vector<int>      scan     = {4, 8, 12, 16, 20, 24};

    // ps.emplace_back(std::make_shared<PowerTensorComplex>(makeMesh(vertices, indixes)));
    // ps.emplace_back(std::make_shared<PowerTensor>(makeSphere(0.2)));
    // ps.emplace_back(std::make_shared<MeshDesc>(MeshDesc(vertices, indices, scan)));
    // auto basicTask = BasicTask(ps);
}

void case1()
{
    auto phi0      = std::make_shared<SphereDesc>(SphereDesc(0.8, 0., 1.));
    // SphereDesc sphere(0.8, 0., 1.);
    auto basicTask = BasicTask(phi0);
}

void testPrimitive() { case1(); }