#define JSON_C_
#include "json.h"

#include <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

static JSONError jerrno = NoError;
static size_t jerr_index = 0;

const char * json_strerr() {
    return JSONErrorMessage[jerrno];
}

size_t json_err_loc() {
    return jerr_index;
}

// Shorthand to set jerno and return -1;
static inline int set_jerrno(JSONError err) {
    jerrno = err;
    return -1;
}
static inline size_t align_8(size_t n) { return (((n - 1) >> 3) + 1) << 3; }
static inline bool is_whitespace(char c) { return c == ' ' || c == '\t' || c == '\n'; }

static int json_parse_value(const char **buf, const char *buf_end, uint8_t **restrict dst,
                            const uint8_t *dst_end);

// *dst must be 8 aligned
static inline int json_parse_string(const char **buf, const char *buf_end, uint8_t **restrict dst,
                                    const uint8_t *dst_end) {
    if (*dst + sizeof(JSONHeader) >= dst_end) {
        return set_jerrno(DstOverflow);
    }

    JSONHeader *header = (JSONHeader *)(*dst);
    header->type       = (uint32_t)String;
    header->len        = 0;
    *dst += sizeof(JSONHeader);

    // Skip first quote
    (*buf)++;
    if (*buf == buf_end) {
        return set_jerrno(SrcOverflow);
    }

    // If the last char was an esc
    bool esc = false;
    // If we're currently parsing a unicode escape,
    // -1: no, 0-4: we're n char in
    int esc_unicode = -1;
    // The unicode codepoint we're parsing
    int un_codepoint = 0;

    for (; *buf < buf_end; (*buf)++) {
        char c = **buf;

        if (esc_unicode >= 0) {
            int digit = 0;
            if (c >= '0' && c <= '9')
                digit = c - '0';
            else if (c >= 'a' && c <= 'f')
                digit = c - 'a' + 10;
            else if (c >= 'A' && c <= 'F')
                digit = c - 'A' + 10;
            else {
                return set_jerrno(StringBadUnicode);
            }
            un_codepoint <<= 4;
            un_codepoint += digit;
            esc_unicode++;

            if (esc_unicode == 4) { // UTF-8 Encoding
                if (un_codepoint <= 0x7f) {
                    if (*dst + 1 >= dst_end)
                        return set_jerrno(DstOverflow);

                    *(*dst)++ = un_codepoint;
                    header->len++;
                } else if (un_codepoint <= 0x7ff) {
                    if (*dst + 2 >= dst_end)
                        return set_jerrno(DstOverflow);

                    *(*dst)++ = 0b11000000 | (un_codepoint >> 6 & 0b011111);
                    *(*dst)++ = 0b10000000 | (un_codepoint >> 0 & 0b111111);
                    header->len += 2;
                } else if (un_codepoint <= 0xffff) {
                    if (*dst + 3 >= dst_end)
                        return set_jerrno(DstOverflow);

                    *(*dst)++ = 0b11100000 | (un_codepoint >> 12 & 0b1111);
                    *(*dst)++ = 0b10000000 | (un_codepoint >> 6 & 0b111111);
                    *(*dst)++ = 0b10000000 | (un_codepoint >> 0 & 0b111111);
                    header->len += 3;
                } else if (un_codepoint <= 0x10ffff) {
                    if (*dst + 4 >= dst_end)
                        return set_jerrno(DstOverflow);

                    *(*dst)++ = 0b11110000 | (un_codepoint >> 18 & 0b111);
                    *(*dst)++ = 0b10000000 | (un_codepoint >> 12 & 0b111111);
                    *(*dst)++ = 0b10000000 | (un_codepoint >> 6 & 0b111111);
                    *(*dst)++ = 0b10000000 | (un_codepoint >> 0 & 0b111111);
                    header->len += 4;
                } else {
                    return set_jerrno(StringBadUnicode);
                }
                esc_unicode = -1;
            }
        } else if (esc) {
            char r;
            switch (c) {
            case '"':
            case '\\':
            case '/': // For some reason you can escape a slash in JSON
                r = c;
                break;
            case 'b':
                r = '\b';
                break;
            case 'f':
                r = '\f';
                break;
            case 'n':
                r = '\n';
                break;
            case 'r':
                r = '\r';
                break;
            case 't':
                r = '\t';
                break;
            case 'u':
                esc_unicode = 0;
                break;
            default:
                return set_jerrno(StringBadEscape);
            }

            if (c != 'u') {
                if (*dst + 1 >= dst_end) {
                    return set_jerrno(DstOverflow);
                }
                *(*dst)++ = r;
                header->len++;
            }

            esc = false;
        } else {
            if (c == '\\') {
                esc = true;
                continue;
            } else if (c == '"') {
                int padded_len = align_8(header->len);
                if (*dst + (padded_len - header->len) >= dst_end)
                    return set_jerrno(DstOverflow);
                for (; padded_len > header->len; padded_len--)
                    *(*dst)++ = '\0';
                (*buf)++;
                return 0;
            } else if ((c < ' ' && c != '\t') || c == 0x7f) {
                jerrno = StringBadChar;
                return -1;
            }
            if (*dst + 1 >= dst_end)
                return set_jerrno(DstOverflow);
            *(*dst)++ = c;
            header->len++;
        }
    }
    // The only way to get out of the loop is if *buf >= buf_end
    return set_jerrno(SrcOverflow);
}

