//-----------------------------------------------------------------------------
// Copyright (C) 2018 Merlok
//
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
// at your option, any later version. See the LICENSE.txt file for the text of
// the license.
//-----------------------------------------------------------------------------
// Tools for work with CBOR format http://cbor.io/spec.html
// via Intel tinycbor (https://github.com/intel/tinycbor) library
//-----------------------------------------------------------------------------
//

#include "cbortools.h"
#include <stdlib.h>
#include "emv/emvjson.h"
#include "util.h"
#include "fidocore.h"

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

static CborError dumpelm(CborValue *it, bool *got_next, int nestingLevel) {
	CborError err;
	*got_next = false;

	CborType type = cbor_value_get_type(it);
	indent(nestingLevel);
	switch (type) {
	case CborMapType:
	case CborArrayType: {
		printf(type == CborArrayType ? "Array[" : "Map[");
		break;
	}

	case CborIntegerType: {
		int64_t val;
		cbor_value_get_int64(it, &val);     // can't fail
		printf("%lld", (long long)val);
		break;
	}

	case CborByteStringType: {
		uint8_t *buf;
		size_t n;
		err = cbor_value_dup_byte_string(it, &buf, &n, it);
		*got_next = true;
		if (err)
			return err;     // parse error
		printf("%s", sprint_hex(buf, n));
		free(buf);
		break;
	}

	case CborTextStringType: {
		char *buf;
		size_t n;
		err = cbor_value_dup_text_string(it, &buf, &n, it);
		*got_next = true;
		if (err)
			return err;     // parse error
		printf("%s", buf);
		free(buf);
		break;
	}

	case CborTagType: {
		CborTag tag;
		cbor_value_get_tag(it, &tag);
		printf("Tag(%lld)", (long long)tag);
		break;
	}

	case CborSimpleType: {
		uint8_t type;
		cbor_value_get_simple_type(it, &type);
		printf("simple(%u)", type);
		break;
	}

	case CborNullType:
		printf("null");
		break;

	case CborUndefinedType:
		printf("undefined");
		break;

	case CborBooleanType: {
		bool val;
		cbor_value_get_boolean(it, &val);       // can't fail
		printf("%s", val ? "true" : "false");
		break;
	}

	case CborDoubleType: {
		double val;
		if (false) {
			float f;
	case CborFloatType:
			cbor_value_get_float(it, &f);
			val = f;
		} else {
			cbor_value_get_double(it, &val);
		}
		printf("%g", val);
		break;
	}
	case CborHalfFloatType: {
		uint16_t val;
		cbor_value_get_half_float(it, &val);
		printf("__f16(%04x)", val);
		break;
	}

	case CborInvalidType:
		printf("CborInvalidType!!!");
		break;
	}

	return CborNoError;
}

static CborError dumprecursive(uint8_t cmdCode, bool isResponse, CborValue *it, bool isMapType, int nestingLevel) {
	int elmCount = 0;
	while (!cbor_value_at_end(it)) {
		CborError err;
		CborType type = cbor_value_get_type(it);
//printf("^%x^", type);
		bool got_next;

		switch (type) {
		case CborMapType:
		case CborArrayType: {
			// recursive type
			CborValue recursed;
			assert(cbor_value_is_container(it));
			if (!(isMapType && (elmCount % 2)))
				indent(nestingLevel);
			printf(type == CborArrayType ? "Array[\n" : "Map[\n");
			err = cbor_value_enter_container(it, &recursed);
			if (err)
				return err;       // parse error
			err = dumprecursive(cmdCode, isResponse, &recursed, (type == CborMapType), nestingLevel + 1);
			if (err)
				return err;       // parse error
			err = cbor_value_leave_container(it, &recursed);
			if (err)
				return err;       // parse error
			indent(nestingLevel);
			printf("]");
			got_next = true;
			break;
		}

		default: {
			err = dumpelm(it, &got_next, (isMapType && (elmCount % 2)) ? 0 : nestingLevel);
			if (err)
				return err;
			if (cmdCode > 0 && nestingLevel == 1 && isMapType && !(elmCount % 2)) {
				int64_t val;
				cbor_value_get_int64(it, &val);
				char *desc = fido2GetCmdMemberDescription(cmdCode, isResponse, val);
				if (desc)
					printf(" (%s)", desc);
			}
			break;
		}
		}

		if (!got_next) {
			err = cbor_value_advance_fixed(it);
			if (err)
				return err;
		}
		if (isMapType && !(elmCount % 2)) {
			printf(": ");
		} else {
			printf("\n");
		}
		elmCount++;
	}
	return CborNoError;
}

