//--------------- MYSTRING.CPP ---------------
// The class definition for fractions.
//
// Michael Arciola

#include "mystring.h"
#include <typeinfo>


MyString::MyString() // -------------------------------------------------- // #1
{
    length = 0;
    data = new char[length + 1];
    data[0] = '';
}

MyString::MyString(const char* s1)
{
    length = strlen(s1);
    data = new char[length + 1];

    for(int i = 0; i < length; i++) {
        data[i] = s1[i];
        //cout << s1[i];
        //cout << data[i];
    }

    data[length + 1] = '';
}

MyString::MyString(int s1)
{
    int temp;
    char c = 'm';
    MyString final;
    int count = 0;
    length = 0;
    data = new char[length + 1];
    int s2;
    s2 = s1;

    while (s1 != 0)
    {
        temp = s1 % 10;
        s1 = s1 / 10;
        c = temp + '0';
        count++;
    }

    length = count;

    for (int i = length - 1; i >= 0; i--)
    {
        temp = s2 % 10;
        s2 = s2 / 10;
        data[i] = temp + '0';
    }


    data[count] = '';

}

// Destructor   ----------------------------------------------------------- // #2
MyString::~MyString()
{
    delete [] data;
}

// Copy Constructor
MyString::MyString(const MyString& s1)
{
    length = s1.length;
    data = new char[length + 1];

    for (int i = 0; i < length; i++)
    {
        data[i] = s1.data[i];
    }

    data[length + 1] = '';
}

// Assignment Operator
MyString& MyString::operator=(const MyString& s1)
{
    if (this != &s1)
    {
        delete [] data;

        length = s1.length;
        data = new char[length + 1];

        for (int i = 0; i < length; i++)
        {
            data[i] = s1.data[i];
        }

        data[length + 1] = '';
    }

    return *this;
}

ostream& operator<< (ostream& os, const MyString& s1) // --------------- -// #3
{
    for (int i = 0; i < s1.length; i++)
    {
        os << s1.data[i];
    }

    return os;
}

istream& operator>> (istream& is, MyString& s1)
{
    // NEED HELP

    /*
    is >> s1;

    return is;
    */
}

istream& getline (istream& is, MyString& s1, char delim)
{
    // NEED HELP
}

bool operator< (const MyString& s1, const MyString& s2)  // ------------- // #4
{
    if (strcmp(s1.data, s2.data) < 0) {
        return true;
    } else {
        return false;
    }
}

bool operator> (const MyString& s1, const MyString& s2)
{
    return s2 < s1;
}

bool operator<=(const MyString& s1, const MyString& s2)
{
    return !(s2<s1);
}

bool operator>=(const MyString& s1, const MyString& s2)
{
    return !(s1<s2);
}

bool operator==(const MyString& s1, const MyString& s2)
{
    return (s1<=s2) && (s1>=s2);
}

bool operator!=(const MyString& s1, const MyString& s2)
{
    return !(s1==s2);
}

MyString operator+ (const MyString& s1, const MyString& s2) // ------------ // #5
{
    MyString newstring;
    int len = s1.length + s2.length;

    newstring.grow(len);

    for (int i = 0; i < s1.length; i++)
    {
        newstring.data[i] = s1.data[i];
    }

    for (int i = 0; i < s2.length; i++)
    {
        newstring.data[s1.length + i] = s2.data[i];
    }


    return newstring;
}

MyString& MyString::operator+=(const MyString& s1)
{
    int start = length;
    int growth = s1.length;
    int totallen = s1.length + length;

    grow(growth, start);

    cout << "Start: " << start << endl;
    cout << "Length: " << length << endl;

    for (int i = start; start < length; i++)
    {
        cout << "data[i]: " << data[i] << endl;
        cout << "s1.data[i]: " << s1.data[i] << endl;
        data[i] = s1.data[i];
    }
}

char& MyString::operator[] (unsigned int index) // ------------------------ // #6
{
    return data[index];
}

const char& MyString::operator[] (unsigned int index) const
{
    return data[index];
}

int MyString::getLength() const // ------------------------------------------ // #7
{
    return length;
}

const char* MyString::getCString() const
{
    return data;
}

MyString MyString::substring(unsigned int start) const // ------------------------- // #8
{
    MyString temp;

    for (int i = start; i < length; i++)
    {
        temp.data[i] = data[i];
        cout << temp.data[i];
    }

    return temp;
}

MyString MyString::substring(unsigned int start, unsigned int size) const
{
    MyString temp;

    if (size + start > length) {
        size = length;
    } else {
        size += start;
    }

    for (int i = start; i < size; i++)
    {
        if (i != size)
        {
            temp.data[i] = data[i];
            cout << temp.data[i];
        }
    }

    return temp;
}

MyString& MyString::insert(unsigned int index, const MyString& s) // ---------- // #9
{
    if (index > length) {
        index = length;
    }

    grow(s.length, index);
    int len = s.length;
    int ph = 0;

        for (int i = index; i < index + len; i++) {
            data[i] = s.data[ph];
            ph += 1;
        }
}

int MyString::indexOf(const MyString& s) const // ------------------------------// #10
{
    int final;

    if (strstr(data, s.data) == 0) {
        final = -1;
    } else {
        final = strstr(data, s.data) - data;
    }

    return final;
}

void MyString::grow(int len) {

    char* temp = new char[length + len + 1];

    for (int i = 0; i < length; i++)
    {
        temp[i] = data[i];
    }

    /* FOR TESTING
    for (int i = length; i < length + len; i++)
    {
        temp[i] = 'm';
    }
    */

    temp[length + len + 1] = '';

    data = temp;
    length = length + len + 1;
}

void MyString::grow(int len, int index) {

    char* temp = new char[length + len + 1];
    int ph = 0;

    for (int i = 0; i < index; i++)
    {
        temp[i] = data[i];
        ph += 1;
    }

    for (int i = index; i < index + len; i++)
    {
        temp[i] = ' ';
    }

    for (int i = index + len; i < length + len + 1; i++)
    {
        temp[i] = data[ph];
        ph += 1;
    }

    temp[length + len + 1] = '';

    data = temp;
    length = length + len + 1;
}

void MyString::reverse() {

    char temp;

    for (int i = 0; i < length/2; i++) { // Loops through array, add value to temp, and move it to the other side of the array
        temp = data[i];
        data[i] = data[length - i -1];
        data[length - i -1] = temp;
        cout << data[i] << endl;

    }

}