#include <iostream>
#include "ArrayUtils.h"
#include <sstream>
#include <cstring>
#include <algorithm>

using namespace std;

const size_t MAX_SIZE = 10;
const string TEST_ARRAY[] = { "Alpha", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf", "Hotel", "India", "Juliett"};

bool TestPrintArray(void);
bool TestLoadArray(void);
bool TestStoreArray(void);
bool TestFindCommon(void);
bool TestMerge(void);
bool TestFindDiff(void);
bool TestFind(void);
bool TestSort(void);
bool TestCopy(void);
bool TestAppendToArray(void);
bool TestDeleteFromArray(void);


// this is about the only reason to have a global variable.
bool GLOBAL_DEBUG = false;


const string HOME_DIR = "/home/CS/dbennett/230/hw3B/data";


int main(int argc, char * argv[]) {

     int i=1;
     

     while (i < argc) {
         if (strcmp(argv[i], "-d") == 0) {
            GLOBAL_DEBUG = true;
            i++;
         } else {
            cout << "Unknown Arg " << argv[i] << endl;
            i++;
         }
     }

     TestPrintArray();
     TestLoadArray();
     TestStoreArray();
     TestFindCommon();
     TestMerge();
     TestFindDiff();
     TestFind();
     TestSort();
     TestCopy();
     TestAppendToArray();
     TestDeleteFromArray();

     return 0;
}

bool cmp(string a, string b) {
   return a < b;
}

void MyPrintArray(const string ary[], size_t size) {
    size_t i;

    cout <<"{";
    if (size > 0) {
       cout << ary[0] ;
    }

    for(i=1; i < size; i++) {
       cout << ", " << ary[i];
    }
    cout << "} ";

    return;

}

bool CheckPrintResult(string result, const string ary[], size_t size) {
    size_t i, letterOffset;
    string outName;
    char endlChar;

    bool error = false;
   
    letterOffset = 0;

    for(i=0;i<size; i++) {

        letterOffset = result.find('\n');
        outName = result.substr(0,letterOffset);
        endlChar = result[letterOffset];

        result = result.substr(letterOffset+1, string::npos);

        if (ary[i] != outName) {
           cout << "\n\tOutput error, should be \"" << ary[i] << "\" but is \"" 
                << outName << "\"" << endl;
           error = true;
        }

        if ( endlChar != '\n') {
           cout << "\n\tOutput error, newline missing on line " << i << endl;
           error = true;
        }
    }
    if (result != "") {
        cout << "\n\tError, extra output" << endl;
        error = true;
    }

    if (error) {
       cout << " FAILED" << endl;
    }

    return not error;
    
}

// don't worry about this routine, it captures standard out in a string.
bool RealTestPrint(const string ary[], size_t size) {
     bool success;
     
     // a place to store the output 
     stringstream buffer;
     streambuf * old = cout.rdbuf(buffer.rdbuf());

     // call the function
     PrintArray(ary, size);
     cout.rdbuf(old);

     success = CheckPrintResult(buffer.str(), ary, size);

     return success;
}

bool TestPrintArray(void){
    string ary[MAX_SIZE];
    size_t size;
    char letter;

    if (GLOBAL_DEBUG) { 
        cout << "Running PrintArray Test" << endl;
    }

    letter = 'a';
    for(size=0; size < MAX_SIZE; size++) {
        RealTestPrint(ary, size);
        ary[size] = letter;
        letter++;
    }
    RealTestPrint(ary, size);

    RealTestPrint(TEST_ARRAY, MAX_SIZE);

    // this line should complain
    //string ary2[] = {"Alfa", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot"};
    //size_t size2 = 6;
    //string bad = "Alfa \nBravo \nCharlie\nDelta\nEcho\nFoxtrot";
    //cout << "Test of test routine ";
    //CheckPrintResult(bad, ary2, size2);
        
    if (GLOBAL_DEBUG) { 
        cout << "Finished Running PrintArray Test" << endl;
        cout << endl;
    }

    // might change this later.
    return true;
}


bool TestBasicLoadArray(string ary[], size_t size, string fileName, size_t realSize) {

     string errorMsg = "Load resulted in overflow, X truncated.\n";

     bool success = true;
     stringstream buffer;
     streambuf * old = cout.rdbuf(buffer.rdbuf());
     size_t i;

     LoadArray(ary, size, MAX_SIZE, fileName, "X");
     cout.rdbuf(old);

     if (realSize > MAX_SIZE) {
        // check output error message
        if (buffer.str() != errorMsg) {
           cout << "\n\tBad Error Message, should be \n\t\"" 
                <<  errorMsg <<"\"\n but is \n\t\"";
           cout << buffer.str();
           cout << '"' << endl;
           success = false;
        }
        // check size.
        if (size != MAX_SIZE) {
           cout <<"\n\tBad Return size, should be " << MAX_SIZE 
                << " but is " << size << endl;
           success = false;
        }
     } else {
        if (size != realSize) {
           cout <<"\n\tBad Return size, should be " << realSize 
                << " but is " << size << endl;
           success = false;
        }
     }

     // check contents;
     for(i =0;i<size;i++) {
        if (TEST_ARRAY[i] != ary[i]) {
           cout << "\n\tLoad failed, should be " << TEST_ARRAY[i]
                << " but is " << ary[i] << endl;
           success = false;
        }
     }

     return success; 
}

// const is carried from previous function
// need to make copy to sort and compare
bool Same(const string a[], const string b[], size_t size) {
    size_t i;
    string c[MAX_SIZE];
    string d[MAX_SIZE];

    if (size > MAX_SIZE) {
       cout << "Error in Same, arrays too large" << endl;
       return false;
    }

    for(i=0;i<size;i++) {
       c[i] = a[i];
       d[i] = b[i];
    }

    bool same =true;
    sort(c,c+size,cmp);
    sort(d,d+size,cmp);
    for(i=0;i<size;i++) {
       if (c[i] != d[i]) {
          same = false;
       }
    }

    return same;
}

bool TestLoadArray(void){

    if (GLOBAL_DEBUG) {
        cout << "Running LoadArray Tests" << endl;
    }

    string ary[MAX_SIZE];
    size_t size=0, i;

    string baseName = HOME_DIR + "/data/file";
    stringstream s;

    for(i=0;i<=12;i++) {
       s << baseName << i ;

       TestBasicLoadArray(ary, size, s.str(), i);

       s.str("");
    }

    if (GLOBAL_DEBUG) {
        cout << "Finished Running LoadArray Test" << endl;
        cout << endl;
    }

    return true;
}

void StoreTest(const string ary[], size_t size) {
    string myFileName = "DANS_TEST_FILE";
    string res[100];
    size_t resSize = 0;

    StoreArray(TEST_ARRAY, size, myFileName);
    LoadArray(res, resSize, 100, myFileName, "X");
    if (resSize != size or not Same(ary,res, resSize)) {
        cout <<"\tSave of " ;
        PrintArray(ary, size);
        cout << " failed, array loded is ";
        PrintArray(res, resSize);
        cout << endl;
        cout << endl;
    }
    return;
}


bool TestStoreArray(void){

    if (GLOBAL_DEBUG) {
        cout << "Running StoreArray Tests" << endl;
    }

    StoreTest(TEST_ARRAY, 0);
    StoreTest(TEST_ARRAY, 1);
    StoreTest(TEST_ARRAY, 2);
    StoreTest(TEST_ARRAY, 3);
    StoreTest(TEST_ARRAY, 4);

    if (GLOBAL_DEBUG) {
        cout << "Finished Running StoreArray Tests" << endl;
        cout << endl;
    }

    return true;
}

void PrintError( const string ary1[], size_t size1,
                const string ary2[], size_t size2,
                const string result[], size_t newSize,
                 const string ans[], size_t ansSize, 
                 string routineName) {
        cout << "\t Error in  " << routineName << endl;
        cout << "\t\t";
        MyPrintArray(ary1, size1);
        cout << " and ";
        MyPrintArray(ary2, size2);
        cout  << " got " ;
        MyPrintArray(result, newSize);
        cout << " not ";
        MyPrintArray(ans, ansSize);
        cout << endl;
        cout << endl;

        return;
}

void CheckAndPrintError( const string ary1[], size_t size1,
                const string ary2[], size_t size2,
                const string result[], size_t newSize,
                 const string ans[], size_t ansSize, 
                 string routineName) {

    if (newSize != ansSize or not Same(result, ans, ansSize)) {
        PrintError(ary1, size1, ary2, size2, result, newSize, 
                                     ans, ansSize, routineName);
    }
    return;
}

void CheckCommon( const string ary1[], size_t size1,
                const string ary2[], size_t size2,
                 const string ans[], size_t ansSize) {

     string result[1000];
     size_t newSize;

     FindCommon(ary1, size1, ary2, size2, result, newSize);
     CheckAndPrintError(ary1, size1, ary2, size2, result, 
                                     newSize, ans, ansSize,"FindCommon");
     return;
}



bool TestFindCommon(void){

    string ary1[] = {"A", "C", "E"};
    string ary2[] = {"A", "B", "C"};
    string ary3[] = {"D", "E", "F"};


    if (GLOBAL_DEBUG) {
        cout << "Running FindCommon Tests " << endl;
    }

    // all in common, but different sizes
    CheckCommon(ary1, 3, ary1, 3, ary1, 3);
    CheckCommon(ary1, 3, ary1, 2, ary1, 2);
    CheckCommon(ary1, 3, ary1, 1, ary1, 1);
    CheckCommon(ary1, 3, ary1, 0, ary1, 0);
    CheckCommon(ary1, 2, ary1, 3, ary1, 2);
    CheckCommon(ary1, 1, ary1, 3, ary1, 1);
    CheckCommon(ary1, 0, ary1, 3, ary1, 0);

    // two in common
    string ans[6];
    ans[0] = "A";
    ans[1] = "C";
    CheckCommon(ary1, 3, ary2, 3, ans, 2);
    CheckCommon(ary2, 3, ary1, 3, ans, 2);

    // one in common
    ans[0] = "E";
    CheckCommon(ary1, 3, ary3, 3, ans, 1);
    CheckCommon(ary3, 3, ary1, 3, ans, 1);
  
    // nothing in common
    CheckCommon(ary2, 3, ary3, 3, ans, 0);
    CheckCommon(ary3, 3, ary2, 3, ans, 0);

    if (GLOBAL_DEBUG) {
        cout << "Finished Running FindCommon Tests " << endl;
        cout << endl;
    }

    return true;
}

void CheckMerge(const string ary1[], size_t size1,
                const string ary2[], size_t size2,
                const string ans[], size_t ansSize, 
                size_t maxSize, string errorString, int caseNo) {

     if(GLOBAL_DEBUG) {
        cout << "\tMerge case " << caseNo << endl;
     }

     string result[1000];
     size_t newSize = 0;
     stringstream buffer;

     streambuf * old = cout.rdbuf(buffer.rdbuf());

     Merge(ary1, size1, ary2, size2, result, newSize,maxSize,"X");

     cout.rdbuf(old);

     if (errorString != buffer.str()) {
        PrintError(ary1, size1, ary2, size2, result, newSize, ans, ansSize, "Merge");
        cout << "\tProblem with error string" << endl;
        cout << "\tShould be: \"" << errorString <<'"' << endl;
        cout << "\tBut is   : \"" << buffer.str() <<'"' << endl;
     }

     CheckAndPrintError(ary1, size1, ary2, size2, result, 
                                     newSize, ans, ansSize,"Merge");

     return;
}

bool TestMerge(void){
    string ary1[] = {"A", "C", "E"};
    string ary2[] = {"A", "B", "C"};
    string ary3[] = {"D", "E", "F"};

    string ans[10];
    
    if (GLOBAL_DEBUG) {
        cout << "Running Merge Tests " << endl;
    }

    // merge 1, no change
    CheckMerge(ary1, 3, ary1, 3, ary1, 3, 3, "",1);

    ans[0] = "A";
    ans[1] = "C";
    ans[2] = "E";
    ans[3] = "B";

    // good merge, no change.
    CheckMerge(ary1, 3, ary1, 3, ans, 3, 3, "",2);

    // good merge, array grows.
    CheckMerge(ary1, 3, ary2, 3, ans, 4, 6, "",3);

    // merge fails with overflow
    CheckMerge(ary1, 3, ary3, 3, ans, 3, 3, 
                        "Merge resulted in overflow, X truncated.\n",4);

    ans[0] = "A";
    ans[1] = "B";
    ans[2] = "C";
    ans[3] = "D";
    ans[4] = "E";
    ans[5] = "F";
    // good merge, at limit
    CheckMerge(ary2, 3, ary3, 3, ans, 6, 6, "",5);

    if (GLOBAL_DEBUG) {
        cout << "Finished Running Merge Tests " << endl;
        cout << endl;
    }

    return true;
}

void CheckDiff( const string ary1[], size_t size1,
                const string ary2[], size_t size2,
                 const string ans[], size_t ansSize) {

     string result[1000];
     size_t newSize=0;

     FindDiff(ary1, size1, ary2, size2, result, newSize);
     CheckAndPrintError(ary1, size1, ary2, size2, result, 
                                     newSize, ans, ansSize,"FindDiff");
     return;
}

bool TestFindDiff(void){
    string ary1[] = {"A", "C", "E"};
    string ary2[] = {"A", "B", "C"};
    string ary3[] = {"D", "E", "F"};

    string ans[10];

    if (GLOBAL_DEBUG) {
        cout << "Running FindDiff Tests " << endl;
    }

    // no diff
    CheckDiff(ary1, 3, ary1, 3, ans, 0);

    // last item missing
    ans[0] = "E";
    CheckDiff(ary1, 3, ary1, 2, ans, 1);

    // two
    ans[1] = "C";
    CheckDiff(ary1, 3, ary1, 1, ans, 2);

    // three
    CheckDiff(ary1, 3, ary1, 0, ary1, 3);

    ans[0] = "E";
    CheckDiff(ary1, 3, ary2, 3, ans, 1);

    ans[0] = "B";
    CheckDiff(ary2, 3, ary1, 3, ans, 1);
    

    if (GLOBAL_DEBUG) {
        cout << "Finished Running FindDiff Tests " << endl;
        cout << endl;
    }

    return true;
}

bool TestFind(void){
    size_t i;

    if (GLOBAL_DEBUG) {
        cout << "Running Find Tests " << endl;
    }

    for(i=0;i<MAX_SIZE;i++) {
       if (not Find(TEST_ARRAY, MAX_SIZE, TEST_ARRAY[i])) {
          cout << "\tFind failed for " << TEST_ARRAY[i] << endl;
       }
    }

    if (Find(TEST_ARRAY, MAX_SIZE, "Zebra")) {
        cout << "Find failed, found Zebra but should not" << endl;
    }

    if (Find(TEST_ARRAY, MAX_SIZE, "Aardvark")) {
        cout << "Find failed, found Aardvark but should not" << endl;
    }

    if (GLOBAL_DEBUG) {
        cout << "Finished Running Find Tests " << endl;
        cout << endl;
    }

    return true;
}


void MixArray(string ary[], size_t size) {
     size_t i,j;
     string tmp;

     for(i=0;i<size;i++) {
        j = rand() % size;
        if (i != j) {
           tmp = ary[i];
           ary[i] = ary[j];
           ary[j] = tmp;
        }
     }
     return;

}

bool TestSort(void){
    size_t  arraySize, loops;
    size_t i;

    string tmp[MAX_SIZE];

    if (GLOBAL_DEBUG) {
        cout << "Running Sort Tests " << endl;
    }
 
    for(arraySize=1;arraySize < MAX_SIZE; arraySize ++) {
        for(loops=0;loops<10; loops++) {
            for(i=0;i<arraySize; i++) {
              tmp[i] = TEST_ARRAY[i];
            }

            MixArray(tmp, arraySize);            

            Sort(tmp, arraySize);
            if (not Same(tmp, TEST_ARRAY, arraySize) ) {
               cout << "\tSort of size " << arraySize  << " failed." << endl;
               cout << "\tUser    : ";
               MyPrintArray(tmp, arraySize);
               cout << endl;
               cout << "\tStandard: ";
               MyPrintArray(TEST_ARRAY, arraySize);
               cout << endl;
            }
        }
    }

    if (GLOBAL_DEBUG) {
       cout << "Finished Running Sort Tests " << endl;
       cout << endl;
    }

    return true;
}

bool TestCopy(void){
    string tmp[MAX_SIZE];
    size_t i;
    size_t arraySize;

    if (GLOBAL_DEBUG) {
       cout << "Running Copy Tests " << endl;
    }

    for(i=0;i<MAX_SIZE;i++) {
        Copy(TEST_ARRAY, i, tmp, arraySize);
        if (i != arraySize or not Same(tmp, TEST_ARRAY, arraySize) ) {
           cout <<"\tCopy Failed: ";
           MyPrintArray(tmp, arraySize);
           cout << " is not ";
           MyPrintArray(TEST_ARRAY, i);
           cout << endl << endl;
        }
    }

    if (GLOBAL_DEBUG) {
        cout << "Finished Running Copy Tests " << endl;
        cout << endl;
    }

    return true;
}

void TestAppend(string ary[], size_t & size, string word, string error) {
     stringstream buffer;

     streambuf * old = cout.rdbuf(buffer.rdbuf());

     AppendToArray(ary, size, MAX_SIZE, word,"X");

     cout.rdbuf(old);

     if (error != buffer.str()) {
        cout << "\tAppend error failure " << endl;
        cout << "\tGot        : " << buffer.str() << endl;
        cout << "\tShould Have: " << error << endl;
        cout << "\tAdding " << word << " to " ;
        MyPrintArray(ary, size);
     }
     if (not Same(ary, TEST_ARRAY, size)) {
        cout << "\tAppend Fail ";
        MyPrintArray(ary, size) ;
        cout << " is not " ;
        MyPrintArray(TEST_ARRAY, size);
        cout << " but should be" << endl;
     }
     return;
}

bool TestAppendToArray(void){
    string tmp[1000];
    size_t i,j, arraySize=0;

    if (GLOBAL_DEBUG) {
        cout << "Running Append Tests " << endl;
    }

    for(i=0;i<MAX_SIZE;i++) {
       for(j=0;j<2;j++) {
           TestAppend(tmp, arraySize, TEST_ARRAY[i],"");
       }
    }
    TestAppend(tmp, arraySize, "Aardvark","Add resulted in overflow, X truncated.");
    TestAppend(tmp, arraySize, "Zebra","Add resulted in overflow, X truncated.");


    if (GLOBAL_DEBUG) {
        cout << "Finished Running Merge Tests " << endl;
        cout << endl;
    }

    return true;
}

void Copy(string src[], string dest[], size_t size) {
   size_t i;
   for(i=0;i<size;i++) {
      dest[i] = src[i];
   }
}

void DeleteTest(string ary[],  size_t size, string word, 
                                      string ans[], size_t ansSize, int caseNo) {


    string tmp[100];
    Copy(ary, tmp, size);

    if (GLOBAL_DEBUG) {
       cout << "Delete Case " << caseNo << endl;
    }



    DeleteFromArray(tmp, size, word);
    if (size != ansSize or  not Same(ans, tmp, size)) {
       cout << "\tDeleteFromArray error ";
       MyPrintArray(tmp,size);
       cout << " is not the same as " ;
       MyPrintArray(ans, ansSize);
       cout << endl;
    }
    return;
}


bool TestDeleteFromArray(void){
    string ary1[] = {"A","B","C"};

    string ary2[3];
    string ary3[3];
    size_t i,j,pos;
    size_t size=0;

    
    if (GLOBAL_DEBUG) {
        cout << "Running Delete Tests " << endl;
    }

    for(i=0;i<3;i++) {
        Copy(ary1, ary2,3);
        size = 3;
        pos = 0;
        for(j=0;j<3;j++) {
          if (j!= i) {
             ary3[pos] = ary1[j];
             pos ++;
          }
        }

        DeleteTest(ary2, size,  ary1[i], ary3,2,i);
    }

    size=3;
    DeleteTest(ary1, size, "a", ary1, size,10);
    DeleteTest(ary1, size, " A", ary1, size,11);

  
    if (GLOBAL_DEBUG) {
        cout << "Finished Running Delete Tests " << endl;
        cout << endl;
    }

    return true;
}