int TinyCborInit(uint8_t *data, size_t length, CborValue *cb) {
	CborParser parser;
	CborError err = cbor_parser_init(data, length, 0, &parser, cb);
    if (err)
		return err;

	return 0;
}

int TinyCborPrintFIDOPackage(uint8_t cmdCode, bool isResponse, uint8_t *data, size_t length) {
	CborValue cb;
	int res;
	res = TinyCborInit(data, length, &cb);
	if (res)
		return res;

    CborError err = dumprecursive(cmdCode, isResponse, &cb, false, 0);

	if (err) {
		fprintf(stderr,
#if __WORDSIZE == 64
		"CBOR parsing failure at offset %" PRId64 " : %s\n",
#else
		"CBOR parsing failure at offset %" PRId32 " : %s\n",
#endif
		cb.ptr - data, cbor_error_string(err));
		return 1;
	}

	return 0;
}

int JsonObjElmCount(json_t *elm) {
	int res = 0;
	const char *key;
	json_t *value;

	if (!json_is_object(elm))
		return 0;

	json_object_foreach(elm, key, value) {
		if (strlen(key) > 0 && key[0] != '.')
			res++;
	}

	return res;
}

int JsonToCbor(json_t *elm, CborEncoder *encoder) {
	if (!elm || !encoder)
		return 1;

	int res;

	// CBOR map == JSON object
	if (json_is_object(elm)) {
		CborEncoder map;
		const char *key;
		json_t *value;

		res = cbor_encoder_create_map(encoder, &map, JsonObjElmCount(elm));
		cbor_check(res);

		json_object_foreach(elm, key, value) {
			if (strlen(key) > 0 && key[0] != '.') {
				res = cbor_encode_text_stringz(&map, key);
				cbor_check(res);

				// RECURSION!
				JsonToCbor(value, &map);
			}
		}

		res = cbor_encoder_close_container(encoder, &map);
		cbor_check(res);
	}

	// CBOR array == JSON array
	if (json_is_array(elm)) {
		size_t index;
		json_t *value;
		CborEncoder array;

		res = cbor_encoder_create_array(encoder, &array, json_array_size(elm));
		cbor_check(res);

		json_array_foreach(elm, index, value) {
			// RECURSION!
			JsonToCbor(value, &array);
		}

		res = cbor_encoder_close_container(encoder, &array);
		cbor_check(res);
	}

	if (json_is_boolean(elm)) {
		res = cbor_encode_boolean(encoder, json_is_true(elm));
		cbor_check(res);
	}

	if (json_is_integer(elm)) {
		res = cbor_encode_int(encoder, json_integer_value(elm));
		cbor_check(res);
	}

	if (json_is_real(elm)) {
		res = cbor_encode_float(encoder, json_real_value(elm));
		cbor_check(res);
	}

	if (json_is_string(elm)) {
		const char * val = json_string_value(elm);
		if (CheckStringIsHEXValue(val)) {
			size_t datalen = 0;
			uint8_t data[4096] = {0};
			res = JsonLoadBufAsHex(elm, "$", data, sizeof(data), &datalen);
			if (res)
				return 100;

			res = cbor_encode_byte_string(encoder, data, datalen);
			cbor_check(res);
		} else {
			res = cbor_encode_text_stringz(encoder, val);
			cbor_check(res);
		}
	}



	return 0;
}

