#include "lap/core/CInitialization.hpp"
#include "lap/core/CResult.hpp"
#include "lap/core/CString.hpp"

int main() {
    // 1. Initialize (REQUIRED)
    auto result = lap::core::Initialize();
    if (!result.HasValue()) {
        return 1;
    }

    // 2. Use AUTOSAR types
    lap::core::String str = "Hello, LightAP";
    lap::core::Vector<int> vec = {1, 2, 3};

    // 3. Use Result<T> for error handling
    lap::core::Result<int> value = lap::core::Result<int>::FromValue(42);
    if (value.HasValue()) {
        std::cout << "Value: " << value.Value() << "\n";
    }

    // 4. Cleanup (REQUIRED)
    lap::core::Deinitialize();
    return 0;
}

#include "lap/core/ipc/Publisher.hpp"
#include "lap/core/ipc/Subscriber.hpp"
#include "lap/core/ipc/Message.hpp"

using namespace lap::core::ipc;

// Define message type
class SensorData : public Message {
public:
    int32_t temperature = 0;
    int32_t humidity = 0;
    
    size_t OnMessageSend(void* chunk_ptr, size_t chunk_size) noexcept override {
        std::memcpy(chunk_ptr, this, sizeof(SensorData));
        return sizeof(SensorData);
    }
    
    bool OnMessageReceived(const void* chunk_ptr, size_t chunk_size) noexcept override {
        std::memcpy(this, chunk_ptr, sizeof(SensorData));
        return true;
    }
};

int main() {
    // Publisher
    PublisherConfig config;
    config.max_chunks = 16;
    config.chunk_size = sizeof(SensorData);
    auto pub = Publisher::Create("/sensor_data", config).Value();
    
    // Send with Lambda (zero-copy)
    pub.Send([](void* chunk_ptr, size_t) -> size_t {
        SensorData* data = static_cast<SensorData*>(chunk_ptr);
        data->temperature = 25;
        data->humidity = 60;
        return sizeof(SensorData);
    });
    
    // Subscriber
    auto sub = Subscriber::Create("/sensor_data").Value();
    auto sample = sub.Receive().Value();
    const SensorData* data = sample.GetPayload<SensorData>();
    
    return 0;
}

#include "lap/core/CInitialization.hpp"

int main() {
    auto result = lap::core::Initialize();
    if (!result.HasValue()) {
        return 1;
    }
    
    // Your application code here
    
    lap::core::Deinitialize();
    return 0;
}

// String Types (SWS_CORE_01xxx)
lap::core::String str = "Hello";
lap::core::StringView view = str;

// Optional (SWS_CORE_01301)
lap::core::Optional<int> opt = 42;
if (opt.has_value()) {
    std::cout << opt.value() << "\n";
}

// Variant (SWS_CORE_01601)
lap::core::Variant<int, std::string> var = 42;
if (lap::core::holds_alternative<int>(var)) {
    int value = lap::core::get<int>(var);
}

// Result (SWS_CORE_00701)
lap::core::Result<int> divide(int a, int b) {
    if (b == 0) {
        return lap::core::Result<int>::FromError(
            lap::core::CoreErrc::kInvalidArgument);
    }
    return lap::core::Result<int>::FromValue(a / b);
}

// Future/Promise (SWS_CORE_00321/00341)
lap::core::Promise<int> promise;
lap::core::Future<int> future = promise.get_future();
promise.set_value(42);
int value = future.get();

#include "lap/core/ipc/Publisher.hpp"
#include "lap/core/ipc/Subscriber.hpp"

// Publisher side
auto pub_result = lap::core::Publisher::Create("camera");
auto& publisher = pub_result.Value();

// Loan memory from shared pool (zero-copy)
auto loan_result = publisher.Loan();
if (loan_result.HasValue()) {
    auto& message = loan_result.Value();
    // Write directly to shared memory
    message.SetHeader("image", 5242880);  // 5MB
    message.SetPayload(image_data, image_size);
    publisher.Send(std::move(message));
}

// Subscriber side
auto sub_result = lap::core::Subscriber::Create("camera");
auto& subscriber = sub_result.Value();

auto sample = subscriber.Receive();
if (sample.HasValue()) {
    auto& msg = sample.Value();
    // Access shared memory directly (zero-copy)
    ProcessImage(msg.GetPayload(), msg.GetPayloadSize());
}

#include "lap/core/CString.hpp"
#include "lap/core/CVector.hpp"
#include "lap/core/COptional.hpp"

// Vector
lap::core::Vector<int> vec = {1, 2, 3};
vec.push_back(4);

// String
lap::core::String str = "Hello";
str += " World";

// Optional
lap::core::Optional<int> opt = lap::core::nullopt;
if (!opt.HasValue()) {
    opt = 42;
}

using namespace lap::core::ipc;

// Example 1: Small messages (< 1KB)
PublisherConfig config;
config.max_chunks = 256;
config.chunk_size = 1024;
auto pub = Publisher::Create("/small_msg", config).Value();

pub.Send([](void* ptr, size_t) {
    std::memcpy(ptr, "Hello IPC", 10);
    return 10;
});

// Example 2: Large images (5MB)
PublisherConfig img_config;
img_config.max_chunks = 16;
img_config.chunk_size = 1920*720*4;  // 5.3MB
img_config.loan_policy = LoanPolicy::kWait;
auto img_pub = Publisher::Create("/camera0", img_config).Value();

img_pub.Send([](void* ptr, size_t size) -> size_t {
    GenerateImageData(ptr, size);
    return size;
});

// Example 3: Subscriber with timeout
auto sub = Subscriber::Create("/sensor_data").Value();
auto sample = sub.ReceiveWithTimeout(100000000);  // 100ms
if (sample.HasValue()) {
    ProcessData(sample.Value().GetRawPayload());
}

#include "lap/core/CConfig.hpp"

// Get configuration instance
auto& config = lap::core::ConfigManager::getInstance();

// Load from file
config.loadFromFile("config.json");

// Get values
auto port = config.getValue<int>("server.port");
auto host = config.getValue<std::string>("server.host");

// Set values
config.setValue("server.maxConnections", 100);

// Save
config.saveToFile("config.json");