//
// created by fouteen98
//
#include <stdexcept>
//#include <iostream>
#include "my_string.h"
my_string::my_string()
{
    str_len = 1;
    c_ptr = new char [str_len];
    c_ptr[0] = '\0';
    //ctor
}

my_string::my_string(const char *str)
{
    str_len = length(str) + 1;
    c_ptr = new char [str_len];
    for (size_t i = 0; i < str_len; i++)
        c_ptr[i] = str[i];
    c_ptr[str_len -1] = '\0';

}

my_string::my_string(const my_string &obj)
{
    delete [] c_ptr;
    str_len = obj.str_len;
    c_ptr = new char [str_len];
    for(size_t i = 0; i < str_len; i++){
        c_ptr[i] = obj.c_ptr[i];
    }
}

my_string::~my_string()
{
        delete [] c_ptr;
        c_ptr = nullptr;

//dtor
}

int my_string::length(){
    size_t i = 0;
    for(; c_ptr[i] != '\0'; i++);
    return i;
}
int my_string::length(const char *str){ // private
    size_t i = 0;
    for(; str[i] != '\0'; i++);
    return i;
}

char my_string::at(size_t pos) {
    return c_ptr[pos];
}

void my_string::swap(my_string &obj) {
    char *temp = c_ptr;
    c_ptr = obj.c_ptr;
    obj.c_ptr = temp;
    size_t len = str_len;
    str_len = obj.str_len;
    obj.str_len = len;
}

void my_string::swap(char *str) {
    size_t len = length(str);
    c_ptr = str;
    str_len = len;
}




my_string& my_string::append(const my_string& obj) {
    size_t s1 = length(), s2 = length(obj.c_ptr), size = s1 + s2;
    char *temp =  new char [size + 1];
    for(size_t i = 0; i < s1; ++i)
        temp[i] = c_ptr[i];
    for(size_t i = 0; i < s2 + 1; ++i)
        temp[i + s1 - 1] = obj.c_ptr[i];
    temp[size - 1] = '\0';
    delete[]c_ptr;
    str_len = size;
    c_ptr = temp;
    return *this;
}

my_string& my_string::append(const char *str) {
    size_t len = length(str);
    size_t size = length() + len;
    char *temp = new char [size + 1];
    for(size_t i = 0; i < str_len - 1; ++i)
        temp[i] = c_ptr[i];
    for(size_t i = 0; i < len; ++i)
        temp[i + str_len - 1] = str[i];
    delete [] c_ptr;
    str_len = size;
    c_ptr = temp;

    return *this;
}

my_string &my_string::prepend(const my_string &obj) {
    my_string end_result(obj.c_ptr);
    *this = end_result.append(*this);
    return *this;
}

my_string &my_string::prepend(const char *str) {
    my_string end_result(str);
    *this = end_result.append(*this);
    return *this;
}

my_string my_string::substr(size_t pos, size_t len) {
    size_t length = (len > str_len - pos) ? (str_len - pos) : len;
    char * temp(new char [length + 1]);
    for(size_t i = 0; i < length; i++)
        temp[i] = c_ptr[i + pos];
    temp[length] = '\0';

    return my_string(temp);
}




my_string& my_string::insert(std::size_t pos, const my_string &obj){
    size_t size = (str_len - 1) + obj.str_len;
    char *temp = new char[size];
   // so the problem was with nested for loop i wrote
    size_t j = 0;
    for (size_t i = 0; i < size; ++i, ++j) {
        if (i == pos)
            for (size_t k = 0; k < (obj.str_len - 1); ++k, ++i)
                temp[i] = obj.c_ptr[k];
        temp[i] = c_ptr[j];
    }
    delete [] c_ptr;
    c_ptr = temp;
    str_len = size;
    return *this;
}
my_string& my_string::insert(size_t pos, const char *str){
    size_t size = (str_len - 1) + length(str);
    char *temp = new char[size];
    // so the problem was with nested for loop i wrote
    size_t j = 0;
    for (size_t i = 0; i < size; ++i, ++j) {
        if (i == pos)
            for (size_t k = 0; k < length(str); ++k, ++i)
                temp[i] = str[k];
        temp[i] = c_ptr[j];
    }
    delete [] c_ptr;
    c_ptr = temp;
    str_len = size;
    return *this;

}

