#include <trueform/vtk/core.hpp>

// Create new polydata
auto mesh = vtkSmartPointer<tf::vtk::polydata>::New();

// Wrap existing vtkPolyData (zero-copy)
mesh->ShallowCopy(reader->GetOutput());

// Detect in VTK pipelines
if (auto* tf_poly = tf::vtk::polydata::SafeDownCast(input)) {
    // Use cached structures
}

// Retrieve from filter input (creates if needed)
auto* poly = tf::vtk::polydata::GetData(inputVector, 0);

for (auto pt : mesh->points()) {
    auto [x, y, z] = pt;
}

for (auto face : mesh->polys()) {
    for (auto vertex_id : face) { /* ... */ }
}

for (auto polygon : mesh->polygons()) {
    for (auto pt : polygon) { /* point_view */ }
    for (auto id : polygon.indices()) { /* vertex index */ }
}

for (auto path : mesh->paths()) {
    for (auto vertex_id : path) { /* ... */ }
}

for (auto curve : mesh->curves()) {
    for (auto pt : curve) { /* point_view */ }
    for (auto id : curve.indices()) { /* vertex index */ }
}

for (auto edge : mesh->edges()) {
    auto [v0, v1] = edge;
}

for (auto segment : mesh->segments()) {
    auto [pt0, pt1] = segment;
}

auto pn = mesh->point_normals();
if (pn.size() > 0) {
    for (auto normal : pn) { /* unit_vector_view */ }
}

auto cn = mesh->cell_normals();

const auto& poly_tree = mesh->poly_tree();      // polygon bounding boxes
const auto& seg_tree = mesh->segment_tree();    // line segment bounding boxes
const auto& pt_tree = mesh->point_tree();       // point bounding boxes

const auto& fm = mesh->face_membership();
const auto& mel = mesh->manifold_edge_link();
const auto& fl = mesh->face_link();
const auto& vl = mesh->vertex_link();

const auto& edges = mesh->edges_buffer();  // tf::blocked_buffer<vtkIdType, 2>

// Points from vtkPolyData
auto points = tf::vtk::make_points(polydata);

// Polygons (dynamic size - handles mixed tri/quad/n-gon)
auto polygons = tf::vtk::make_polygons(polydata);

// Triangles only (compile-time size)
auto triangles = tf::vtk::make_polygons<3>(polydata);

// Curves from line data
auto curves = tf::vtk::make_curves(polydata);

auto point_normals = tf::vtk::make_point_normals(polydata);
auto cell_normals = tf::vtk::make_cell_normals(polydata);
// Returns empty view if no normals present

// Flat range over array data
auto scalars = tf::vtk::make_range(floatArray);

// Blocked access (e.g., RGB tuples)
auto colors = tf::vtk::make_blocked_range<3>(colorArray);

// Dynamic block size
auto tuples = tf::vtk::make_blocked_range(array, tuple_size);

// Raw byte access per tuple
auto bytes = tf::vtk::make_byte_blocks(dataArray);

// From polygons buffer (move for zero-copy)
tf::polygons_buffer<vtkIdType, float, 3, tf::dynamic_size> result;
// ... fill result ...
auto polydata = tf::vtk::make_vtk_polydata(std::move(result));

// From curves buffer
tf::curves_buffer<vtkIdType, float, 3> curves;
// ... fill curves ...
auto lines = tf::vtk::make_vtk_polydata(std::move(curves));

auto normals = tf::compute_normals(polygons);
auto vtk_normals = tf::vtk::make_vtk_normals(std::move(normals));
vtk_normals->SetName("Normals");
polydata->GetCellData()->SetNormals(vtk_normals);

tf::buffer<int> labels;
// ... fill labels ...
auto vtk_labels = tf::vtk::make_vtk_array(std::move(labels));
vtk_labels->SetName("Labels");
polydata->GetCellData()->AddArray(vtk_labels);

tf::index_map_buffer<vtkIdType> point_map;
// ... build map during mesh cleaning ...

// Reindex all point data arrays
auto new_point_data = tf::vtk::make_vtk_point_data_reindexed(
    input->GetPointData(), point_map);
output->GetPointData()->ShallowCopy(new_point_data);

// VTK matrix → trueform frame
auto frame = tf::vtk::make_frame(actor->GetUserMatrix());
auto form = tf::make_form(frame, mesh->poly_tree(), mesh->polygons());

// trueform transformation → VTK matrix
auto transform = tf::random_transformation<float, 3>();
auto matrix = tf::vtk::make_vtk_matrix(transform);
actor->SetUserMatrix(matrix);

// Update existing matrix
tf::vtk::fill_vtk_matrix(actor->GetUserMatrix(), new_transform);

// Screen-space picking ray
auto ray = tf::vtk::make_world_ray(renderer, mouse_x, mouse_y);
if (auto hit = tf::vtk::ray_hit(ray, mesh)) {
    // Process hit
}

// Geometry views
using points_t = /* tf::points view over float data */;
using polys_t = /* tf::offset_block_range over vtkIdType */;
using polygons_t = /* tf::polygons (polys + points) */;
using paths_t = /* tf::paths view */;
using curves_t = /* tf::curves (paths + points) */;
using lines_t = /* tf::offset_block_range over vtkIdType */;
using edges_t = /* tf::edges view */;
using segments_t = /* tf::segments (edges + points) */;
using normals_t = /* tf::unit_vectors view */;

// Sized variants (compile-time vertex count)
template<std::size_t V> using polys_sized_t = /* ... */;
template<std::size_t V> using polygons_sized_t = /* ... */;
template<std::size_t V> using lines_sized_t = /* ... */;

// Array ranges
using float_range_t = tf::range<float*, tf::dynamic_size>;
using double_range_t = tf::range<double*, tf::dynamic_size>;
using int_range_t = tf::range<int*, tf::dynamic_size>;
using vtkIdType_range_t = tf::range<vtkIdType*, tf::dynamic_size>;