#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<Primitive>> 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<uvector<int, 3>> indixes  = {
        uvector<int, 3>(2, 1, 0),
        uvector<int, 3>(1, 2, 3),
        uvector<int, 3>(0, 1, 4),
        uvector<int, 3>(4, 1, 5),
        uvector<int, 3>(6, 2, 0),
        uvector<int, 3>(6, 0, 4),
        uvector<int, 3>(0, 3, 2),
        uvector<int, 3>(0, 2, 6),
        uvector<int, 3>(1, 3, 7),
        uvector<int, 3>(1, 7, 5),
        uvector<int, 3>(5, 7, 6),
        uvector<int, 3>(4, 5, 6),
    };

    // ps.emplace_back(std::make_shared<PowerTensorComplex>(makeMesh(vertices, indixes)));
    // ps.emplace_back(std::make_shared<PowerTensor>(makeSphere(0.2)));
    auto phi0 = std::make_shared<PowerTensorComplex>(makeMesh(vertices, indixes));
    phi0->add(*std::make_shared<PowerTensor>(makeSphere(0.2)));
    auto basicTask = BasicTask(phi0);
}

void case1()
{
    auto phi0      = std::make_shared<PowerTensor>(makeSphere(0.2));
    auto basicTask = BasicTask(phi0);
}

void testPrimitive() { case1(); }