#include "../inc/mystring_.h"
#include <cstring>
#include <time.h>
#include <vector>
#include <algorithm>
using namespace std;
mystring_::mystring_(/* args */) : m_str("")
{
}

mystring_ operator+(const mystring_ &str1, const mystring_ &str2)
{
 size_t len = strlen(str1.m_str) + strlen(str2.m_str) + 1;
 mystring_ strtotal;
 strtotal.m_str = new char[len + 1];
 memset(strtotal.m_str, 0, len);
 memcpy(strtotal.m_str, str1.m_str, strlen(str1.m_str));
 strcat(strtotal.m_str, str2.m_str);
 return strtotal;
}

mystring_::mystring_(const mystring_ &mystr)
{
 if (&mystr == this)
 {
 return;
 }

 if (mystr.m_str == nullptr)
 {
 m_str = nullptr;
 return;
 }
 size_t len = strlen(mystr.m_str);
 m_str = new char[len + 1];
 strcpy(m_str, mystr.m_str);
 m_str[len] = '0円';
}

mystring_::mystring_(const char *mstr)
{
 cout << "use mystring_ construct , param is const char *" << endl;
 size_t len = strlen(mstr);
 m_str = new char[len + 1];
 strcpy(m_str, mstr);
 m_str[len] = '0円';
}

mystring_::mystring_(const string str)
{
 cout << "use mystring_ construct string str" << endl;
 size_t len = str.length();
 m_str = new char[len + 1];
 strncpy(m_str, str.c_str(), len);
 m_str[len] = '0円';
}

mystring_::~mystring_()
{
 if (m_str == "" || m_str == nullptr)
 {
 cout << "begin destruct , str is null or empty" << endl;
 }
 else
 {
 cout << "begin destruct " << m_str << endl;
 }

 if (m_str == nullptr || m_str == "")
 {
 return;
 }

 delete[] m_str;
 m_str = nullptr;
}

mystring_ &mystring_::operator=(const mystring_ &mystr)
{
 if (&mystr == this)
 {
 return *this;
 }

 if (this->m_str != nullptr)
 {
 delete[] m_str;
 this->m_str = nullptr;
 }

 if (mystr.m_str == nullptr)
 {
 m_str = nullptr;
 }

 size_t len = strlen(mystr.m_str);
 m_str = new char[len + 1];
 strcpy(m_str, mystr.m_str);
 m_str[len] = '0円';
 return *this;
}

mystring_ &mystring_::operator=(string str)
{
 cout << "use operator = string str" << endl;
 if (this->m_str != nullptr)
 {
 delete[] m_str;
 this->m_str = nullptr;
 }

 size_t len = str.length();
 m_str = new char[len + 1];
 strncpy(m_str, str.c_str(), len);
 m_str[len] = '0円';
 return *this;
}

mystring_ &mystring_::operator=(const char *cstr)
{
 cout << "use operator = const char*" << endl;
 if (this->m_str != nullptr)
 {
 delete[] m_str;
 this->m_str = nullptr;
 }

 size_t len = strlen(cstr);
 m_str = new char[len + 1];
 strncpy(m_str, cstr, len);
 m_str[len] = '0円';
 return *this;
}

ostream &operator<<(ostream &os, const mystring_ &mystr1)
{
 if (mystr1.m_str == nullptr)
 {
 os << "mystring_ data is null" << endl;
 return os;
 }
 os << "mystring_ data is " << mystr1.m_str << endl;
 return os;
}

char mystring_::operator[](unsigned int index)
{
 if (index >= strlen(m_str))
 {
 throw "index out of range!!!";
 }

 return m_str[index];
}

bool mystringOpr_::operator()(const mystring_ &str1, const mystring_ &str2)
{
 if (strlen(str1.m_str) > strlen(str2.m_str))
 {
 return true;
 }

 if (strlen(str1.m_str) < strlen(str2.m_str))
 {
 return false;
 }

 for (unsigned int i = 0; i < strlen(str1.m_str); i++)
 {
 return str1.m_str[i] > str2.m_str[i];
 }
}

void use_mystr_1()
{
 auto mystr1 = mystring_("hello zack");
 auto mystr2(mystr1);
 auto mystr3 = mystring_();
 cout << mystr1 << mystr2 << mystr3 << endl;
 mystring_ mystr4 = ", i love u";
 auto mystr5 = mystr1 + mystr4;
 cout << "mystr4 is " << mystr4 << endl;
 cout << "mystr5 is " << mystr5 << endl;

 mystring_ mystr6 = "";
 auto mystr7 = mystr5 + mystr6;
 cout << "mystr7 is " << mystr7 << endl;

 auto ch = mystr1[4];
 cout << "index is 4, char is " << ch << endl;

 std::vector<mystring_> vec_mystring_;
 vec_mystring_.push_back(mystr1);
 vec_mystring_.push_back(mystr2);
 vec_mystring_.push_back(mystr3);
 vec_mystring_.push_back(mystr4);
 vec_mystring_.push_back(mystr5);
 vec_mystring_.push_back(mystr6);
 vec_mystring_.push_back(mystr7);
 sort(vec_mystring_.begin(), vec_mystring_.end(), mystringOpr_());
 cout << "====================after sort ..." << endl;
 for_each(vec_mystring_.begin(), vec_mystring_.end(), [](const mystring_ &str)
 { cout << str << endl; });
}

