module cbor;

private import std.string : format;
private import std.traits : Unqual, isArray, isAssociativeArray, isBoolean, isDynamicArray,
    isExpressionTuple, isFloatingPoint, isIntegral, isSomeChar, isStaticArray, isUnsigned;
public import std.typecons : Flag, Yes, No;
private import std.range : ElementEncodingType, hasLength, save, tee;
private import std.conv : to;
private import std.utf : byChar;
private import std.range : isInputRange, isOutputRange, ElementType;
private import std.typecons : isTuple;


/// Encodes value E into output range sink.
/// Returns number of bytes written to sink.
/// If flatten flag is yes then static arrays and structs will be encoded in place without headers.
size_t encodeCbor(R, E)(auto ref R sink, auto ref const E value)
    if(isOutputRange!(R, ubyte))
{
    // void* gets into here
    static if (is(E == struct)) {
        return encodeCborArray(sink, value);
    }
    // { ... }
    else {
        static assert(false, "Unable to encode " ~ E.stringof);
    }
}

size_t encodeCborArray(R, A)(auto ref R sink, A aggregate)
    if(isOutputRange!(R, ubyte) && is(A == struct))
{
    return encodeCborAggregate(sink, aggregate);
}

size_t encodeCborAggregate(R,A)(auto ref R sink, auto ref A aggregate)
    if (isOutputRange!(R, ubyte) && is(A == struct))
{
    size_t size;

    foreach(i, member; aggregate.tupleof)
    {
        enum bool encoded = isEncodedFieldValue!(member);
        enum bool encoded2 = isEncodedFieldType!(typeof(member));
        pragma(msg, "encode ", typeof(member), ": ", encoded, " ", encoded2);

        static if (encoded)
        {
            size += encodeCbor(sink, member);
        }
    }
    return size;
}

private template isEncodedFieldType(member)
{
    pragma(msg, member.stringof, " is type");
    enum bool isEncodedFieldType = isEncodedType!(member);
}

private template isEncodedFieldValue(alias member)
{
    pragma(msg, member.stringof, " is value");

    enum bool isEncodedFieldValue = isEncodedType!(typeof(member));
    pragma(msg, typeof(member), " ", member.stringof, " ", isEncodedFieldValue, " is value");
}

private enum bool isEncodedType(T) = isIntegral!T || isFloatingPoint!T || isBoolean!T ||
    isArray!T || isInputRange!T || isAssociativeArray!T ||
    isTuple!T || is(T == string) || is(T == class) || is(T == struct);

unittest
{
    static struct Inner
    {
    }

    static struct Test1
    {
        Inner inner;
        void* pointer; // not encoded
    }

    ubyte[1024] buf1;
    size_t size;

    Test1 test;
    size = encodeCborAggregate(buf1[], test);
}