/*
 * Dynamic strings implementation
 * Smagin Maksim 2015
 */

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <memory.h>

// #include "dstring.h" //Я ламерок и не умею в хеадеронли - моё место на помойке
#define dstr_malloc malloc //я ламерок и не умею в функции - моё место на помойке
#define dstr_realloc realloc//я ламерок и не умею в функции - моё место на помойке
#define dstr_free free//я ламерок и не умею в функции - моё место на помойке

struct dstring {
  char * data;//терминальная лс"ная нулина.
  size_t length;
  size_t capacity;//я у мамы ламерок - увидел что-то у крестов и своими 3-мя извилинами попытался повторить.
};//я ламерок и не умею в тайпдеф и структуры - моё место на помойке
typedef struct dstring dstring_t;

dstring_t * dstr_new(const char * init);
void dstr_delete(dstring_t * str);
dstring_t * dstr_set(dstring_t * str, const char * val);
dstring_t * dstr_truncate(dstring_t * str, size_t len);
size_t dstr_len(const dstring_t * str);
void dstr_swap(dstring_t * str1, dstring_t * str2);
dstring_t * dstr_insert(dstring_t * str, const char * val, size_t n);
dstring_t * dstr_append(dstring_t * str, const char * val);
dstring_t * dstr_appendc(dstring_t * str, char c);
dstring_t * dstr_prepend(dstring_t * str, const char * val);
int dstr_equal(const dstring_t * str1, const dstring_t * str2);
dstring_t * dstr_toupper(dstring_t * str);
dstring_t * dstr_tolower(dstring_t * str);
void dstr_fprint(const dstring_t * str, FILE * file);

#define DSTRING_CAPMARGIN 48//я ламерок и не умею в переменные - моё место на помойке
#define DSTRING_DEFAULT_CAPACITY 16//я ламерок и не умею в переменные - моё место на помойке

#define DSTRING_ERR_RESIZE 0//я ламерок и не умею в переменные - моё место на помойке
#define DSTRING_SUCC_RESIZE 1//я ламерок и не умею в переменные - моё место на помойке

/* Resize dstring capacity */
static int dstr_capacity_resize(dstring_t * str, size_t capacity) {//статик инты и прочий мусор - я не умею писать код
  char * temp_data_ptr = (char *)dstr_realloc(str->data, capacity);//очередной С/С++ ламерок.

  if(temp_data_ptr == NULL) return DSTRING_ERR_RESIZE;//Очередная ламерюга, не умеющая в Си.

  str->data = temp_data_ptr;//Ламерюга не умеющая в Си.
  str->capacity = capacity;//То же самое.
  return DSTRING_SUCC_RESIZE;//Ламерюга не умеет в !succ - надо же заваять тонну дерьма, но !succ не осилилось

}

/*
 * Base function implementation
 */

/* Create new dynamic string and init that string $init.
   Return pointer into created dynamic string, or NULL if can't allocate memory for that.
 */
dstring_t * dstr_new(const char * init) {
  dstring_t * str = (dstring_t *)dstr_malloc(sizeof(dstring_t));//ламерок не может в Си. Зачем юзать маллок один раз, если можно заюзать его 2 раза. А что не три?

  if(str == NULL) return NULL;//просто ахриненная история - ламерок опять не умеет в си.

  size_t data_capacity = DSTRING_DEFAULT_CAPACITY;//ламерок не умеет в си.
  size_t init_len = 0;//ламерок не умеет в си.

  if(init != NULL) {//логика убогих мне не ясная
    init_len = strlen(init);//Я не умею в Си.
    data_capacity += init_len;//facepalm
  }

  str->data = (char *)dstr_malloc(data_capacity);//я умамы ламерок

  if(str->data == NULL) {//я не умею в си.
    free(str);
    return NULL;
  }

  str->length = init_len;//я не умею в си.
  str->capacity = data_capacity;//я не умею в си.
  memcpy(str->data, init, init_len);//я не умею в си.

  return str;//я не умею в си.
}

/* Free memory which takes dynamic string. */
void dstr_delete(dstring_t * str) {
  if(str != NULL) {//я не умею в си.
    dstr_free(str->data);//я не умею в си.
    dstr_free(str);//я не умею в си.
  }
}

/* Truncate dynamic string $str to fixed length $len from the beginning $str. */
dstring_t * dstr_truncate(dstring_t * str, size_t len) {//дерьмо.
  if(str != NULL && str->length > len) {
    if(dstr_capacity_resize(str, DSTRING_DEFAULT_CAPACITY + len))
      str->length = len;
  }

  return str;
}