// *dst must be 8 aligned
static int json_parse_number(const char **buf, const char *buf_end, uint8_t **restrict dst,
                             const uint8_t *dst_end) {

    if (*dst + sizeof(JSONHeader) + sizeof(double) >= dst_end) {
        return set_jerrno(DstOverflow);
    }

    JSONHeader *header = (JSONHeader *)(*dst);
    double     *value  = (double *)((*dst) + sizeof(JSONHeader));
    *dst += sizeof(JSONHeader) + sizeof(double);

    header->type = (uint32_t)Number;
    header->len  = sizeof(double);

    double sign = 1.0;
    if (**buf == '-') {
        (*buf)++;
        sign = -1.0;
    }

    if (*buf >= buf_end)
        return set_jerrno(SrcOverflow);
    if (**buf != '0') {
        for (; *buf < buf_end; (*buf)++) {
            char c = **buf;
            if (c < '0' || c > '9') {
                break;
            }

            *value *= 10.0;
            *value += (double)(c - '0');
        }
    } else {
        (*buf)++;
    }

    if (*buf < buf_end && **buf == '.') {
        double place = 0.1;
        (*buf)++; // Skip dot
        if (*buf >= buf_end)
            return set_jerrno(SrcOverflow);
        if (**buf < '0' || **buf > '9')
            return set_jerrno(NumberBadChar);

        for (; *buf < buf_end; (*buf)++) {
            char c = **buf;
            if (c < '0' || c > '9')
                break;
            double digit = (double)(c - '0');
            *value += digit * place;
            place *= 0.1;
        }
    }

    if (*buf < buf_end && (**buf == 'e' || **buf == 'E')) {
        double exp      = 0.0;
        double exp_sign = 1.0;

        (*buf)++; // Skip e/E
        if (*buf >= buf_end)
            return set_jerrno(SrcOverflow);

        if (**buf == '+' || **buf == '-') {
            exp_sign = **buf == '-' ? -1.0 : 1.0;
            (*buf)++;
            if (*buf >= buf_end)
                return set_jerrno(SrcOverflow);
        }

        for (; *buf < buf_end; (*buf)++) {
            char c = **buf;
            if (c < '0' || c > '9')
                break;
            exp *= 10;
            exp += (double)(c - '0');
        }

        exp *= exp_sign;
        *value *= pow(10.0, exp);
    }

    *value *= sign;

    return 0;
}

// *dst must be 8 aligned
static int json_parse_boolean(const char **buf, const char *buf_end, uint8_t **restrict dst,
                              const uint8_t *dst_end) {

    if (*dst + sizeof(JSONHeader) + 8 >= dst_end) {
        return set_jerrno(DstOverflow);
    }

    JSONHeader *header = (JSONHeader *)(*dst);
    uint64_t     *value  = (uint64_t *)((*dst) + sizeof(JSONHeader));
    *dst += sizeof(JSONHeader) + 8;

    header->type = (uint32_t)Boolean;
    header->len  = 8;

    if(**buf == 't') {
        if(*buf + 4 > buf_end) return set_jerrno(SrcOverflow);
        if(strncmp(*buf, "true", 4) != 0) {
            return set_jerrno(BadKeyword);
        }
        *buf += 4;
        *value = 1;
    } else if(**buf == 'f') {
        if(*buf + 5 > buf_end) return set_jerrno(SrcOverflow);
        if(strncmp(*buf, "false", 5) != 0) {
            return set_jerrno(BadKeyword);
        }
        *buf += 5;
        *value = 0;
    } else {
        return set_jerrno(BadKeyword);
    }
    return 0;
}

