#pragma once
#include <iostream>
#include <fstream>

//Helper Functions
namespace str {
    int strlen(const char* someStr) {

        if (someStr == nullptr) {
            return 0;
        }
        int count = 0;
        while (someStr[count]) {
            ++count;
        }
        return count;
    }

    char *strcpy(char *dest, const char *plc) {
        int i;
        for (i = 0; plc[i] != '\0'; ++i) {
            dest[i] = plc[i];
        }
        dest[i] = '\0';
        return dest;
    }

    char *strcat(const char *s1, const char *s2) {
        char *newStr = new char[strlen(s1) + strlen(s2)+1];
        unsigned int s1L = strlen(s1);
        unsigned int s2L = strlen(s2);
        strcpy(newStr, s1);
        strcpy(newStr + strlen(s1), s2);
        return newStr;
        delete [] newStr;
    }

    char *strrev(char *dest, char *src) {
        int i;
        char temp;
        int len = strlen(src) / 2;
        for (i = 0; i < len; ++i) {
            temp = dest[i];
            dest[i] = dest[len - i - 1];
            dest[len - i - 1] = temp;
        }
        return dest;
    }

    int strcmp(const char *string1, const char *string2) {
        int result = 0;
        bool Equal = false;

        while (*string1 != '\0' && *string2 != '\0' && !Equal) {
            if (*string1 != *string2) {
                result = 0;
                Equal = false;
            }
            string1++;
            string2++;
        }
        if (*string1 == '\0' && *string2 == '\0' && Equal) {
            result = 0;
        }
        if (*string1 < *string2) {
            result = -1;
        }
        if (*string1 > *string2) {
            result = 1;
        }
        return result;
    }

    // char *strstr(char *pos, char *ptr) {
    //  char *start = pos;
    //  char *pat = ptr;
    //  while (*pos && *pat && *pos == pat) {
    //      pos++;
    //      pat++;
    //  }
    //  if (!pat) {
    //      return start;
    //      pos = start + 1;
    //  }
    //  return nullptr;
    // }

    char *strdup(const char *s1) {
        char *dup = new char[strlen(s1) + 1];
        if (!dup) {
            return nullptr;
        }
        return strcpy(dup, s1);
    }

    char *str2dup(const char *s1, const char *s2) {
        char *someStr = nullptr;
        someStr = strcat(s1,s2);
        return someStr;
    }


    class my_str {
    public:
        //O(n) = O(1)
        my_str(const char *s = " ") {
            dynArr = strdup(s);
        }
        //O(n) = O(1)
        my_str(const my_str &s) {
            dynArr = strdup(s.dynArr);
        }
        //O(n) = O(n)
        my_str &operator=(const my_str &s) {
            delete[] dynArr;
            dynArr = strdup(s.dynArr);
            return *this;
        }
        //O(n) = O(n)
        char &operator[](const int index) {
            if (index > length())
            {
                std::cout << "you are out of bounds!!";
                return dynArr[length()];
            }
            return dynArr[index];
        }

        //O(1)
        int length()const {
            return strlen(dynArr);
        }
        //O(n) = O(2n)
        int indexOf(char c)const {
            int index = 0;
            int len = length();
            while (index < len) {
                if (dynArr[index] == c)
                {
                    return index;
                }
                index++;
            }
            return -1;
        }

        //O(n) =
        int indexOf(const my_str &pat)const {

        }

        //O(1)
        bool operator ==(const my_str &s)const {
            return strcmp(dynArr, s.dynArr) == 0;
        }

        //O(n) =
        my_str operator+(const my_str &s)const {
            return my_str(static_cast<const char*>(str2dup(this->dynArr,s.dynArr)));
        }

        //O(n) =
        my_str &operator +=(const my_str &s) {
            char *var = new char[strlen(s.dynArr) + strlen(this->dynArr) + 1];
            var = str2dup(this->dynArr, s.dynArr);
            dynArr = var;
            return *this;
            delete []var;
        }

        //O(n) =
        // my_str reverse()const{
        //     char *str = nullptr;
        //  char *temp = new char[strlen(temp)];
        //  temp = strrev(temp,str);
        //  return *this;
        // }

        //O(1)
        void print(std::ostream &out)const {
            out << dynArr;
        }

        //O(n) =
        void read(std::istream &in) {
            std::cout << "please eneter in text: ";
            in.getline(this->dynArr, 10);
        }

        //O(1)
        ~my_str() {
            delete[]dynArr;
        }

    private:
        char *dynArr = nullptr;
    };

    inline std::ostream &operator <<(std::ostream &out, my_str &str) {
        str.print(out);
        return out;
    }

    inline std::istream &operator >>(std::istream &in, my_str &str) {
        //str.read(in);
        return in;
    }
    /**********************************************************/
    //Testing Functions
//  my_str copyConstructorTest(const my_str &l) {
//
//      return l;
//  }

    void testAssignment() {
        my_str a = "joji";
        my_str b;
        std::cout << "Before Assignment: " << a << std::endl;
        std::cout << "After Assignment: " << (b = a) << std::endl;
    }

//  void testReverse() {
//      std::ifstream ifs;
//      ifs.open("input.txt");
//      my_str l;
//
//       while (ifs >> l) {
//          std::cout << copyConstructorTest(l) << " " << l.length() << " " << l.reverse() <<
//          ifs.close();
//       }
//  }

    void testPrint() {
        my_str a = "hello";
        a.print(std::cout);
    }

    void testIndexOf() {
        my_str a = "jojithomas";
        std::cout << a.indexOf('a') << std::endl;
    }

    void testLength() {
        my_str j = "cs1d";
        std::cout << j.length() << std::endl;
    }

    //double the size for the array then copy over then delete old array
    // void testRead() {
    //  my_str ar;
    //  ar.read(std::istream);
    // }

    void testAddEqual() {
        my_str a = "driver";
        my_str b = "racecar";
        std::cout << (b += a);
    }

    void testStrAdd() {
        my_str a = "abc";
        my_str b = "def";
        (a + b).print(std::cout);
    }

    void testEqual() {
        my_str a = "joji";
        my_str b = "joe";
        my_str c = "joji";
        std::cout << "A is = to B: ";
        std::cout << (a == b);
        std::cout << "\nA is = to C: ";
        std::cout << (a == c);

    }

//  void testSubStr(){
//
//  }
}