#include <pw/core/matrix_transform.hpp>
#include <pw/core/serialize.hpp>
#include <pw/core/vector.hpp>
// #include <pw/core/geometry.hpp>
#include <pw/core/axisangle.hpp>

#include <variant>
#include <vector>
#include <print>

namespace pw {
struct geometry_n {
    std::vector<vector<float, 3>> vertices{};
    std::vector<std::size_t> indices{};
};

struct mesh_n {

    geometry_n geometry{};


};

} // namespace pw

auto main() -> int {

    auto geom = pw::geometry_n{.vertices = {{1.2f, 2.4f, 4.8f},
                                            {2.4f, 1.2f, 4.8f},
                                            {1.2f, 4.8f, 2.4f}},
                               .indices  = {0, 1, 2}};

    for (auto i : geom.indices) {
        std::print("({}) ",pw::serialize::to_string(geom.vertices[i]));
    }



    // pw::geometry geo;

    // pw::vector3_array vs = {
    //     { -1, 1, 0 },
    //     { -1,-1, 0 },
    //     {  1,-1, 0 },
    //     {  1, 1, 0 }
    // };

    // pw::geometry::indices_t idx = {
    //     0, 1, 2,
    //     0, 2, 3
    // };

    // geo.set_vertices(vs);
    // geo.set_indices(idx);

    // geo.compute_normals();

    //    amesh.set_vertices(vs);

    //    for (auto v : amesh.vertices()) {
    //        std::cout << pw::serialize::matrix(v.transposed()) << std::endl;
    //    }

    //    auto scale = pw::matrix_transform<float>::scale_matrix({2,2,2});

    //    amesh.transform(scale);

    //    std::cout << "after scale" << std::endl;

    //    for (auto v : amesh.vertices()) {
    //        std::cout << pw::serialize::matrix(v.transposed()) << std::endl;
    //    }

    //    pw::axisangle aa;

    //    aa.axis = pw::vector3({ 0, 0, 1 });
    //    aa.angle = pw::deg_to_rad(90.0f);

    //    auto rot_mat = aa.to_matrix();

    //    amesh.transform(rot_mat);

    //    std::cout << "after rotate" << std::endl;

    //    for (auto v : amesh.vertices()) {
    //        std::cout << pw::serialize::matrix(v.transposed()) << std::endl;
    //    }
}
