#include "msgpack.h"

// read big endian ints
#define M_I16(b)  (b[0] << 8)  | (b[1])
#define M_I32(b)  (b[0] << 24) | (b[1] << 16) \
                | (b[2] << 8)  | (b[3])
#define M_I64(b) (b[0] << 56) | (b[1] << 48) \
                | (b[2] << 40) | (b[3] << 32) \
                | (b[4] << 24) | (b[5] << 16) \
                | (b[6] << 8)  | (b[7])

// Todo: add memtable for the lengths, the index is the current index from the array,
//       the msgpack_t struct has a pointer to such a table
// macro making sure there are enough bytes before reading them
#define ENOUGH_BYTES(pack, n, on_fail) if((pack)->size < (n)) { on_fail; }
#define EB(pack, n) ENOUGH_BYTES(pack, (n)+1, return 0)

// byte, type, format, length expr, condition
#define BYTE_FORMATS(X, pack)                                           \
    X(0xc0, MSGPACK_NIL,     FMT_NIL,       0, ;)                       \
    X(0xc1, MSGPACK_UNKNOWN, FMT_UNUSED,    0, ;)                       \
    X(0xc2, MSGPACK_BOOL,    FMT_FALSE,     0, ;)                       \
    X(0xc3, MSGPACK_BOOL,    FMT_TRUE,      0, ;)                       \
                                                                        \
    X(0xc4, MSGPACK_RAW,     FMT_BIN8,      1+ pack->bin[1],         EB(pack, 1)) \
    X(0xc5, MSGPACK_RAW,     FMT_BIN16,     2+ M_I16(pack->bin+1),   EB(pack, 2)) \
    X(0xc6, MSGPACK_RAW,     FMT_BIN32,     4+ M_I32(pack->bin+1),   EB(pack, 4)) \
    X(0xc7, MSGPACK_EXT,     FMT_EXT8,      1+ pack->bin[1],         EB(pack, 1)) \
    X(0xc8, MSGPACK_EXT,     FMT_EXT16,     2+ M_I16(pack->bin+1),   EB(pack, 2)) \
    X(0xc9, MSGPACK_EXT,     FMT_EXT32,     4+ M_I32(pack->bin+1),   EB(pack, 4)) \
                                                                        \
    X(0xca, MSGPACK_FLOAT,   FMT_F32,       4, ;)                       \
    X(0xcb, MSGPACK_FLOAT,   FMT_F64,       8, ;)                       \
    X(0xcc, MSGPACK_INT,     FMT_U8,        1, ;)                       \
    X(0xcd, MSGPACK_INT,     FMT_U16,       2, ;)                       \
    X(0xce, MSGPACK_INT,     FMT_U32,       4, ;)                       \
    X(0xcf, MSGPACK_INT,     FMT_U64,       8, ;)                       \
    X(0xd0, MSGPACK_INT,     FMT_I8,        1, ;)                       \
    X(0xd1, MSGPACK_INT,     FMT_I16,       2, ;)                       \
    X(0xd2, MSGPACK_INT,     FMT_I32,       4, ;)                       \
    X(0xd3, MSGPACK_INT,     FMT_I64,       8, ;)                       \
    X(0xd4, MSGPACK_EXT,     FMT_FIX_EXT1,  1+ 1,  ;)                   \
    X(0xd5, MSGPACK_EXT,     FMT_FIX_EXT2,  1+ 2,  ;)                   \
    X(0xd6, MSGPACK_EXT,     FMT_FIX_EXT4,  1+ 4,  ;)                   \
    X(0xd7, MSGPACK_EXT,     FMT_FIX_EXT8,  1+ 8,  ;)                   \
    X(0xd8, MSGPACK_EXT,     FMT_FIX_EXT16, 1+ 16, ;)                   \
                                                                        \
    X(0xd9, MSGPACK_RAW,     FMT_STR8,      1+ pack->bin[1],        EB(pack, 1)) \
    X(0xda, MSGPACK_RAW,     FMT_STR16,     2+ M_I16(pack->bin+1),  EB(pack, 2)) \
    X(0xdb, MSGPACK_RAW,     FMT_STR32,     4+ M_I32(pack->bin+1),  EB(pack, 4)) \
                                                                                 \
    X(0xdc, MSGPACK_ARRAY,   FMT_ARRAY16,   2+ complex_length(pack, FMT_ARRAY16), EB(pack, 2)) \
    X(0xdd, MSGPACK_ARRAY,   FMT_ARRAY32,   4+ complex_length(pack, FMT_ARRAY32), EB(pack, 4)) \
    X(0xde, MSGPACK_MAP,     FMT_MAP16,     2+ complex_length(pack, FMT_MAP16),   EB(pack, 2)) \
    X(0xdf, MSGPACK_MAP,     FMT_MAP32,     4+ complex_length(pack, FMT_MAP32),   EB(pack, 4))

