#include "stdafx.h"

#include "alloc.h"

#include "kryString.h"

kryString::kryString() : m_capacity(0), m_length(0), m_str(kry_strdup(""))
{
}

kryString::kryString(const char *str)
{
  this->m_str = kry_strdup(str);
  this->m_length = g_utf8_strlen(m_str, -1);
  this->m_capacity = this->m_length;
}

kryString::kryString(const char *str, int start, int count)
{
  char *str_start = g_utf8_offset_to_pointer(str, start);
  char *str_end = g_utf8_offset_to_pointer(str, start + count);
  char tmp = str_end[0];
  str_end[0] = 0;

  this->m_str = kry_strdup(str_start);
  this->m_length = g_utf8_strlen(m_str, -1);
  this->m_capacity = this->m_length;

  str_end[0] = tmp;
}

kryString::kryString(const kryString &str)
{
  this->m_str = kry_strdup(str.m_str);
  this->m_length = str.m_length;
  this->m_capacity = this->m_length;
}

kryString::~kryString()
{
  this->Empty();
}

gboolean kryString::IsEmpty()
{
  return this->m_length == 0;
}

int kryString::GetLength()
{
  return this->m_length;
}

gunichar kryString::operator [] (int index)
{
  return g_utf8_get_char(g_utf8_offset_to_pointer(this->m_str, index));
}

void kryString::Empty()
{
  if(this->m_str)
    kry_free(this->m_str);

  this->m_str = NULL;
  this->m_length = 0;
  this->m_capacity = 0;
}

kryString kryString::Mid(int start, int count)
{
  kryString newString = kryString(m_str, start, count);
  return newString;
}

kryString kryString::Mid(int start)
{
  kryString newString = this->Mid(start, this->m_length - start);
  return newString;
}

kryString kryString::Left(int count)
{
  return this->Mid(0, count);
}

int kryString::Find(char chr, int start)
{
  if(this->m_length == 0)
    return -1;

  char *match = g_utf8_strchr(g_utf8_offset_to_pointer(this->m_str, start), -1, chr);
  if(match == NULL)
    return -1;

  return g_utf8_pointer_to_offset(this->m_str, match);
}

int kryString::Find(char *target, int start)
{
  unsigned int target_length = strlen(target);
  int pos = start;
  char *ptr_buff = g_utf8_offset_to_pointer(this->m_str, start);

  do
  {
    if(!strncmp(ptr_buff, target, target_length))
      return pos;

    pos++;
  } while((ptr_buff = g_utf8_next_char(ptr_buff)) != NULL && strlen(ptr_buff) >= target_length);

  return -1;
}

char *kryString::GetBuffer()
{
  return this->m_str;
}

gboolean match_chr(gunichar chr, char *targets)
{
  for(unsigned int i = 0; i < strlen(targets); i++)
    if((char) chr == targets[i])
      return TRUE;

  return FALSE;
}

kryString & kryString::Trim(char *targets)
{
  char *ptr = this->m_str;
  int left_trim = 0;
  for(int i = 0; i < this->m_length; i++)
  {
    gunichar chr = g_utf8_get_char(ptr);
    if(match_chr(chr, targets))
      left_trim++;
    else
      break;

    ptr = g_utf8_next_char(ptr);
  }

  if(left_trim != 0)
  {
    char *new_str = kry_strdup(g_utf8_offset_to_pointer(this->m_str, left_trim));
    kry_free(this->m_str);
    this->m_str = new_str;
    this->m_length -= left_trim;
    this->m_capacity = this->m_length;
  }

  char *end = g_utf8_offset_to_pointer(this->m_str, this->m_length);
  while(end && (end = g_utf8_prev_char(end)))
  {
    gunichar chr = g_utf8_get_char(end);
    if(match_chr(chr, targets))
    {
      end[0] = 0;
      this->m_length--;
    }
    else
    {
      break;
    }
  }

  return *this;
}

/*void kryString::Replace(char *s1, char *s2)
{
}*/

void kryString::operator +=(gunichar chr)
{
  if(this->m_length == this->m_capacity)
  {
    int bytes = this->m_length * 8;
    if(bytes == 0)
      bytes = 4;

    bytes += 2;

    char *newStr = (char *) kry_malloc(bytes);
    memset(newStr, 0, strlen(this->m_str) + 1);
    memcpy(newStr, this->m_str, strlen(this->m_str));

    if(this->m_str)
      kry_free(this->m_str);

    this->m_str = newStr;
    this->m_capacity *= 2;

    if(this->m_capacity == 0)
      this->m_capacity++;
  }

  char *end = g_utf8_offset_to_pointer(this->m_str, this->m_length);
  char buffer[6];
  int b = g_unichar_to_utf8(chr, buffer);
  int i;
  for(i = 0; i < b; i++)
    end[i] = buffer[i];

  end[i] = 0;


  this->m_length++;
}

void kryString::operator =(char *str)
{
  char *ptr = this->m_str;

  this->m_str = kry_strdup(str);
  this->m_length = g_utf8_strlen(str, -1);
  this->m_capacity = this->m_length;

  if(ptr)
    kry_free(ptr);
}

void kryString::operator =(const kryString &str)
{
  char *ptr = this->m_str;

  this->m_str = kry_strdup(str.m_str);
  this->m_length = g_utf8_strlen(this->m_str, -1);
  this->m_capacity = this->m_length;

  if(ptr)
    kry_free(ptr);

}

/*kryString & kryString::operator +(kryString &str)
{
  return str;
}*/

gboolean operator==(kryString &str, char *str2)
{
  return !strcmp(str.GetBuffer(), str2);
}