#pragma once
/////////////////////////////////////////////////////////////////////
// TestNoSqlDb.h - demonstrate NoSqlDb requirements                //
// ver 1.0                                                         //
// Jim Fawcett, CSE687 - Object Oriented Design, Spring 2017       //
/////////////////////////////////////////////////////////////////////
/*
* Package Operations:
* -------------------
* This package defines class TestDBString, that demonstrates each of
* the requirements met.  It uses a SuperHero class from package TestTypes
* to demonstrate that the NoSqlDb does work with multiple types.
*
* Required Files:
* ---------------
*   TestNoSqlDb.h, TestNoSqlDb.cpp,
*   Queries.h, Queries.cpp,
*   Persist.h, Persist.cpp,
*   Display.h, Display.cpp,
*   DateTime.h, DateTime.cpp,
*   TestTypes.h, TestTypes.cpp,
*   Utilities.h, Utilities.cpp,
*
* Maintenance History:
*---------------------
* ver 1.0 : 06 Feb 2017
* - first release
*/

#include "TestQueries.h"
#include "../NoSqlDb/NoSqlDb.h"
#include "../Queries/Queries.h"
#include "../Persist/Persist.h"
#include "../Display/Display.h"
#include "../TestTypes/TestTypes.h"
#include "../Utilities/Utilities.h"
#include <regex>
#include <string>
#include <vector>
#include <fstream>

class TestDBString
{
public:
  NoSQLDB::NoSqlDb<std::string>& makeTestStringDb();
  NoSQLDB::NoSqlDb<NoSQLDB::SuperHero>& makeTestSuperHeroDb();
  NoSQLDB::NoSqlDb<std::string> makeProject1Db();
  void DemoReq1();
  void DemoReq2();
  void DemoReq3();
  void DemoReq4();
  void DemoReq5();
  void DemoReq6();
  void DemoReq7();
  void DemoReq8();
  void DemoReq9();
  void DemoReq10();
  void DemoReq11();
  void DemoReq12();
private:
  NoSQLDB::NoSqlDb<std::string> db_;
};

void TestDBString::DemoReq1()
{
  Utilities::subTitle("Demonstrating Req #1 - is C++");
  std::cout << "\n  Examine code in Visual Studio to verify that it is C++, using standard libraries.\n";
}

void TestDBString::DemoReq2()
{
  Utilities::subTitle("Demonstrating Req #2 - template database");
  Utilities::putLine();
  std::cout << "\n  type of data = " << typeid(std::string).name() << "\n\n";
  db_ = makeTestStringDb();
  NoSQLDB::Display<std::string> display(db_);
  display.showAll();

  std::cout << "\n  type of data = " << typeid(NoSQLDB::SuperHero).name() << "\n\n";
  NoSQLDB::NoSqlDb<NoSQLDB::SuperHero>& dbSH = makeTestSuperHeroDb();
  NoSQLDB::Display<NoSQLDB::SuperHero> displaySH(dbSH);
  displaySH.showAll();
  Utilities::putLine();
}

void TestDBString::DemoReq3()
{
  Utilities::subTitle("Demonstrating Req #3 - add and delete db records");
  std::cout << "\n  inserting new elements:\n";
  NoSQLDB::Element<std::string> newElem("newElem", "test");
  newElem.data = "new element";
  db_.saveRecord("newElem", newElem);
  NoSQLDB::Element<std::string> newerElem("newerElem", "test");
  newerElem.saveChild("newElem");
  newerElem.data = "newer element";
  db_.saveRecord("newerElem", newerElem);
  NoSQLDB::Display<std::string> display(db_);
  display.showAll();

  std::cout << "\n  removing element \"newElem\":\n";
  db_.removeRecord("newElem");
  display.showAll();
  std::cout << "\n  note: newerElem child (newElem) was removed when newElem was removed.\n";
}

void TestDBString::DemoReq4()
{
  Utilities::subTitle("Demonstrating Req #4 - editing records");
  std::cout << "\n  editing element with key \"Joe\"\n";
  NoSQLDB::Element<std::string> elem = db_.value("Joe");
  elem.name = "Joey";
  elem.category = "test R4";
  elem.data = "new data";
  std::vector<std::string>& children = elem.children.getValue();
  if(children.size() > 0)
    children.erase(children.begin());
  db_.saveValue("Joe", elem);
  NoSQLDB::Display<std::string> display(db_);
  display.showAll();
}

