#include <print>

#include <adclib/adclib_device.h>

using namespace adc;

int main()
{
    std::string id1 = "1", id2 = "2", id3 = "str";

    int i = 10;
    double d = 8.1;
    std::string s{"dwedjkwlk"};

    AdcGenericDevice<> dev("DEV#1");

    std::println("add arith RW-attr with id='{}' (val={})", id1, i);
    dev.addArithAttr(
        id1, [&i]() -> adc_result_t<int> { return i; },
        [&i](int ii) -> adc_error_t {
            i = ii;
            return AdcDeviceErrorCode::ERROR_OK;
        });
    // dev.addAttr(
    //     id1, [&i]() -> adc_result_t<int> { return i; },
    //     [&i](int ii) -> adc_error_t {
    //         i = ii;
    //         return AdcDeviceErrorCode::ERROR_OK;
    //     },
    //     std::tuple<double, int, long>{});

    std::println("add RO-attr with id='{}' (val={})", id2, d);
    dev.addAttr(id2, [&d]() -> adc_result_t<double> { return d; }, nullptr);

    std::println("add RW-attr with id='{}' (val={})", id3, s);
    dev.addAttr(
        id3, [&s]() -> adc_result_t<std::string> { return s; },
        [&s](std::string const& sv) -> adc_error_t {
            s = sv;
            return {};
        },
        [&s](adc_result_t<std::string> const&) -> adc_result_t<const char*> { return s.c_str(); },
        [&s](adc_result_t<const char*> const& p) -> adc_result_t<std::string> {
            s = p.value();
            return s;
        });

    std::print("get '{}'-attr value as native int:\t", id1);
    adc_result_t<int> ri = dev[id1];
    if (ri) {
        std::println("dev[{}] = {}", id1, ri.value());
    } else {
        std::println("cannot get dev[{}] as int: {}", id1, ri.error().message());
    }

    int ii = 77;
    std::print("set '{}'-attr value to {} as native int:\t", id1, ii);
    auto err = dev[id1] = ii;
    if (err) {
        std::println("cannot set dev[{}] as int: {}", id1, err.message());
    } else {
        std::println("OK");
    }

    std::print("get '{}'-attr value as double:\t", id1);
    adc_result_t<double> rd = dev[id1];
    if (rd) {
        std::println("dev[{}] = {}", id1, rd.value());
    } else {
        std::println("cannot get dev[{}] as double: {}", id1, rd.error().message());
    }

    double dd = 33.333;
    std::print("set '{}'-attr value to {} as double:\t", id1, dd);
    err = dev[id1] = dd;
    if (err) {
        std::println("cannot set dev[{}] as double: {}", id1, err.message());
    } else {
        std::println("OK");
    }

    std::print("get '{}'-attr value as native int:\t", id1);
    ri = dev[id1];
    if (ri) {
        std::println("dev[{}] = {}", id1, ri.value());
    } else {
        std::println("cannot get dev[{}] as int: {}", id1, ri.error().message());
    }

    err = dev[id2] = 0.29817;
    if (err) {
        std::println("cannot set dev[{}] as double: {}", id2, err.message());
    }

    return 0;
}