#include "String.h"
#include <memory>

//-----------------------------------------------------------------------------------------------------------------------------
String::String(const char* pData)
{
  if (!pData) return;

  m_uiLength = StringLength(pData);
  m_pData = new char[m_uiLength + 1];
  memset(m_pData, 0, m_uiLength + 1);
  memcpy(m_pData, pData, m_uiLength);
  m_uiCapacity = m_uiLength;
}

//-----------------------------------------------------------------------------------------------------------------------------
String::String(const std::string &sString)
  : m_pData(new char[sString.length()])
  , m_uiLength(sString.length())
  , m_uiCapacity(sString.length())
{
}

//-----------------------------------------------------------------------------------------------------------------------------
String::String(const String& sRhs)
  : m_uiLength(sRhs.m_uiLength)
  , m_pData(new char[sRhs.m_uiLength + 1])
  , m_uiCapacity(sRhs.m_uiCapacity)
{
  memset(m_pData + m_uiLength, 0, 1);
  memcpy(m_pData, sRhs.m_pData, m_uiLength);
}

//-----------------------------------------------------------------------------------------------------------------------------
String::~String()
{
  DELETE_ARRAY(m_pData);
}

//-----------------------------------------------------------------------------------------------------------------------------
int String::StringLength(const char* pChar)
{
  int iRet = 0;
  while (*pChar != 0x0)
  {
    pChar++;
    iRet++;
  }
  return iRet;
}

//-----------------------------------------------------------------------------------------------------------------------------
void String::Insert(const char *pData, unsigned int uiPos)
{
  if (!pData) return;

  unsigned int uilength = StringLength(pData);
  unsigned int uiNewLength = m_uiLength + uilength;

  while (uiNewLength > m_uiCapacity)
  {
    IncreaseCapacity();
  }

  char* pLeft = m_pData + uiPos;
  char* pRight = m_pData + uiPos + uilength;

  memcpy(pRight, m_pData + uiPos, m_uiLength - uiPos);
  memcpy(pLeft, pData, uilength);

  m_uiLength = uiNewLength;
}

//-----------------------------------------------------------------------------------------------------------------------------
void String::Append(const char *pData)
{
  Insert(pData, m_uiLength);
}

//-----------------------------------------------------------------------------------------------------------------------------
bool String::Contains(const String& sRhs)
{
  return Contains(sRhs.m_pData);
}

//-----------------------------------------------------------------------------------------------------------------------------
bool String::Contains(const char *pData)
{
  int iRet = 1;
  unsigned int uiLength = StringLength(pData);
  unsigned int uiOffset = 0;

  while (iRet != 0)
  {
    if (uiLength > m_uiLength || uiOffset > m_uiLength) break;
    iRet = memcmp(m_pData + uiOffset, pData, uiLength);
    uiOffset++;
  }

  return iRet == 0;
}

//-----------------------------------------------------------------------------------------------------------------------------
unsigned int String::Find(const String& sRhs, unsigned int uiOffset)
{
  return Find(sRhs.m_pData, uiOffset);
}

//-----------------------------------------------------------------------------------------------------------------------------
unsigned int String::Find(const char *pData, unsigned int uiOffset)
{
  unsigned int uiLength = StringLength(pData);
  unsigned int uiCurrentOffset = uiOffset;

  for (int iRet = 1; iRet != 0; uiCurrentOffset++)
  {
    if (uiLength > m_uiLength || uiCurrentOffset > m_uiLength)
    {
      uiCurrentOffset = -1;
      break;
    }
    iRet = memcmp(m_pData + uiCurrentOffset, pData, uiLength);
  }

  return uiCurrentOffset;
}

//-----------------------------------------------------------------------------------------------------------------------------
char String::At(unsigned int uiPos)
{
  return *(m_pData + uiPos);
}

//-----------------------------------------------------------------------------------------------------------------------------
bool String::Remove(const String& sRhs)
{
  return RemoveAt(Find(sRhs), sRhs.m_uiLength);
}

//-----------------------------------------------------------------------------------------------------------------------------
bool String::Remove(const char *pData)
{
  return RemoveAt(Find(pData), StringLength(pData));
}

//-----------------------------------------------------------------------------------------------------------------------------
bool String::RemoveAt(unsigned int uiPos, unsigned int uiSize)
{
  if (uiPos > m_uiLength) return false;

  m_uiLength = m_uiLength - uiSize;
  char* pLast = m_pData + uiPos + uiSize;
  memcpy(m_pData + uiPos, pLast, uiSize);
  memset(pLast, 0, uiSize);

  return true;
}

//-----------------------------------------------------------------------------------------------------------------------------
unsigned int String::Length() const
{
  return m_uiLength;
}

//-----------------------------------------------------------------------------------------------------------------------------
std::string String::ToStdString()
{
  return std::string(m_pData);
}

//-----------------------------------------------------------------------------------------------------------------------------
void String::IncreaseCapacity()
{
  m_uiCapacity = m_uiCapacity * c_uiCapacityIncreaseFactor;
  char *pNew = new char[m_uiCapacity + 1];
  memset(pNew, 0, m_uiCapacity + 1);
  memcpy(pNew, m_pData, m_uiLength);
  DELETE_ARRAY(m_pData);
  m_pData = pNew;
}