// *dst must be 8 aligned
static int json_parse_null(const char **buf, const char *buf_end, uint8_t **restrict dst,
                              const uint8_t *dst_end) {

    if (*dst + sizeof(JSONHeader) >= dst_end) {
        return set_jerrno(DstOverflow);
    }

    JSONHeader *header = (JSONHeader *)(*dst);
    *dst += sizeof(JSONHeader);

    header->type = (uint32_t)Null;
    header->len  = 0;

    if(*buf + 4 > buf_end) return set_jerrno(SrcOverflow);
    if(strncmp(*buf, "null", 4) != 0) {
        return set_jerrno(BadKeyword);
    }
    *buf += 4;
    return 0;
}

// *dst must be 8 aligned
static int json_parse_array(const char **buf, const char *buf_end, uint8_t **restrict dst,
                              const uint8_t *dst_end) {

    if (*dst + sizeof(JSONHeader) >= dst_end) {
        return set_jerrno(DstOverflow);
    }

    JSONHeader *header = (JSONHeader *)(*dst);
    *dst += sizeof(JSONHeader);
    uint8_t * dst_arr_start = *dst;

    header->type = (uint32_t)Array;

    (*buf)++; // Skip [
    // skip initial whitespace
    for(; *buf < buf_end && is_whitespace(**buf); (*buf)++);
    if(*buf == buf_end) return set_jerrno(SrcOverflow);
    if(**buf == ']') {
        header->len = 0;
        return 0;
    }
    while(1) {
        if (json_parse_value(buf, buf_end, dst, dst_end) != 0) return -1;
        for(; *buf < buf_end && is_whitespace(**buf); (*buf)++);
        if (*buf == buf_end) return set_jerrno(SrcOverflow);
        if(**buf == ',') {
            (*buf)++;
        } else if(**buf == ']') {
            (*buf)++;
            break;
        } else {
            return set_jerrno(BadChar);
        }
    }
    header->len = *dst - dst_arr_start;
    return 0;
}

// *dst must be 8 aligned
static int json_parse_object(const char **buf, const char *buf_end, uint8_t **restrict dst,
                              const uint8_t *dst_end) {

    if (*dst + sizeof(JSONHeader) >= dst_end) {
        return set_jerrno(DstOverflow);
    }

    JSONHeader *header = (JSONHeader *)(*dst);
    *dst += sizeof(JSONHeader);
    uint8_t * dst_obj_start = *dst;

    header->type = (uint32_t)Object;

    (*buf)++; // Skip {

    for(; *buf < buf_end && is_whitespace(**buf); (*buf)++);
    if(*buf == buf_end) return set_jerrno(SrcOverflow);
    if(**buf == '}') {
        header->len = 0;
        return 0;
    }

    while(1) {
        // Skip whitespace before key
        for(; *buf < buf_end && is_whitespace(**buf); (*buf)++);
        // Parse key
        if (json_parse_string(buf, buf_end, dst, dst_end) != 0) return -1;
        // Skip whitespace after key
        for(; *buf < buf_end && is_whitespace(**buf); (*buf)++);
        // There should be at least one char
        if(*buf == buf_end) return set_jerrno(SrcOverflow);
        // There should be a colon
        if(**buf != ':') return set_jerrno(ObjectBadChar);
        // Skip colon
        (*buf)++;
        // Parse value (takes char of whitespace)
        if (json_parse_value(buf, buf_end, dst, dst_end) != 0) return -1;
        // Skip whitespace after value
        for(; *buf < buf_end && is_whitespace(**buf); (*buf)++);
        // There should be at least one char (} or ,)
        if (*buf == buf_end) return set_jerrno(SrcOverflow);
        if(**buf == ',') {
            (*buf)++;
        } else if(**buf == '}') {
            (*buf)++;
            break;
        } else {
            return set_jerrno(BadChar);
        }
    }
    header->len = *dst - dst_obj_start;
    return 0;
}

// *dst must be 8 aligned
static int json_parse_value(const char **buf, const char *buf_end, uint8_t **restrict dst,
                            const uint8_t *dst_end) {
    for (; *buf < buf_end; (*buf)++) {
        if(is_whitespace(**buf)) continue;

        switch (**buf) {
        case '"':
            return json_parse_string(buf, buf_end, dst, dst_end);
        case '-':
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            return json_parse_number(buf, buf_end, dst, dst_end);
        case '{':
            return json_parse_object(buf, buf_end, dst, dst_end);
        case '[':
            return json_parse_array(buf, buf_end, dst, dst_end);
        case 't':
        case 'f':
            return json_parse_boolean(buf, buf_end, dst, dst_end);
        case 'n':
            return json_parse_null(buf, buf_end, dst, dst_end);
        default:
            return set_jerrno(BadChar);
        }
    }
    if (*buf == buf_end)
        return set_jerrno(SrcOverflow);
    return 0;
}

