#pragma once
#include "LSFramework.Exports.h"
#include "LSMacros.h"

#include <vector>

template <class T>

class LSFRAMEWORK_API LSVector
{
public:

  LSVector()
  {
  }

  LSVector(size_t zSize)
  {
    m_pData = new T[zSize];
    m_zCapacity = zSize;
  }

  LSVector(const LSVector& oRhs)
    : m_pData(oRhs.m_pData)
    , m_zSize(oRhs.m_zSize)
    , m_zCapacity(oRhs.m_zCapacity)
  {
  }

  ~LSVector()
  {
    DELETE_ARRAY(m_pData)
  }

  T& PushBack(T oNewobj)
  {
    return Assign(oNewobj);
  }

  T& Assign(T oNewobj)
  {
    if (m_zSize == m_zCapacity)
    {
      m_zCapacity *= c_dCapacityIncreaseFactor;
      T* pNew = new T[m_zCapacity];
      memmove(pNew, m_pData, m_zSize);
      DELETE_ARRAY(m_pData);
      m_pData = pNew;
    }
    m_zSize += 1;
    m_pData[m_zSize] = oNewobj;
    return m_pData[m_zSize];
  }

  T& Insert(T oNewobj, const size_t zPos)
  {
    if (zPos == m_zCapacity)
    {
      return Assign(oNewobj);
    }
    else
    {
      m_pData[zPos] = oNewobj;
      return m_pData[zPos];
    }
  }

  void PopBack()
  {
    Remove(m_zSize);
  }

  void Remove(const size_t zPos)
  {
    memset(m_pData[zPos], 0, sizeof(T));
  }

  T& At(const size_t zPos)
  {
    return m_pData[zPos];
  }

  void Reserve(const size_t zNewCapacity)
  {
    if (zNewCapacity < m_zCapacity) return;
    T* pOld = m_pData;
    m_pData = new T[zNewCapacity];
    memmove_s(m_pData, zNewCapacity, pOld, m_zSize);
    m_zCapacity = zNewCapacity;
    DELETE_ARRAY(pOld);
  }

  void Clear()
  {
    DELETE_ARRAY(m_pData)
  }

  size_t Size() const
  {
    return m_zSize;
  }

  size_t Capacity() const
  {
    return m_zCapacity;
  }

  T* Data() const
  {
    return m_pData;
  }

  LSVector operator=(const LSVector oRhs)
  {
    LSVector vTemp();
    vTemp.m_pData = oRhs.m_pData;
  }

  T& operator[](const size_t _Pos)
  {
    m_pData + _Pos * sizeof(T);
  }

private:

  std::vector<int> s;
  T* m_pData = nullptr;
  size_t m_zSize = 0;
  size_t m_zCapacity = 0;
  const float c_dCapacityIncreaseFactor = 1.5;
};