int CborMapGetKeyById(CborParser *parser, CborValue *map, uint8_t *data, size_t dataLen, int key) {
	CborValue cb;

	CborError err = cbor_parser_init(data, dataLen, 0, parser, &cb);
	cbor_check(err);

	if (cbor_value_get_type(&cb) != CborMapType)
		return 1;

	err = cbor_value_enter_container(&cb, map);
	cbor_check(err);

	int64_t indx;
	while (!cbor_value_at_end(map)) {
		// check number
		if (cbor_value_get_type(map) != CborIntegerType)
			return 1;

		cbor_value_get_int64(map, &indx);

		err = cbor_value_advance(map);
		cbor_check(err);

		if (indx == key)
			return 0;

		// pass value
		err = cbor_value_advance(map);
		cbor_check(err);
	}

	err = cbor_value_leave_container(&cb, map);
	cbor_check(err);

	return 2;
}

CborError CborGetArrayBinStringValue(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen) {
	return CborGetArrayBinStringValueEx(elm, data, maxdatalen, datalen, NULL, 0);
}

CborError CborGetArrayBinStringValueEx(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen, uint8_t *delimeter, size_t delimeterlen) {
	CborValue array;
	if (datalen)
		*datalen = 0;

	size_t slen = maxdatalen;
	size_t totallen = 0;

	CborError res = cbor_value_enter_container(elm, &array);
	cbor_check(res);

	while (!cbor_value_at_end(&array)) {
		res = cbor_value_copy_byte_string(&array, &data[totallen], &slen, &array);
		cbor_check(res);

		totallen += slen;
		if (delimeter) {
			memcpy(&data[totallen], delimeter, delimeterlen);
			totallen += delimeterlen;
		}
		slen = maxdatalen - totallen;
	}

	res = cbor_value_leave_container(elm, &array);
	cbor_check(res);

	if (datalen)
		*datalen = totallen;

	return CborNoError;
};

CborError CborGetBinStringValue(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen) {
	if (datalen)
		*datalen = 0;

	size_t slen = maxdatalen;

	CborError res = cbor_value_copy_byte_string(elm, data, &slen, elm);
	cbor_check(res);

	if (datalen)
		*datalen = slen;

	return CborNoError;
};

CborError CborGetArrayStringValue(CborValue *elm, char *data, size_t maxdatalen, size_t *datalen, char *delimeter) {
	CborValue array;
	if (datalen)
		*datalen = 0;

	size_t slen = maxdatalen;
	size_t totallen = 0;

	CborError res = cbor_value_enter_container(elm, &array);
	cbor_check(res);

	while (!cbor_value_at_end(&array)) {
		res = cbor_value_copy_text_string(&array, &data[totallen], &slen, &array);
		cbor_check(res);

		totallen += slen;
		if (delimeter) {
			strcat(data, delimeter);
			totallen += strlen(delimeter);
		}
		slen = maxdatalen - totallen;
		data[totallen] = 0x00;
	}

	res = cbor_value_leave_container(elm, &array);
	cbor_check(res);

	if (datalen)
		*datalen = totallen;

	return CborNoError;
};

CborError CborGetStringValue(CborValue *elm, char *data, size_t maxdatalen, size_t *datalen) {
	if (datalen)
		*datalen = 0;

	size_t slen = maxdatalen;

	CborError res = cbor_value_copy_text_string(elm, data, &slen, elm);
	cbor_check(res);

	if (datalen)
		*datalen = slen;

	return CborNoError;
};

CborError CborGetStringValueBuf(CborValue *elm) {
	static char stringBuf[2048];
	memset(stringBuf, 0x00, sizeof(stringBuf));

	return CborGetStringValue(elm, stringBuf, sizeof(stringBuf), NULL);
};

int CBOREncodeElm(json_t *root, char *rootElmId, CborEncoder *encoder) {
	json_t *elm = NULL;
	if (rootElmId && strlen(rootElmId) && rootElmId[0] == '$')
		elm = json_path_get(root, rootElmId);
	else
		elm = json_object_get(root, rootElmId);

	if (!elm)
		return 1;

	int res = JsonToCbor(elm, encoder);

	return res;
}

CborError CBOREncodeClientDataHash(json_t *root, CborEncoder *encoder) {
	uint8_t buf[100] = {0};
	size_t jlen;

	JsonLoadBufAsHex(root, "$.ClientDataHash", buf, sizeof(buf), &jlen);

	// fill with 0x00 if not found
	if (!jlen)
		jlen = 32;

	int res = cbor_encode_byte_string(encoder, buf, jlen);
	cbor_check(res);

	return 0;
}