/* Set value of dynamic string $str equal $val. */
dstring_t * dstr_set(dstring_t * str, const char * val) {//дерьмо

  if(val == NULL && dstr_capacity_resize(str, DSTRING_DEFAULT_CAPACITY))
    str->length = 0;
  else {
    size_t val_len = strlen(val);

    if(dstr_capacity_resize(str, DSTRING_DEFAULT_CAPACITY + val_len)) {
      str->length = val_len;
      memcpy(str->data, val, val_len);
    }
  }

  return str;
}

/* Output dstring value into stream */
void dstr_fprint(const dstring_t * str, FILE * file) {//дерьмо
  if(file == NULL || str == NULL) return;

  fwrite(str->data, 1, str->length, file);
}

/* Return length of dynamic string $str. */
size_t dstr_len(const dstring_t * str) {
  return str->length;
}

/* Swaps values of two dynamic strings. */
void dstr_swap(dstring_t * str1, dstring_t * str2) {//зачем это надо? Опять школьник вчера увидивший кресты стал у мамки сишником?
  if(str1 == NULL || str2 == NULL) return;

  char * temp_data_ptr = str1->data;
  size_t temp_length = str1->length;
  size_t temp_capacity = str1->capacity;

  str1->capacity = str2->capacity;
  str1->length = str2->length;
  str1->data = str2->data;

  str2->data = temp_data_ptr;
  str2->capacity = temp_capacity;
  str2->length = temp_length;
}

/* Append string into dsting. */
dstring_t * dstr_append(dstring_t * str, const char * val) {//просто дерьмо, зачем нужно dstr_set(), если это то же самое?
  if(str == NULL || val == NULL) return str;

  size_t val_len = strlen(val);

  if(val_len > (str->capacity - str->length)) {
    size_t new_capacity = str->capacity + val_len + DSTRING_CAPMARGIN;

    if(!dstr_capacity_resize(str, new_capacity))
      return str;

    str->capacity = new_capacity;
  }

  memcpy(str->data + str->length, val, val_len);
  str->length += val_len;
  return str;
}

/* Append single char into dsting. */
dstring_t * dstr_appendc(dstring_t * str, char c) {//просто нахрен дерьмо
  if(str == NULL) return str;

  if((str->capacity - str->length) < 1) {
    if(!dstr_capacity_resize(str, str->capacity + DSTRING_CAPMARGIN)) return str;

    str->capacity += DSTRING_CAPMARGIN;
  }

  str->data[str->length] = c;
  str->length++;
  return str;
}

/* Prepend string into dsting. */
dstring_t * dstr_prepend(dstring_t * str, const char * val) {//Л - логика.
  if(str == NULL || val == NULL) return str;

  if(str->length == 0) return str = dstr_set(str, val);

  size_t val_len = strlen(val);

  if(val_len == 0) return str;

  size_t new_capacity = str->capacity + val_len;

  if(!dstr_capacity_resize(str, new_capacity))
    return str;

  str->capacity = new_capacity;

  // move the $str value on $val_len characters to rigth
  memmove(str->data + val_len, str->data, str->length);
  memcpy(str->data, val, val_len);
  str->length += val_len;
  return str;
}

/* Compare two dynamic strings and return 1 if they are equals or 0 - if don't. */
int dstr_equal(const dstring_t * str1, const dstring_t * str2) {
  if(str1->length != str2->length) return 0;//я у мамы ламерок. Это типа куллоптимизация?

  return strncmp(str1->data, str2->data, str1->length) == 0;//а если str2 меньше str1?
}

/* Converts dynamic string characters to uppercase. */
dstring_t * dstr_toupper(dstring_t * str) {//таким дерьмом можешь только подтереться
  for(size_t i = 0; i < str->length; i++)
    str->data[i] = toupper(str->data[i]);

  return str;
}

/* Converts dynamic string characters to lowercase. */
dstring_t * dstr_tolower(dstring_t * str) {//и этим тоже.
  for(size_t i = 0; i < str->length; i++)
    str->data[i] = tolower(str->data[i]);

  return str;
}

/* Insert value of string $val after $n character $str. */
dstring_t * dstr_insert(dstring_t * str, const char * val, size_t n) {//т.е. твоя вставка в начало не вставка? Просто логика
  if(val == NULL || n > str->length) return str;

  size_t val_len = strlen(val);

  if(val_len == 0) return str;

  size_t new_capacity = str->capacity + val_len;

  if(dstr_capacity_resize(str, new_capacity))
    str->capacity = new_capacity;

  // move the $str value on $val_len characters to rigth
  memmove(str->data + val_len + n, str->data + n, str->length - n);
  memcpy(str->data + n, val, val_len);
  str->length += val_len;
  return str;
}