/* this works: but commented them because of performance
my_string &my_string::insert(size_t pos, const char *str) {
    my_string end_results;
    my_string first = substr(0, pos);
    my_string second = substr(pos);
    end_results.append(first);
    end_results.append(str);
    end_results.append(second);
    new(this)my_string(end_results);
    return *this;
}




my_string& my_string::insert(std::size_t pos, const my_string &obj){

    my_string end_results;
    my_string first = substr(0, pos);
    my_string second = substr(pos);
    end_results.append(first);
    end_results.append(obj.c_ptr);
    end_results.append(second);
    new(this)my_string(end_results);
    return *this;
}
*/
// overloaded operators
my_string& my_string ::operator=(const my_string& obj){
    if (this != &obj) {
        delete[] c_ptr;
        str_len = obj.str_len;
        c_ptr = new char[str_len];
        for (std::size_t i = 0; i < str_len; i++)
            c_ptr[i] = obj.c_ptr[i];
    }
    return *this;
}

my_string &my_string::operator=(const char *str) {
    *this = my_string(str);
    return *this;
}
my_string &my_string::operator=(my_string &&str) noexcept {
    this->~my_string();
    new(this)my_string(std::move(str));

    return *this;
}



size_t my_string::operator[](const size_t pos) {
    if (pos < 0 || pos >= str_len - 1)
        return -1;
    else
        return c_ptr[pos];
}

my_string my_string::operator+(const my_string &obj) {
    size_t s1 = length(), s2 = length(obj.c_ptr), size = s1 + s2 + 1;
    char *temp =  new char [size + 1];
    for(size_t i = 0; i < s1; ++i)
        temp[i] = c_ptr[i];
    for(size_t i = 0; i < s2 + 1; ++i)
        temp[i + s1] = obj.c_ptr[i];
    temp[size - 1] = '\0';
    delete[]c_ptr;
    str_len = size;
    c_ptr = temp;
    return *this;
}

my_string my_string::operator+(const char *str) {
    size_t len = length(str);
    size_t size = length() + len;
    char *temp = new char [size + 1];
    for(size_t i = 0; i < str_len - 1; ++i)
        temp[i] = c_ptr[i];
    for(size_t i = 0; i < len; ++i)
        temp[i + str_len - 1] = str[i];
    delete [] c_ptr;
    str_len = size;
    c_ptr = temp;
    return *this;
}

my_string my_string::operator+=(const my_string &obj) {
    size_t s1 = length(), s2 = length(obj.c_ptr), size = s1 + s2 + 1;
    char *temp =  new char [size + 1];
    for(size_t i = 0; i < s1; ++i)
        temp[i] = c_ptr[i];
    for(size_t i = 0; i < s2 + 1; ++i)
        temp[i + s1] = obj.c_ptr[i];
    temp[size - 1] = '\0';
    delete[]c_ptr;
    str_len = size;
    c_ptr = temp;
    return *this;
}

my_string my_string::operator+=(const char *str) {
    size_t len = length(str);
    size_t size = length() + len;
    char *temp = new char [size + 1];
    for(size_t i = 0; i < str_len - 1; ++i)
        temp[i] = c_ptr[i];
    for(size_t i = 0; i < len; ++i)
        temp[i + str_len - 1] = str[i];
    delete [] c_ptr;
    str_len = size;
    c_ptr = temp;
    return *this;
}

// friend functions
std::ostream& operator<< (std::ostream &str, const my_string &obj){
    str << obj.c_ptr;
    return str;
}
std::istream& operator>> (std::istream &str, const my_string &obj){
    str >> obj.c_ptr;
    return str;
}