#include "chunked_vector/chunked_vector.h"

int main() {
    dod::chunked_vector<int> vec;
    
    // Add some elements
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    
    // Use like std::vector
    for (const auto& item : vec) {
        std::cout << item << " ";
    }
    
    return 0;
}

// std::vector - potentially dangerous
std::vector<int> std_vec = {1, 2, 3};
auto it = std_vec.begin();
std_vec.push_back(4);  // May invalidate 'it' if reallocation occurs
// *it;  // Potentially undefined behavior

// chunked_vector - always safe
chunked_vector<int> chunked_vec = {1, 2, 3};
auto it = chunked_vec.begin();
chunked_vec.push_back(4);  // Never invalidates 'it'
*it;  // Always safe - returns 1

template <typename T, size_t PAGE_SIZE = 1024>
class chunked_vector;

using value_type = T;
using reference = T&;
using const_reference = const T&;
using pointer = T*;
using const_pointer = const T*;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
using iterator = basic_iterator<T>;
using const_iterator = basic_iterator<const T>;

// Default constructor
chunked_vector() noexcept;

// Fill constructor
explicit chunked_vector(size_type count);
chunked_vector(size_type count, const T& value);

// Initializer list constructor
chunked_vector(std::initializer_list<T> init);

// Copy constructor
chunked_vector(const chunked_vector& other);

// Move constructor
chunked_vector(chunked_vector&& other) noexcept;

// Unchecked access
reference operator[](size_type pos);
const_reference operator[](size_type pos) const;

// Checked access (throws std::out_of_range)
reference at(size_type pos);
const_reference at(size_type pos) const;

// First and last elements
reference front();
const_reference front() const;
reference back();
const_reference back() const;

iterator begin() noexcept;
const_iterator begin() const noexcept;
const_iterator cbegin() const noexcept;

iterator end() noexcept;
const_iterator end() const noexcept;
const_iterator cend() const noexcept;

bool empty() const noexcept;
size_type size() const noexcept;
size_type capacity() const noexcept;
size_type max_size() const noexcept;

void reserve(size_type new_capacity);
void shrink_to_fit();

static constexpr size_t page_size();

void clear() noexcept;

void push_back(const T& value);
void push_back(T&& value);

template<typename... Args>
reference emplace_back(Args&&... args);

void pop_back();

void resize(size_type count);
void resize(size_type count, const T& value);

// Erase operations
iterator erase(const_iterator pos);
iterator erase(const_iterator first, const_iterator last);
iterator erase_unsorted(const_iterator pos);  // Fast unordered erase

chunked_vector& operator=(const chunked_vector& other);
chunked_vector& operator=(chunked_vector&& other) noexcept;
chunked_vector& operator=(std::initializer_list<T> init);

#include "chunked_vector/chunked_vector.h"
#include <iostream>

int main() {
    // Create a chunked_vector with default page size
    dod::chunked_vector<int> vec;
    
    // Add elements
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);
    
    // Access elements
    std::cout << "First: " << vec.front() << std::endl;
    std::cout << "Last: " << vec.back() << std::endl;
    std::cout << "Size: " << vec.size() << std::endl;
    
    // Iterate
    for (const auto& value : vec) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

// Use smaller page size for memory-constrained environments
dod::chunked_vector<int, 256> small_vec;

// Use larger page size for better cache performance
dod::chunked_vector<int, 4096> large_vec;

// Power-of-2 page sizes are optimized
dod::chunked_vector<int, 1024> optimized_vec;

struct Point {
    float x, y, z;
    
    Point(float x = 0, float y = 0, float z = 0) : x(x), y(y), z(z) {}
    
    Point(const Point&) = default;
    Point& operator=(const Point&) = default;
    
    Point(Point&&) = default;
    Point& operator=(Point&&) = default;
};

int main() {
    dod::chunked_vector<Point> points;
    
    // Add points using different methods
    points.push_back({1.0f, 2.0f, 3.0f});
    points.emplace_back(4.0f, 5.0f, 6.0f);
    
    // Reserve space to avoid reallocations
    points.reserve(1000);
    
    // Resize with default-constructed elements
    points.resize(10);
    
    // Resize with specific value
    points.resize(20, Point{1.0f, 1.0f, 1.0f});
    
    return 0;
}

#include <algorithm>
#include <numeric>

int main() {
    dod::chunked_vector<int> vec = {5, 2, 8, 1, 9, 3};
    
    // Sort elements
    std::sort(vec.begin(), vec.end());
    
    // Find elements
    auto it = std::find(vec.begin(), vec.end(), 8);
    if (it != vec.end()) {
        std::cout << "Found 8 at position " << std::distance(vec.begin(), it) << std::endl;
    }
    
    // Calculate sum
    int sum = std::accumulate(vec.begin(), vec.end(), 0);
    std::cout << "Sum: " << sum << std::endl;
    
    return 0;
}

int main() {
    dod::chunked_vector<int> vec;
    
    // Reserve capacity to avoid multiple reallocations
    vec.reserve(10000);
    
    // Use emplace_back for in-place construction
    for (int i = 0; i < 10000; ++i) {
        vec.emplace_back(i);
    }
    
    // Use erase_unsorted for fast removal when order doesn't matter
    auto it = vec.begin() + 100;
    vec.erase_unsorted(it);  // O(1) instead of O(n)
    
    // Shrink to fit to reclaim unused memory
    vec.shrink_to_fit();
    
    return 0;
}

// Enable iterator debugging (default in debug builds)
#define CHUNKED_VEC_ITERATOR_DEBUG_LEVEL 1
#include "chunked_vector/chunked_vector.h"

// Disable iterator debugging for maximum performance
#define CHUNKED_VEC_ITERATOR_DEBUG_LEVEL 0
#include "chunked_vector/chunked_vector.h"

// Define custom allocator macros before including the header
#define CHUNKED_VEC_ALLOC(size, alignment) my_aligned_alloc(size, alignment)
#define CHUNKED_VEC_FREE(ptr) my_free(ptr)
#include "chunked_vector/chunked_vector.h"

// Define custom assertion macro
#define CHUNKED_VEC_ASSERT(expr) my_assert(expr)
#include "chunked_vector/chunked_vector.h"

// Override inlining behavior
#define CHUNKED_VEC_INLINE __forceinline
#include "chunked_vector/chunked_vector.h"