/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2019  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  VAS_EBOOT is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/dl.h>
#include <VasEBoot/mm.h>

#define JSMN_STATIC
#include "jsmn.h"
#include "json.h"

VAS_EBOOT_MOD_LICENSE ("GPLv3");

VasEBoot_err_t
VasEBoot_json_parse (VasEBoot_json_t **out, char *string, VasEBoot_size_t string_len)
{
  VasEBoot_json_t *json = NULL;
  jsmn_parser parser;
  VasEBoot_err_t ret = VAS_EBOOT_ERR_NONE;
  int jsmn_ret;

  if (!string)
    return VAS_EBOOT_ERR_BAD_ARGUMENT;

  json = VasEBoot_zalloc (sizeof (*json));
  if (!json)
    return VAS_EBOOT_ERR_OUT_OF_MEMORY;
  json->string = string;

  /*
   * Parse the string twice: first to determine how many tokens
   * we need to allocate, second to fill allocated tokens.
   */
  jsmn_init (&parser);
  jsmn_ret = jsmn_parse (&parser, string, string_len, NULL, 0);
  if (jsmn_ret <= 0)
    {
      ret = VAS_EBOOT_ERR_BAD_ARGUMENT;
      goto err;
    }

  json->tokens = VasEBoot_calloc (jsmn_ret, sizeof (jsmntok_t));
  if (!json->tokens)
    {
      ret = VAS_EBOOT_ERR_OUT_OF_MEMORY;
      goto err;
    }

  jsmn_init (&parser);
  jsmn_ret = jsmn_parse (&parser, string, string_len, json->tokens, jsmn_ret);
  if (jsmn_ret <= 0)
    {
      ret = VAS_EBOOT_ERR_BAD_ARGUMENT;
      goto err;
    }

  *out = json;

 err:
  if (ret)
    VasEBoot_json_free (json);

  return ret;
}

void
VasEBoot_json_free (VasEBoot_json_t *json)
{
  if (json)
    {
      VasEBoot_free (json->tokens);
      VasEBoot_free (json);
    }
}