// just mask these ranges, don't check them
// use the logaical and of the ranges as a mask 

// range low, range high, type, format, length expr
#define RANGE_FORMATS(X, pack)                                          \
    X(0x00, 0x7f, MSGPACK_INT,    FMT_FIX_U,     0)                     \
    X(0x80, 0x8f, MSGPACK_MAP,    FMT_FIX_MAP,   complex_length(pack, FMT_FIX_MAP))   \
    X(0x90, 0x9f, MSGPACK_ARRAY,  FMT_FIX_ARRAY, complex_length(pack, FMT_FIX_ARRAY)) \
    X(0xa0, 0xbf, MSGPACK_STRING, FMT_FIX_STR,   pack[0] & 01F)         \
    X(0xe0, 0xff, MSGPACK_INT,    FMT_FIX_I,     0)

#define X_TO_ENUM2(_1, _2, fmt, ...) fmt,
#define X_TO_ENUM3(_1, _2, _3, fmt, ...) fmt,

enum msgpack_fmt {
    BYTE_FORMATS(X_TO_ENUM2,;)
    RANGE_FORMATS(X_TO_ENUM3,;)
};

#define X_TO_FMT_TYPE1(_1, type, fmt, ...) [fmt] = type,
#define X_TO_FMT_TYPE2(_1, _2, type, fmt, ...) [fmt] = type,

static const enum msgpack_type fmt_to_type[] = {
    BYTE_FORMATS(X_TO_FMT_TYPE1,;)
    RANGE_FORMATS(X_TO_FMT_TYPE2,;)
};


static size_t complex_length(msgpack_t *pack, enum msgpack_fmt fmt);
static size_t pack_lenght(msgpack_t pack);
static enum msgpack_fmt pack_fmt(msgpack_t pack);

#define SUCCESS(type) (type)
#define ERROR(type, err, rest) ((rest << 6) | (err << 3) | (type))

#define CHECK_ARGS(type, pack, m)                                       \
    do {                                                                \
        if(!(pack) || !(pack)->bin || (pack)->size == 0)                \
            return ERROR((type), MSGPACK_ERROR_INVALID_PACK, 0);        \
        if((pack)->bin[0] == 0xc)                                       \
            return ERROR((type), MSGPACK_ERROR_WRONG_TYPE, MSGPACK_NIL);\
        if(!(m))                                                        \
            return ERROR((type), MSGPACK_ERROR_INVALID_ARGUMENT, 0);    \
    } while(0)

int msgpack_read(msgpack_t *pack, msgpack_allocator_t alloc, void **m_ptr);

int msgpack_read_int(msgpack_t *pack, msgpack_int_t *m)
{
    CHECK_ARGS(MSGPACK_INT, pack, m);

    enum msgpack_fmt fmt = pack_fmt(pack);
    switch(fmt) {
    default:
        return ERROR(MSGPACK_INT, MSGPACK_ERROR_WRONG_TYPE, fmt_to_type[fmt]);
    }

    return SUCCESS(MSGPACK_INT);
}

int msgpack_read_bool(msgpack_t *pack, msgpack_bool_t *m);
int msgpack_read_float(msgpack_t *pack, msgpack_int_t *m);
int msgpack_read_string(msgpack_t *pack, msgpack_string_t *m);
int msgpack_read_bin(msgpack_t *pack, msgpack_bin_t *m);