void use_mystr_2()
{
 //直接初始化
 mystring_ mystr1("hello zack");
 //直接初始化
 auto mystr2(mystr1);
 //拷贝初始化
 auto mystr3 = mystr2;
 //拷贝初始化
 mystring_ mystr4 = "hello world!";
 //拷贝初始化
 auto mystr5 = mystring_("hello everyone");
 cout << mystr1 << mystr2 << mystr3 << mystr4 << mystr5 << endl;
}

HasPtr f(HasPtr hp)
{
 HasPtr copyptr = hp;
 return copyptr;
}

void use_mystr_3()
{
 HasPtr ptr("hello zack!");
 f(ptr);
}

void use_mystr()
{
 HasPtr hasptr1("hello zack");
 cout << hasptr1 << endl;
 HasPtr hasptr2(hasptr1);
 cout << hasptr2 << endl;
 HasPtr hasptr3 = hasptr2;
 cout << hasptr3 << endl;
 HasPtr hasptr4("hello world");
 hasptr4 = hasptr3;
 cout << hasptr4 << endl;
}

HasPtr::HasPtr(const string &str) : m_str(new string(str)), m_index(++_curnum)
{
 cout << "this is param constructor" << endl;
}
int HasPtr::_curnum = 0;
HasPtr::~HasPtr()
{
 if (m_str != nullptr)
 {
 delete m_str;
 m_str = nullptr;
 }
}

HasPtr::HasPtr(const HasPtr &hp)
{
 cout << "this is copy construtor" << endl;
 if (&hp != this)
 {
 this->m_str = new string(string(*hp.m_str));
 int seconds = time((time_t *)NULL);
 _curnum++;
 this->m_index = _curnum;
 }

 return;
}

// HasPtr &HasPtr::operator=(const HasPtr &hp)
// {
// cout << "this is operator = " << endl;
// if (&hp != this)
// {
// this->m_str = new string(string(*hp.m_str));
// this->m_index = hp.m_index;
// }

// return *this;
// }

HasPtr &HasPtr::operator=(HasPtr hptr)
{
 // hptr是一个局部变量
 //交换后hptr.m_str指向this.m_str原来指向的内存
 swap(*this, hptr);
 // return返回*this后,hptr自动被回收
 return *this;
}

void swap(HasPtr &hptr1, HasPtr &hptr2)
{
 using std::swap;
 swap(hptr1.m_index, hptr2.m_index);
 swap(hptr1.m_str, hptr2.m_str);
}

ostream &operator<<(ostream &os, const HasPtr &hp)
{
 os << "index is " << hp.m_index << " , data is " << *(hp.m_str) << endl;
 return os;
}

SharePtr::SharePtr(const SharePtr &sptr)
{
 //如果是自赋值则跳过
 if (&sptr == this)
 {
 return;
 }
 //其他类对象拷贝给自己
 this->pstr = sptr.pstr;
 //引用计数增加
 (*sptr.usecount)++;
 //拷贝对方的引用计数给自己
 this->usecount = sptr.usecount;
}

SharePtr &SharePtr::operator=(const SharePtr &sptr)
{
 //如果是自赋值则跳过
 if (&sptr == this)
 {
 return *this;
 }

 //减少自己原来的引用计数
 (*this->usecount)--;

 //判断引用计数是否为0
 if (*(this->usecount) == 0)
 {
 //回收原来指向的内存
 delete (this->pstr);
 //回收引用计数内存
 delete (this->usecount);
 }

 //其他类对象拷贝给自己
 this->pstr = sptr.pstr;

 //对方引用计数增加
 (*sptr.usecount)++;
 //拷贝对方的引用计数给自己
 this->usecount = sptr.usecount;
 return *this;
}

SharePtr::~SharePtr()
{
 //引用计数-1
 (*this->usecount)--;
 //引用计数为0,销毁内存
 if (*(this->usecount) == 0)
 {
 cout << "use count is 0 dealloc"
 << endl;
 delete usecount;
 delete pstr;
 return;
 }
}

//获取引用计数
size_t SharePtr::getUseCount()
{
 return *(this->usecount);
}

void test_share()
{
 SharePtr sptr1("hello zack");
 SharePtr sptr2(sptr1);
 cout << "sptr1 use count is "
 << sptr1.getUseCount() << endl;
 cout << "sptr2 use count is "
 << sptr2.getUseCount() << endl;
 SharePtr sptr3("hello world");
 cout << "sptr3 use count is "
 << sptr3.getUseCount() << endl;
 sptr2 = sptr3;
 cout << "sptr1 use count is "
 << sptr1.getUseCount() << endl;
 cout << "sptr2 use count is "
 << sptr2.getUseCount() << endl;
 cout << "sptr3 use count is "
 << sptr3.getUseCount() << endl;
}

void swap_int(int &a, int &b)
{
 int temp = a;
 a = b;
 b = temp;
}