int json_parse(const char * src, size_t src_len, uint8_t * dst, size_t dst_len) {
    memset(dst, 0, dst_len);
    const char * buf = src;
    const char * buf_end = src + src_len;
    uint8_t * dst_end = dst + dst_len;
    int rc = json_parse_value(&buf, buf_end, &dst, dst_end);
    jerr_index = buf - src;
    return rc;
}

void json_print_value(uint8_t ** buf) {
    JSONHeader * header = (JSONHeader*) *buf;
    *buf += sizeof(header);
    switch(header->type) {
        case String:
            printf("\"%.*s\"", header->len, *buf);
            *buf += align_8(header->len);
            break;
        case Number:
            printf("%lf", *(double *)*buf);
            *buf += sizeof(double);
            break;
        case Boolean: 
            {
                uint64_t value = *(uint64_t*)*buf;
                if(value == 1) {
                    printf("true");
                } else if(value == 0) {
                    printf("false");
                } else {
                    printf("(boolean) garbage");
                }
                *buf += 8;
            }
            break;
        case Null:
            printf("null");
            break;
        case Array:
            {
                uint8_t * end = *buf + header->len;
                printf("[");
                while(1) {
                    json_print_value(buf);
                    if(*buf < end) {
                        printf(", ");
                    } else {
                        printf("]");
                        break;
                    }
                }
            }
            break;
        case Object:
            {
                uint8_t * end = *buf + header->len;
                printf("{");
                while(1) {
                    json_print_value(buf);
                    printf(":");
                    json_print_value(buf);
                    if(*buf < end) {
                        printf(",");
                    } else {
                        printf("}");
                        break;
                    }
                }
            }
            break;
    }
}

struct Test {
    double a;
    char * b;
};

const JSONAdapter TestAdapter[] = {
    {".a", Number, offsetof(struct Test, a)},
    {".b", String, offsetof(struct Test, b)},
};

static void json_adapt_set(uint8_t * buf, JSONAdapter * adapters, size_t adapter_count, void * ptr, char * path) {
    JSONHeader * header = (JSONHeader *)buf;
    for(int i = 0; i < adapter_count; i++) {
        if(strcmp(path, adapters[i].path) == 0 && header->type == adapters[i].type) {
            void * p = ptr + adapters[i].offset;
            switch(header->type) {
                case String:
                    {
                        char * v = malloc(header->len + 1);
                        strncpy(v, (char *)(buf + sizeof(JSONHeader)), header->len);
                        v[header->len] = '\0';
                        *(char**)p = v;
                    }
                    break;
                case Number:
                    *(double*)p = *(double*)(buf + sizeof(JSONHeader));
                    break;
                case Boolean:
                    *(bool*)p = *(uint64_t*)(buf + sizeof(JSONHeader)) == 1;
                    break;
            }
        }
    }
}

static void json_adapt_priv(uint8_t ** buf, JSONAdapter * adapters, size_t adapter_count, void * ptr, char * full_path, char * path) {
    JSONHeader * header = (JSONHeader *)*buf;

    switch(header->type) {
        case String:
            json_adapt_set(*buf, adapters, adapter_count, ptr, full_path);
            *buf += sizeof(JSONHeader) + align_8(header->len);
            break;
        case Number:
            json_adapt_set(*buf, adapters, adapter_count, ptr, full_path);
            *buf += sizeof(JSONHeader) + sizeof(double);
            break;
        case Boolean:
            json_adapt_set(*buf, adapters, adapter_count, ptr, full_path);
            *buf += sizeof(JSONHeader) + 8;
            break;
        case Null:
            *buf += sizeof(JSONHeader);
            break;
        case Array:
            {
                *buf += sizeof(JSONHeader);
                uint8_t * end = *buf + header->len;
                for(size_t index = 0; *buf < end; index++) {
                    int len = sprintf(path, ".%lu", index);
                    json_adapt_priv(buf, adapters, adapter_count, ptr, full_path, path + len);
                }
            }
            break;
        case Object:
            {
                *buf += sizeof(JSONHeader);
                uint8_t * end = *buf + header->len;
                while(*buf < end) {
                    JSONHeader * key_header = (JSONHeader*)*buf;
                    *buf += sizeof(JSONHeader);

                    int len = sprintf(path, ".%.*s", key_header->len, *buf);
                    *buf += align_8(key_header->len);

                    json_adapt_priv(buf, adapters, adapter_count, ptr, full_path, path + len);
                }
            }
            break;
    }
}

void json_adapt(uint8_t * buf, JSONAdapter * adapters, size_t adapter_count, void * ptr) {
    char path[512] = ".";
    json_adapt_priv(&buf, adapters, adapter_count, ptr, path, path);
}