void TestDBString::DemoReq5()
{
  using namespace NoSQLDB;
  Utilities::subTitle("Demonstrating Req #5 - persisting db to XML file");
  Utilities::putLine();
  NoSQLDB::NoSqlDb<NoSQLDB::SuperHero>& dbSH = makeTestSuperHeroDb();
  Persist<SuperHero> persistSH(dbSH);
  Utilities::subTitle("Persisting NoSqlDb<SuperHero> to XML string:");
  std::cout << "\n" << persistSH.save();
  std::cout << "\n";

  NoSQLDB::Persist<std::string> persist(db_);
  Utilities::subTitle("Persisting NoSqlDb<std::string> to XML string:");
  std::cout << "\n" << persist.compress(persist.save());
  std::cout << "\n";
}

void TestDBString::DemoReq6()
{
  Utilities::subTitle("Demonstrating Req #6 - timed persist");
  std::cout << "\n  not implemented yet\n";
}

void TestDBString::DemoReq7()
{
  Utilities::subTitle("Demonstrating Req #7 - Simple Queries");
  using namespace NoSQLDB;
  Query<std::string> query(db_);
  Display<std::string> display(db_);
  TestExQueries<std::string> tq(std::cout);
  tq.doQueries(db_);
}

void TestDBString::DemoReq8()
{
  Utilities::subTitle("Demonstrating Req #8 - Compound \"AND\" Queries");

  NoSQLDB::Query<std::string> query(db_);
  NoSQLDB::Display<std::string> display(db_);
  NoSQLDB::NoSqlDb<std::string>& db = db_;

  NoSQLDB::Query<std::string>::QueryType getElem 
    = [&db](const NoSQLDB::Query<std::string>::Arg& arg, NoSQLDB::Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n  getElem Query for \"" << arg << "\"";
    for (NoSQLDB::Key k : keys)
    {
      if ((db.value(k)).name.getValue() == arg)
        returnKeys.push_back(arg);
    }
    return returnKeys;
  };

  NoSQLDB::Query<std::string>::QueryType hasChildren = [&db](const std::string& arg, NoSQLDB::Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n  hasChildren query:";
    for (NoSQLDB::Key k : keys)
    {
      if ((db.value(k)).children.getValue().size() > 0)
        returnKeys.push_back(k);
    }
    return returnKeys;
  };

  std::cout << "\n  Compound Query - hasChildren, then getElem for Veronica, then for Ashok\n";
  NoSQLDB::Keys qkeys = query.execute(hasChildren, "", db.keys());
  std::cout << "\n  size of returned keyset = " << qkeys.size();
  std::cout << "\n  returned keys are: ";
  for (NoSQLDB::Key k : qkeys)
    std::cout << k << " ";
  std::cout << "\n";
  display.showQuery(qkeys);

  qkeys = query.execute(getElem, "Veronica", qkeys);
  std::cout << "\n  size of returned keyset = " << qkeys.size();
  std::cout << "\n  returned keys are: ";
  for (NoSQLDB::Key k : qkeys)
    std::cout << k << " ";
  std::cout << "\n";
  display.showQuery(qkeys);

  qkeys = query.execute(getElem, "Ashok", qkeys);
  std::cout << "\n  size of returned keyset = " << qkeys.size();
  std::cout << "\n  returned keys are: ";
  for (NoSQLDB::Key k : qkeys)
    std::cout << k << " ";
  std::cout << "\n";
  display.showQuery(qkeys);
  std::cout << "\n";
}

