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

//-----------------------------------------------------------------------------------------------------------------------------
LSString::LSString(const char* pData)
  : m_zSize(StringLength(pData))
  , m_uiCapacity(StringLength(pData))
{
  Assign(pData);
}

//-----------------------------------------------------------------------------------------------------------------------------
LSString::LSString(const std::string& sRhs)
  : m_zSize(sRhs.length())
  , m_uiCapacity(sRhs.length())
{
  Assign(sRhs);
}

//-----------------------------------------------------------------------------------------------------------------------------
LSString& LSString::operator=(const LSString& sRhs)
{
  m_zSize = sRhs.Size();
  m_uiCapacity = sRhs.Capacity();
  Assign(sRhs);
  return *this;
}

//-----------------------------------------------------------------------------------------------------------------------------
LSString::LSString(const LSString& sRhs)
  : m_zSize(sRhs.m_zSize)
  , m_uiCapacity(sRhs.m_uiCapacity)
{
  Assign(sRhs);
}

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

//-----------------------------------------------------------------------------------------------------------------------------
void LSString::Assign(const char* pData)
{
  m_pData = new char[m_zSize + 1];
  memset(m_pData, 0, m_zSize + 1);
  if (pData) memcpy(m_pData, pData, m_zSize);
}

//-----------------------------------------------------------------------------------------------------------------------------
void LSString::Insert(const char* pData, size_t zLength, size_t zPos)
{
  if (!pData) return;

  size_t zNewLength = m_zSize + zLength;

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

  char* pLeft = m_pData + zPos;
  char* pRight = m_pData + zPos + zLength;

  memcpy(pRight, m_pData + zPos, m_zSize - zPos);
  memcpy(pLeft, pData, zLength);

  m_zSize = zNewLength;
}

//-----------------------------------------------------------------------------------------------------------------------------
bool LSString::RemoveAt(size_t uiPos, size_t uiSize)
{
  if (uiPos > m_zSize) return false;

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

  return true;
}

//-----------------------------------------------------------------------------------------------------------------------------
size_t LSString::StringLength(const char* pChar) const
{
  if (!pChar) return 0;
  const char* pStart = pChar;
  while (*pChar != 0x0)
  {
      pChar++;
  }
  return pChar - pStart;
}

//-----------------------------------------------------------------------------------------------------------------------------
int LSString::Find(const char * pData, size_t uiOffset, size_t uiLength) const
{
  int iRet = -1;
  while (uiOffset + uiLength <= m_zSize)
  {
    iRet = memcmp(m_pData + uiOffset, pData, uiLength);
    if (iRet == 0) break;
    uiOffset++;
  }
  return iRet;
}

//-----------------------------------------------------------------------------------------------------------------------------
void LSString::IncreaseCapacity(size_t uiNewLength)
{
  m_uiCapacity = uiNewLength * c_uiCapacityIncreaseFactor;
  char* pNew = new char[m_uiCapacity + 1];
  memset(pNew, 0, m_uiCapacity + 1);
  memmove(pNew, m_pData, m_zSize);
  DELETE_ARRAY(m_pData);
  m_pData = pNew;
}