/*
 * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */
#include <stdio.h>
#include <freertos/FreeRTOS.h>

#include "unity.h"
#if __has_include("esp_random.h")
#include "esp_random.h"
#else
#include "esp_system.h"
#endif

#include "cbor.h"

#define CBOR_CHECK(a, str, goto_tag, ret_value, ...)                              \
    do                                                                            \
    {                                                                             \
        if ((a) != CborNoError)                                                   \
        {                                                                         \
            printf("%s(%d): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__);        \
            ret = ret_value;                                                      \
            goto goto_tag;                                                        \
        }                                                                         \
    } while (0)

static void indent(int nestingLevel)
{
    while (nestingLevel--) {
        printf("  ");
    }
}

static void dumpbytes(const uint8_t *buf, size_t len)
{
    while (len--) {
        printf("%02X ", *buf++);
    }
}

/**
 * Decode CBOR data manuallly
 */
static CborError example_dump_cbor_buffer(CborValue *it, int nestingLevel)
{
    CborError ret = CborNoError;
    while (!cbor_value_at_end(it)) {
        CborType type = cbor_value_get_type(it);

        indent(nestingLevel);
        switch (type) {
        case CborArrayType: {
            CborValue recursed;
            assert(cbor_value_is_container(it));
            puts("Array[");
            ret = cbor_value_enter_container(it, &recursed);
            CBOR_CHECK(ret, "enter container failed", err, ret);
            ret = example_dump_cbor_buffer(&recursed, nestingLevel + 1);
            CBOR_CHECK(ret, "recursive dump failed", err, ret);
            ret = cbor_value_leave_container(it, &recursed);
            CBOR_CHECK(ret, "leave container failed", err, ret);
            indent(nestingLevel);
            puts("]");
            continue;
        }
        case CborMapType: {
            CborValue recursed;
            assert(cbor_value_is_container(it));
            puts("Map{");
            ret = cbor_value_enter_container(it, &recursed);
            CBOR_CHECK(ret, "enter container failed", err, ret);
            ret = example_dump_cbor_buffer(&recursed, nestingLevel + 1);
            CBOR_CHECK(ret, "recursive dump failed", err, ret);
            ret = cbor_value_leave_container(it, &recursed);
            CBOR_CHECK(ret, "leave container failed", err, ret);
            indent(nestingLevel);
            puts("}");
            continue;
        }
        case CborIntegerType: {
            int64_t val;
            ret = cbor_value_get_int64(it, &val);
            CBOR_CHECK(ret, "parse int64 failed", err, ret);
            printf("%lld\n", (long long)val);
            break;
        }
        case CborByteStringType: {
            uint8_t *buf;
            size_t n;
            ret = cbor_value_dup_byte_string(it, &buf, &n, it);
            CBOR_CHECK(ret, "parse byte string failed", err, ret);
            dumpbytes(buf, n);
            puts("");
            free(buf);
            continue;
        }
        case CborTextStringType: {
            char *buf;
            size_t n;
            ret = cbor_value_dup_text_string(it, &buf, &n, it);
            CBOR_CHECK(ret, "parse text string failed", err, ret);
            puts(buf);
            free(buf);
            continue;
        }
        case CborTagType: {
            CborTag tag;
            ret = cbor_value_get_tag(it, &tag);
            CBOR_CHECK(ret, "parse tag failed", err, ret);
            printf("Tag(%lld)\n", (long long)tag);
            break;
        }
        case CborSimpleType: {
            uint8_t type;
            ret = cbor_value_get_simple_type(it, &type);
            CBOR_CHECK(ret, "parse simple type failed", err, ret);
            printf("simple(%u)\n", type);
            break;
        }
        case CborNullType:
            puts("null");
            break;
        case CborUndefinedType:
            puts("undefined");
            break;
        case CborBooleanType: {
            bool val;
            ret = cbor_value_get_boolean(it, &val);
            CBOR_CHECK(ret, "parse boolean type failed", err, ret);
            puts(val ? "true" : "false");
            break;
        }
        case CborHalfFloatType: {
            uint16_t val;
            ret = cbor_value_get_half_float(it, &val);
            CBOR_CHECK(ret, "parse half float type failed", err, ret);
            printf("__f16(%04x)\n", val);
            break;
        }
        case CborFloatType: {
            float val;
            ret = cbor_value_get_float(it, &val);
            CBOR_CHECK(ret, "parse float type failed", err, ret);
            printf("%g\n", val);
            break;
        }
        case CborDoubleType: {
            double val;
            ret = cbor_value_get_double(it, &val);
            CBOR_CHECK(ret, "parse double float type failed", err, ret);
            printf("%g\n", val);
            break;
        }
        case CborInvalidType: {
            ret = CborErrorUnknownType;
            CBOR_CHECK(ret, "unknown cbor type", err, ret);
            break;
        }
        }

        ret = cbor_value_advance_fixed(it);
        CBOR_CHECK(ret, "fix value failed", err, ret);
    }
    return CborNoError;
err:
    return ret;
}


TEST_CASE("CBOR example", "[cbor]")
{
    CborEncoder root_encoder;
    CborParser root_parser;
    CborValue it;
    uint8_t buf[100];

    // Initialize the outermost cbor encoder
    cbor_encoder_init(&root_encoder, buf, sizeof(buf), 0);

    // Create an array containing several items
    CborEncoder array_encoder;
    CborEncoder map_encoder;
    cbor_encoder_create_array(&root_encoder, &array_encoder, 5); // [
    // 1. Create a map containing several pairs
    cbor_encoder_create_map(&array_encoder, &map_encoder, 3); // {
    // chip:esp32
    cbor_encode_text_stringz(&map_encoder, "chip");
    cbor_encode_text_stringz(&map_encoder, "esp32");
    // unicore:false
    cbor_encode_text_stringz(&map_encoder, "unicore");
    cbor_encode_boolean(&map_encoder, false);
    // ip:[192,168,1,100]
    cbor_encode_text_stringz(&map_encoder, "ip");
    CborEncoder array2;
    cbor_encoder_create_array(&map_encoder, &array2, 4); // [
    // Encode several numbers
    cbor_encode_uint(&array2, 192);
    cbor_encode_uint(&array2, 168);
    cbor_encode_uint(&array2, 1);
    cbor_encode_uint(&array2, 100);
    cbor_encoder_close_container(&map_encoder, &array2);        // ]
    cbor_encoder_close_container(&array_encoder, &map_encoder); // }
    // 2. Encode float number
    cbor_encode_float(&array_encoder, 3.14);
    // 3. Encode simple value
    cbor_encode_simple_value(&array_encoder, 99);
    // 4. Encode a string
    cbor_encode_text_stringz(&array_encoder, "2019-07-10 09:00:00+0000");
    // 5. Encode a undefined value
    cbor_encode_undefined(&array_encoder);
    cbor_encoder_close_container(&root_encoder, &array_encoder); // ]

    // If error happend when encoding, then this value should be meaningless
    printf("encoded buffer size %d", cbor_encoder_get_buffer_size(&root_encoder, buf));

    // Initialize the cbor parser and the value iterator
    cbor_parser_init(buf, sizeof(buf), 0, &root_parser, &it);

    printf("convert CBOR to JSON");
    // Dump the values in JSON format
    cbor_value_to_json(stdout, &it, 0);
    puts("");

    printf("decode CBOR manually: ");
    // Decode CBOR data manully
    TEST_ESP_OK(example_dump_cbor_buffer(&it, 0));
}