void TestDBString::DemoReq9()
{
  Utilities::subTitle("Demonstrating Req #9 - Compound \"OR\" Queries");
  Utilities::putLine();

  NoSQLDB::Query<std::string> query(db_);
  NoSQLDB::Display<std::string> display(db_);
  NoSQLDB::NoSqlDb<std::string>& db = db_;

  display.showAll();
  NoSQLDB::Query<std::string>::QueryType hasChildren = [&db](const std::string& arg, NoSQLDB::Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n  hasChildren query:";
    for (NoSQLDB::Key k : keys)
    {
      if ((db.value(k)).children.getValue().size() > 0)
        returnKeys.push_back(k);
    }
    return returnKeys;
  };
  NoSQLDB::Keys qkeys = query.execute(hasChildren, "", db.keys());

  NoSQLDB::Query<std::string>::QueryType getElem
    = [&db](const NoSQLDB::Query<std::string>::Arg& arg, NoSQLDB::Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::regex re(arg);
    std::cout << "\n  getElem Query for \"" << arg << "\"";
    for (NoSQLDB::Key k : keys)
    {
      std::string name = db.value(k).name;
      if (std::regex_match(name, re))
        returnKeys.push_back(k);
    }
    return returnKeys;
  };
  NoSQLDB::Keys qkeys2 = query.execute(getElem, "newer.*", db.keys());
  for (NoSQLDB::Key k : qkeys2)
    qkeys.push_back(k);
  std::sort(qkeys.begin(), qkeys.end());
  qkeys.erase(std::unique(qkeys.begin(), qkeys.end()), qkeys.end());
  Utilities::putLine();
  display.showQuery(qkeys);
}

void TestDBString::DemoReq10()
{
  Utilities::subTitle("Demonstrating Req #10 - Reading Project1 Package Structure");
  using namespace NoSQLDB;
  Utilities::putLine();

  NoSqlDb<std::string> testDb = makeProject1Db();
  NoSQLDB::Persist<std::string> persist(testDb);
  persist.saveToFile("Project1.xml");

  Utilities::subTitle("Creating Project1 Package DB from XML file:");
  Utilities::putLine();
  persist.restoreFromFile("Project1.xml");
  Display<std::string> display(testDb);
  display.showAll();
  std::cout << "\n";
}

void TestDBString::DemoReq11()
{
  Utilities::subTitle("Demonstrating Req #11");
  std::cout << "\n  This demonstration shows that all requirements except #6 are satisfied.\n";
}

void TestDBString::DemoReq12()
{
  Utilities::subTitle("Demonstrating optional Req #12");
  std::cout << "\n  testing for requirement #7 illustrates several regex matches.\n";
}