int msgpack_read_array(msgpack_t *pack, msgpack_array_t *m)
{
    CHECK_ARGS(MSGPACK_ARRAY, pack, m);

    enum msgpack_fmt fmt = pack_fmt(pack);
    size_t offset = 0;
    size_t elements = 0;

    switch(fmt) {
    case FMT_FIX_ARRAY:
        offset = 1;
        elements = pack->bin[0] & 0x0F;
        break;
    case FMT_ARRAY16:
        offset = 3;
        ENOUGH_BYTES(pack, offset, return 0);
        elements = M_I16(pack->bin+1);
        break;
    case FMT_ARRAY32:
        offset = 5;
        ENOUGH_BYTES(pack, offset, return 0);
        elements = M_I32(pack->bin+1);
        break;
    default:
        return ERROR(MSGPACK_ARRAY, MSGPACK_ERROR_WRONG_TYPE, fmt_to_type[fmt]);
    }

    if(m->length < elements) {
        m->length = elements;
        return ERROR(MSGPACK_ARRAY, MSGPACK_ERROR_UNSUFFICIENT_CAPACITY, 0);
    }

    for(size_t i = 0; i < elements; i++) {
        msgpack_t new_pack = {pack->bin+offset, size-offset};
        size_t len = pack_lenght(&new_pack) + 1;

        ENOUGH_BYTES(pack, offset + len,
                     return ERROR(MSGPACK_ARRAY, MSGPACK_ERROR_UNEXPECTED_END, 0));

        m->members[i].bin  = pack->bin + offset;
        m->members[i].size = len;

        offset += len;
    }

    return SUCCESS(MSGPACK_ARRAY);
}

int msgpack_read_map(msgpack_t *pack, msgpack_map_t *m);

static size_t complex_length(msgpack_t *pack, enum msgpack_fmt fmt)
{
    ENOUGH_BYTES(pack, 1, return 0);

    size_t offset = 0;
    size_t elements = 0;

    switch(fmt) {
    case FMT_FIX_MAP:
    case FMT_FIX_ARRAY:
        offset = 1;
        elements = pack->bin[0] & 0x0F;
        break;
    case FMT_MAP16:
    case FMT_ARRAY16:
        offset = 3;
        ENOUGH_BYTES(pack, offset, return 0);
        elements = M_I16(pack->bin+1);
        break;
    case FMT_MAP32:
    case FMT_ARRAY32:
        offset = 5;
        ENOUGH_BYTES(pack, offset, return 0);
        elements = M_I32(pack->bin+1);
        break;
    }

    if(fmt_to_type[fmt] == MSGPACK_MAP) elements *= 2;

    for(size_t i = 0; i < elements; i++) {
        msgpack_t new_pack = {pack->bin+offset, size-offset};
        size_t len = pack_lenght(new_pack) + 1;
        if(len == 0) return 0;

        offset += len;
        ENOUGH_BYTES(pack, offset, return 0);
    }

    return offset - 1;
}

#define WRAP_BYTE_FORMATS(X, pack) \
    switch(pack->bin[0]) { BYTE_FORMATS(X, pack) }
#define WRAP_RANGE_FORMATS(X, pack) \
    char byte = pack->bin[0]; RANGE_FORMATS(X, pack) {}

#define BYTE_TO_LENGHT(byte, _type, _fmt, length_expr, cond) \
    case byte: cond; return (length_expr) +1; break;
#define BYTE_TO_TYPE(byte, type, _fmt _length_expr, _cond) \
    case byte: return type; break;

#define RANGE_TO_LENGHT(bytel, byteh, _type, _fmt, length_expr) \
    if(bytel <= byte && byteh >= pack->bin[0]) { return (length_expr) + 1; } else
#define RANGE_TO_TYPE(bytel, byteh, type, _fmt, _length)   \
    if(bytel <= byte && byteh >= pack->bin[0]) { return type; } else

static size_t pack_lenght(msgpack_t pack)
{
    ENOUGH_BYTES(pack, 1, return 0);
    WRAP_BYTE_FORMATS(BYTE_TO_LENGTH, pack);
    WRAP_RANGE_FORMATS(RANGE_TO_LENGTH, pack);

    return 0;
}

static enum msgpack_fmt pack_fmt(msgpack_t pack)
{
    ENOUGH_BYTES(pack, 1, return 0);
    WRAP_BYTE_FORMATS(BYTE_TO_TYPE, pack);
    WRAP_RANGE_FORMATS(RANGE_TO_TYPE, pack);

    return FMT_UNUSED;
}