#include "ml_engine/inference_engine.h"
#include "ml_engine/tensor.h"

using namespace ml_engine;

int main() {
    // Create inference engine
    InferenceEngine<float> engine;
    
    // Configure for optimal performance
    engine.setNumThreads(8);        // Use 8 CPU threads
    engine.enableSIMD(true);        // Enable SIMD optimization
    engine.enableCuda(0);           // Enable GPU on device 0
    
    // Load your model
    engine.loadModel("path/to/model.bin");
    
    // Create input tensor (batch_size=1, channels=3, height=224, width=224)
    Tensor32f input({1, 3, 224, 224});
    
    // Fill with your data...
    // input.data() returns raw pointer for data copying
    
    // Run inference
    auto output = engine.infer(input);
    
    // Process output...
    std::cout << "Output shape: ";
    for (size_t dim : output.shape()) {
        std::cout << dim << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

// Prepare batch of inputs
std::vector<Tensor32f> batch_inputs;
for (int i = 0; i < batch_size; ++i) {
    Tensor32f input({1, 3, 224, 224});
    // Fill input data...
    batch_inputs.push_back(std::move(input));
}

// Run batch inference (automatically parallelized)
auto batch_outputs = engine.inferBatch(batch_inputs);

// Process all outputs...
for (const auto& output : batch_outputs) {
    // Process each output...
}

// Get detailed performance metrics
auto metrics = engine.getPerformanceMetrics();
for (const auto& [name, value] : metrics) {
    std::cout << name << ": " << value << std::endl;
}

// Example output:
// infer_time_ms: 15.234
// executeConvolution_time_ms: 8.456
// executeActivation_time_ms: 2.123
// memory_pool_memory_bytes: 104857600

#include "ml_engine/memory.h"

// Create custom memory pool (1GB)
MemoryPool pool(1024 * 1024 * 1024);

// Allocate aligned memory for SIMD operations
void* ptr = pool.allocate(1024, 64); // 1KB with 64-byte alignment

// Use memory...

// Deallocate when done
pool.deallocate(ptr);

// Pool automatically manages memory fragmentation

#include "ml_engine/simd_ops.h"

using namespace ml_engine::simd;

// High-performance vectorized operations
std::vector<float> a(1000), b(1000), result(1000);

// SIMD-optimized element-wise operations
SIMDOps<float>::add(a.data(), b.data(), result.data(), a.size());
SIMDOps<float>::multiply(a.data(), b.data(), result.data(), a.size());

// Fused multiply-add for neural networks
std::vector<float> c(1000);
SIMDOps<float>::fused_multiply_add(a.data(), b.data(), c.data(), result.data(), a.size());

template<typename T>
class InferenceEngine {
    static_assert(std::is_floating_point_v<T>, "Only floating point types supported");
    
    template<typename U>
    using is_supported_type = std::bool_constant<
        std::is_same_v<U, float> || std::is_same_v<U, double>
    >;
};