//NoSQLDB::NoSqlDb<std::string>& TestDBString::makeTestStringDb()
//{
//  // Ashok, Jiang, Joe, Sam, Veronica
//
//  NoSQLDB::Element<std::string> elem1;
//  elem1.name = "Joe";
//  elem1.category = "test";
//  elem1.dateTime = DateTime();
//  elem1.children.getValue().push_back("Ashok");
//  elem1.children.getValue().push_back("Jiang");
//  elem1.children.getValue().push_back("Sam");
//  elem1.data.getValue() = Utilities::Convert<std::string>::fromString("test1");
//
//  NoSQLDB::Element<std::string> elem2;
//  elem2.name = "Ashok";
//  elem2.category = "test";
//  elem2.dateTime = DateTime();
//  elem2.children.getValue().push_back("Veronica");
//  elem2.children.getValue().push_back("Jiang");
//  elem2.data.getValue() = Utilities::Convert<std::string>::fromString("test2");
//
//  NoSQLDB::Element<std::string> elem3;
//  elem3.name = "Veronica";
//  elem3.category = "test";
//  elem3.dateTime = DateTime();
//  elem3.children.getValue().push_back("Ashok");
//  elem3.children.getValue().push_back("Joe");
//  elem3.children.getValue().push_back("Sam");
//  elem3.data.getValue() = Utilities::Convert<std::string>::fromString("test3");
//
//  NoSQLDB::Element<std::string> elem4;
//  elem4.name = "Jiang";
//  elem4.category = "test";
//  elem4.dateTime = DateTime();
//  elem4.children.getValue().push_back("Ashok");
//  elem4.children.getValue().push_back("Veronica");
//  elem4.data.getValue() = Utilities::Convert<std::string>::fromString("test4");
//
//  NoSQLDB::Element<std::string> elem5;
//  elem5.name = "Sam";
//  elem5.category = "test";
//  elem5.dateTime = DateTime();
//  //elem5.children.getValue().push_back("Ashok");
//  elem5.data.getValue() = Utilities::Convert<std::string>::fromString("test5");
//
//  static NoSQLDB::NoSqlDb<std::string> db;
//  db.saveRecord(elem1.name, elem1);
//  db.saveRecord(elem2.name, elem2);
//  db.saveRecord(elem3.name, elem3);
//  db.saveRecord(elem4.name, elem4);
//  db.saveRecord(elem5.name, elem5);
//
//  return db;
//}
//
//NoSQLDB::NoSqlDb<NoSQLDB::SuperHero>& TestDBString::makeTestSuperHeroDb()
//{
//  NoSQLDB::SuperHero Batman;
//  Batman.name = "Batman";
//  Batman.power = 5;
//  NoSQLDB::Element<NoSQLDB::SuperHero> elem1;
//  elem1.name = "Batman";
//  elem1.category = "Superhero";
//  elem1.dateTime = DateTime();
//  elem1.data = Batman;
//
//  NoSQLDB::SuperHero Thor;
//  Thor.name = "Thor";
//  Thor.power = 3;
//  NoSQLDB::Element<NoSQLDB::SuperHero> elem2;
//  elem2.name = "Thor";
//  elem2.category = "Superhero";
//  elem2.dateTime = DateTime();
//  elem2.data = Thor;
//
//  static NoSQLDB::NoSqlDb<NoSQLDB::SuperHero> db;
//  db.saveRecord("Batman", elem1);
//  db.saveRecord("Thor", elem2);
//
//  return db;
//}
//
//NoSQLDB::NoSqlDb<std::string> TestDBString::makeProject1Db()
//{
//  using namespace NoSQLDB;
//  NoSqlDb<std::string> projDB;
//  Element<std::string> elem;
//  Key key = "TestNoSqlDb";
//  elem.name = key;
//  elem.category = "Package";
//  elem.dateTime = DateTime().now();
//  elem.saveChild("NoSqlDb");
//  elem.saveChild("Persist");
//  elem.saveChild("Queries");
//  elem.saveChild("Display");
//  elem.saveChild("DateTime");
//  elem.data = "TestNoSqlDb data";
//  projDB.saveRecord(key, elem);
//
//  key = "NoSqlDb";
//  elem.name = key;
//  elem.category = "Package";
//  elem.dateTime = DateTime().now();
//  elem.children.getValue().clear();
//  elem.saveChild("DateTime");
//  elem.data = "NoSqlDb data";
//  projDB.saveRecord(key, elem);
//
//  key = "Persist";
//  elem.name = key;
//  elem.category = "Package";
//  elem.dateTime = DateTime().now();
//  elem.children.getValue().clear();
//  elem.saveChild("DateTime");
//  elem.saveChild("NoSqlDb");
//  elem.saveChild("XmlUtilities");
//  elem.data = "Persist data";
//  projDB.saveRecord(key, elem);
//
//  key = "Queries";
//  elem.name = key;
//  elem.category = "Package";
//  elem.dateTime = DateTime().now();
//  elem.children.getValue().clear();
//  elem.saveChild("Display");
//  elem.saveChild("NoSqlDb");
//  elem.saveChild("StoredProcedures");
//  elem.data = "Queries data";
//  projDB.saveRecord(key, elem);
//
//  key = "Display";
//  elem.name = key;
//  elem.category = "Package";
//  elem.dateTime = DateTime().now();
//  elem.children.getValue().clear();
//  elem.saveChild("Queries");
//  elem.saveChild("NoSqlDb");
//  elem.data = "Display data";
//  projDB.saveRecord(key, elem);
//
//  key = "DateTime";
//  elem.name = key;
//  elem.category = "Package";
//  elem.dateTime = DateTime().now();
//  elem.children.getValue().clear();
//  elem.data = "DateTime data";
//  projDB.saveRecord(key, elem);
//
//  key = "StoredProcedures";
//  elem.name = key;
//  elem.category = "Package";
//  elem.dateTime = DateTime().now();
//  elem.children.getValue().clear();
//  elem.data = "StoredProcedures data";
//  projDB.saveRecord(key, elem);
//
//  key = "XmlUtilities";
//  elem.name = key;
//  elem.category = "Package";
//  elem.dateTime = DateTime().now();
//  elem.children.getValue().clear();
//  elem.data = "XmlUtilities data";
//  projDB.saveRecord(key, elem);
//
//  return projDB;
//}