VasEBoot_err_t
VasEBoot_json_getsize (VasEBoot_size_t *out, const VasEBoot_json_t *json)
{
  int size;

  size = json->tokens[json->idx].size;
  if (size < 0)
    return VAS_EBOOT_ERR_OUT_OF_RANGE;

  *out = (VasEBoot_size_t) size;
  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_json_gettype (VasEBoot_json_type_t *out, const VasEBoot_json_t *json)
{
  switch (json->tokens[json->idx].type)
    {
    case JSMN_OBJECT:
      *out = VAS_EBOOT_JSON_OBJECT;
      break;
    case JSMN_ARRAY:
      *out = VAS_EBOOT_JSON_ARRAY;
      break;
    case JSMN_STRING:
      *out = VAS_EBOOT_JSON_STRING;
      break;
    case JSMN_PRIMITIVE:
      *out = VAS_EBOOT_JSON_PRIMITIVE;
      break;
    default:
      return VAS_EBOOT_ERR_BAD_ARGUMENT;
    }

  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_json_getchild (VasEBoot_json_t *out, const VasEBoot_json_t *parent, VasEBoot_size_t n)
{
  VasEBoot_size_t offset = 1, size;
  jsmntok_t *p;

  if (VasEBoot_json_getsize (&size, parent) || n >= size)
    return VAS_EBOOT_ERR_OUT_OF_RANGE;

  /*
   * Skip the first n children. For each of the children, we need
   * to skip their own potential children (e.g. if it's an
   * array), as well. We thus add the children's size to n on
   * each iteration.
   */
  p = &parent->tokens[parent->idx];
  while (n--)
    n += p[offset++].size;

  out->string = parent->string;
  out->tokens = parent->tokens;
  out->idx = parent->idx + offset;

  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_json_getvalue (VasEBoot_json_t *out, const VasEBoot_json_t *parent, const char *key)
{
  VasEBoot_json_type_t type;
  VasEBoot_size_t i, size;

  if (VasEBoot_json_gettype (&type, parent) || type != VAS_EBOOT_JSON_OBJECT)
    return VAS_EBOOT_ERR_BAD_ARGUMENT;

  if (VasEBoot_json_getsize (&size, parent))
    return VAS_EBOOT_ERR_BAD_ARGUMENT;

  for (i = 0; i < size; i++)
    {
      VasEBoot_json_t child;
      const char *s;

      if (VasEBoot_json_getchild (&child, parent, i) ||
	  VasEBoot_json_getstring (&s, &child, NULL) ||
          VasEBoot_strcmp (s, key) != 0)
	continue;

      return VasEBoot_json_getchild (out, &child, 0);
    }

  return VAS_EBOOT_ERR_FILE_NOT_FOUND;
}

static VasEBoot_err_t
get_value (VasEBoot_json_type_t *out_type, const char **out_string, const VasEBoot_json_t *parent, const char *key)
{
  const VasEBoot_json_t *p = parent;
  VasEBoot_json_t child;
  VasEBoot_err_t ret;
  jsmntok_t *tok;

  if (key)
    {
      ret = VasEBoot_json_getvalue (&child, parent, key);
      if (ret)
	return ret;
      p = &child;
    }

  tok = &p->tokens[p->idx];
  p->string[tok->end] = '\0';

  *out_string = p->string + tok->start;

  return VasEBoot_json_gettype (out_type, p);
}

VasEBoot_err_t
VasEBoot_json_getstring (const char **out, const VasEBoot_json_t *parent, const char *key)
{
  VasEBoot_json_type_t type;
  const char *value;
  VasEBoot_err_t ret;

  ret = get_value (&type, &value, parent, key);
  if (ret)
    return ret;
  if (type != VAS_EBOOT_JSON_STRING)
    return VAS_EBOOT_ERR_BAD_ARGUMENT;

  *out = value;
  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_json_getuint64 (VasEBoot_uint64_t *out, const VasEBoot_json_t *parent, const char *key)
{
  VasEBoot_json_type_t type;
  const char *value;
  const char *end;
  VasEBoot_err_t ret;

  ret = get_value (&type, &value, parent, key);
  if (ret)
    return ret;
  if (type != VAS_EBOOT_JSON_STRING && type != VAS_EBOOT_JSON_PRIMITIVE)
    return VAS_EBOOT_ERR_BAD_ARGUMENT;

  VasEBoot_errno = VAS_EBOOT_ERR_NONE;
  *out = VasEBoot_strtoul (value, &end, 10);
  if (VasEBoot_errno != VAS_EBOOT_ERR_NONE || *end)
    return VAS_EBOOT_ERR_BAD_NUMBER;

  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_json_getint64 (VasEBoot_int64_t *out, const VasEBoot_json_t *parent, const char *key)
{
  VasEBoot_json_type_t type;
  const char *value;
  const char *end;
  VasEBoot_err_t ret;

  ret = get_value (&type, &value, parent, key);
  if (ret)
    return ret;
  if (type != VAS_EBOOT_JSON_STRING && type != VAS_EBOOT_JSON_PRIMITIVE)
    return VAS_EBOOT_ERR_BAD_ARGUMENT;

  VasEBoot_errno = VAS_EBOOT_ERR_NONE;
  *out = VasEBoot_strtol (value, &end, 10);
  if (VasEBoot_errno != VAS_EBOOT_ERR_NONE || *end)
    return VAS_EBOOT_ERR_BAD_NUMBER;

  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_json_unescape (char **out, VasEBoot_size_t *outlen, const char *in, VasEBoot_size_t inlen)
{
  VasEBoot_err_t ret = VAS_EBOOT_ERR_NONE;
  VasEBoot_size_t inpos, resultpos;
  char *result;

  if (out == NULL || outlen == NULL)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("output parameters are not set"));

  result = VasEBoot_calloc (1, inlen + 1);
  if (result == NULL)
    return VAS_EBOOT_ERR_OUT_OF_MEMORY;

  for (inpos = resultpos = 0; inpos < inlen; inpos++)
    {
      if (in[inpos] == '\\')
	{
	  inpos++;
	  if (inpos >= inlen)
	    {
	      ret = VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("expected escaped character"));
	      goto err;
	    }

	  switch (in[inpos])
	    {
	      case '"':
		result[resultpos++] = '"';
		break;

	      case '/':
		result[resultpos++] = '/';
		break;

	      case '\\':
		result[resultpos++] = '\\';
		break;

	      case 'b':
		result[resultpos++] = '\b';
		break;

	      case 'f':
		result[resultpos++] = '\f';
		break;

	      case 'r':
		result[resultpos++] = '\r';
		break;

	      case 'n':
		result[resultpos++] = '\n';
		break;

	      case 't':
		result[resultpos++] = '\t';
		break;

	      case 'u':
		{
		  char values[4] = {0};
		  unsigned i;

		  inpos++;
		  if (inpos + ARRAY_SIZE(values) > inlen)
		    {
		      ret = VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("unicode sequence too short"));
		      goto err;
		    }

		  for (i = 0; i < ARRAY_SIZE(values); i++)
		    {
		      char c = in[inpos++];

		      if (c >= '0' && c <= '9')
			values[i] = c - '0';
		      else if (c >= 'A' && c <= 'F')
			values[i] = c - 'A' + 10;
		      else if (c >= 'a' && c <= 'f')
			values[i] = c - 'a' + 10;
		      else
			{
			  ret = VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
					    N_("unicode sequence with invalid character '%c'"), c);
			  goto err;
			}
		    }

		  if (values[0] != 0 || values[1] != 0)
		    result[resultpos++] = values[0] << 4 | values[1];
		  result[resultpos++] = values[2] << 4 | values[3];

		  /* Offset the increment that's coming in via the loop increment. */
		  inpos--;

		  break;
		}

	      default:
		ret = VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("unrecognized escaped character '%c'"), in[inpos]);
		goto err;
	    }
	}
      else
	  result[resultpos++] = in[inpos];
    }

  *out = result;
  *outlen = resultpos;

 err:
  if (ret != VAS_EBOOT_ERR_NONE)
    VasEBoot_free (result);

  return ret;
}