module snmp.varbind;

import c.net_snmp;
import snmp.oid : OID;

private alias size_t = object.size_t;

/// Cursor over a netsnmp_variable_list linked list.
struct VarBind
{
    netsnmp_variable_list* handle;

    bool isValid() const @nogc nothrow @safe
    {
        return handle !is null;
    }

    VarBind next() const @trusted @nogc nothrow
    {
        return handle
            ? VarBind(cast(netsnmp_variable_list*) handle.next_variable) : VarBind(null);
    }

    const(oid)* namePtr() const @trusted @nogc nothrow
    {
        return handle ? handle.name : null;
    }

    size_t nameLength() const @trusted @nogc nothrow
    {
        return handle ? handle.name_length : 0;
    }

    ubyte type() const @trusted @nogc nothrow
    {
        return handle ? handle.type : 0;
    }

    int valueStr(scope char[] buf) const @trusted @nogc nothrow
    {
        if (!isValid || buf.length == 0)
            return 0;
        auto h = cast(netsnmp_variable_list*) handle;
        return snprint_value(buf.ptr, buf.length, h.name, h.name_length, h);
    }

    int oidStr(scope char[] buf) const @trusted @nogc nothrow
    {
        if (!isValid || buf.length == 0)
            return 0;
        return snprint_objid(buf.ptr, buf.length, handle.name, handle.name_length);
    }

    string oidString() const @trusted nothrow
    {
        char[512] buf = void;
        int n = oidStr(buf[]);
        return n > 0 ? buf[0 .. n].idup : "";
    }

    string valueString() const @trusted nothrow
    {
        char[512] buf = void;
        int n = valueStr(buf[]);
        return n > 0 ? buf[0 .. n].idup : "";
    }

    OID toOID() const @trusted @nogc nothrow
    {
        import core.stdc.string : memcpy;

        OID o;
        if (!isValid)
            return o;
        o.length = handle.name_length < MAX_OID_LEN ? handle.name_length : MAX_OID_LEN;
        memcpy(o.data.ptr, handle.name, o.length * oid.sizeof);
        return o;
    }

    /// Returns 0 for non-integer or invalid bindings.
    long asLong() const @trusted @nogc nothrow
    {
        if (!isValid || handle.type != ASN_INTEGER || !handle.val.integer)
            return 0;
        return *handle.val.integer;
    }

    /// Counter32 / Gauge32 / TimeTicks. Returns 0 on type mismatch.
    uint asUint() const @trusted @nogc nothrow
    {
        if (!isValid || !handle.val.integer)
            return 0;
        ubyte t = handle.type;
        if (t != ASN_COUNTER && t != ASN_GAUGE && t != ASN_TIMETICKS && t != ASN_UNSIGNED)
            return 0;
        return cast(uint) *handle.val.integer;
    }

    /// Returns zeroed struct on type mismatch.
    counter64 asCounter64() const @trusted @nogc nothrow
    {
        counter64 zero;
        if (!isValid || handle.type != ASN_COUNTER64 || !handle.val.counter64)
            return zero;
        return *handle.val.counter64;
    }

    /// OctetStr / IpAddress / BitStr raw bytes. Returns null on type mismatch.
    const(ubyte)[] asBytes() const @trusted @nogc nothrow
    {
        if (!isValid)
            return null;
        ubyte t = handle.type;
        if (t != ASN_OCTET_STR && t != ASN_IPADDRESS && t != ASN_BIT_STR)
            return null;
        // `string` is a D keyword — access via __traits
        auto p = __traits(getMember, handle.val, "string");
        if (!p)
            return null;
        return p[0 .. handle.val_len];
    }

    int opApply(scope int delegate(VarBind) dg)
    {
        for (auto v = this; v.isValid; v = v.next)
            if (auto r = dg(v))
                return r;
        return 0;
    }
}

unittest
{
    VarBind v;
    assert(!v.isValid);
    assert(!v.next.isValid);
    assert(v.namePtr is null);
    assert(v.nameLength == 0);
    assert(v.type == 0);

    char[64] buf;
    assert(v.valueStr(buf[]) == 0);
    assert(v.oidStr(buf[]) == 0);
    assert(v.oidString == "");
    assert(v.valueString == "");

    assert(!v.toOID.isValid);
    assert(v.asLong  == 0);
    assert(v.asUint  == 0);
    assert(v.asBytes is null);
    counter64 zero;
    assert(v.asCounter64.high == zero.high && v.asCounter64.low == zero.low);
}