/*

 * Copyright (c) 2014-2020 Pavel Kalvoda <me@pavelkalvoda.com>

 *

 * libcbor is free software; you can redistribute it and/or modify

 * it under the terms of the MIT license. See LICENSE for details.

 */

#include "strings.h"

#include <string.h>

#include "internal/memory_utils.h"

#include "internal/unicode.h"

cbor_item_t* cbor_new_definite_string(void) {

  cbor_item_t* item = _cbor_malloc(sizeof(cbor_item_t));

  _CBOR_NOTNULL(item);

  *item = (cbor_item_t){

      .refcount = 1,

      .type = CBOR_TYPE_STRING,

      .metadata = {.string_metadata = {.type = _CBOR_METADATA_DEFINITE,

                                       .codepoint_count = 0,

                                       .length = 0}}};

  return item;

}

cbor_item_t* cbor_new_indefinite_string(void) {

  cbor_item_t* item = _cbor_malloc(sizeof(cbor_item_t));

  _CBOR_NOTNULL(item);

  *item = (cbor_item_t){

      .refcount = 1,

      .type = CBOR_TYPE_STRING,

      .metadata = {.string_metadata = {.type = _CBOR_METADATA_INDEFINITE,

                                       .length = 0}},

      .data = _cbor_malloc(sizeof(struct cbor_indefinite_string_data))};

  _CBOR_DEPENDENT_NOTNULL(item, item->data);

  *((struct cbor_indefinite_string_data*)item->data) =

      (struct cbor_indefinite_string_data){

          .chunk_count = 0,

          .chunk_capacity = 0,

          .chunks = NULL,

      };

  return item;

}

cbor_item_t* cbor_build_string(const char* val) {

  cbor_item_t* item = cbor_new_definite_string();

  _CBOR_NOTNULL(item);

  size_t len = strlen(val);

  unsigned char* handle = _cbor_malloc(len);

  _CBOR_DEPENDENT_NOTNULL(item, handle);

  memcpy(handle, val, len);

  cbor_string_set_handle(item, handle, len);

  return item;

}

cbor_item_t* cbor_build_stringn(const char* val, size_t length) {

  cbor_item_t* item = cbor_new_definite_string();

  _CBOR_NOTNULL(item);

  unsigned char* handle = _cbor_malloc(length);

  _CBOR_DEPENDENT_NOTNULL(item, handle);

  memcpy(handle, val, length);

  cbor_string_set_handle(item, handle, length);

  return item;

}

void cbor_string_set_handle(cbor_item_t* item,

                            cbor_mutable_data CBOR_RESTRICT_POINTER data,

                            size_t length) {

  CBOR_ASSERT(cbor_isa_string(item));

  CBOR_ASSERT(cbor_string_is_definite(item));

  item->data = data;

  item->metadata.string_metadata.length = length;

  struct _cbor_unicode_status unicode_status;

  size_t codepoint_count =

      _cbor_unicode_codepoint_count(data, length, &unicode_status);

  CBOR_ASSERT(codepoint_count <= length);

  if (unicode_status.status == _CBOR_UNICODE_OK) {

    item->metadata.string_metadata.codepoint_count = codepoint_count;

  } else {

    item->metadata.string_metadata.codepoint_count = 0;

  }

}

cbor_item_t** cbor_string_chunks_handle(const cbor_item_t* item) {

  CBOR_ASSERT(cbor_isa_string(item));

  CBOR_ASSERT(cbor_string_is_indefinite(item));

  return ((struct cbor_indefinite_string_data*)item->data)->chunks;

}

size_t cbor_string_chunk_count(const cbor_item_t* item) {

  CBOR_ASSERT(cbor_isa_string(item));

  CBOR_ASSERT(cbor_string_is_indefinite(item));

  return ((struct cbor_indefinite_string_data*)item->data)->chunk_count;

}

bool cbor_string_add_chunk(cbor_item_t* item, cbor_item_t* chunk) {

  CBOR_ASSERT(cbor_isa_string(item));

  CBOR_ASSERT(cbor_string_is_indefinite(item));

  struct cbor_indefinite_string_data* data =

      (struct cbor_indefinite_string_data*)item->data;

  if (data->chunk_count == data->chunk_capacity) {

    if (!_cbor_safe_to_multiply(CBOR_BUFFER_GROWTH, data->chunk_capacity)) {

      return false;

    }

    size_t new_chunk_capacity =

        data->chunk_capacity == 0 ? 1

                                  : CBOR_BUFFER_GROWTH * (data->chunk_capacity);

    cbor_item_t** new_chunks_data = _cbor_realloc_multiple(

        data->chunks, sizeof(cbor_item_t*), new_chunk_capacity);

    if (new_chunks_data == NULL) {

      return false;

    }

    data->chunk_capacity = new_chunk_capacity;

    data->chunks = new_chunks_data;

  }

  data->chunks[data->chunk_count++] = cbor_incref(chunk);

  return true;

}

size_t cbor_string_length(const cbor_item_t* item) {

  CBOR_ASSERT(cbor_isa_string(item));

  return item->metadata.string_metadata.length;

}

unsigned char* cbor_string_handle(const cbor_item_t* item) {

  CBOR_ASSERT(cbor_isa_string(item));

  return item->data;

}

size_t cbor_string_codepoint_count(const cbor_item_t* item) {

  CBOR_ASSERT(cbor_isa_string(item));

  return item->metadata.string_metadata.codepoint_count;

}

bool cbor_string_is_definite(const cbor_item_t* item) {

  CBOR_ASSERT(cbor_isa_string(item));

  return item->metadata.string_metadata.type == _CBOR_METADATA_DEFINITE;

}

bool cbor_string_is_indefinite(const cbor_item_t* item) {

  return !cbor_string_is_definite(item);

}