#pragma once
/////////////////////////////////////////////////////////////////////
// TestQueries.h - Provides Testing for Queries in TestNoSqlDb     //
// ver 1.0                                                         //
// Jim Fawcett, CSE687 - Object Oriented Design, Spring 2017       //
/////////////////////////////////////////////////////////////////////
/*
* Package Operations:
* -------------------
* This package defines class TestExQueries, that demonstrates each of
* the query requirements.
*
* Required Files:
* ---------------
*   TestQueries.h
*   Queries.h, Queries.cpp
*
* Maintenance History:
*---------------------
* ver 1.0 : 22 Feb 2017
* - first release
*
* Note:
* -----
* There is no TestQueries.cpp nor test stub because these queries
* were written to be tested in TestNoSqlDb package.
*
*/
#include "../Queries/Queries.h"
#include <string>
#include <iostream>

template<typename Data>
class TestExQueries
{
public:
  TestExQueries(std::ostream& out) : out_(out) {};
  void doQueries(NoSQLDB::NoSqlDb<Data>& db);
private:
  NoSQLDB::NoSqlDb<Data>* pDb = nullptr;
  std::ostream& out_;
  void TestQuery1(const std::string& arg);
  void TestQuery2(const std::string& arg);
  void TestQuery3(const std::string& arg);
  void TestQuery4(const std::string& arg);
  void TestQuery5(const std::string& arg);
  void TestQuery6(const std::string& arg);
  void TestQuery7(DateTime dt1, DateTime dt2);
};
//----< run all query tests >----------------------------------------

template<typename Data>
void TestExQueries<Data>::doQueries(NoSQLDB::NoSqlDb<Data>& db)
{
  pDb = &db;
  Utilities::subTitle("Testing Required Queries");
  Utilities::putLine();
  Display<Data> display(*pDb);
  display.showAll();

  TestQuery1("Joe");
  TestQuery2("Veronica");
  std::string regEx = ".*sho.*";
  TestQuery3(regEx);
  regEx = ".*ey.*";
  TestQuery4(regEx);
  regEx = "test";
  TestQuery5(regEx);
  regEx = ".*(t4|t5).*";
  TestQuery6(regEx);
  DateTime dt = DateTime().now();
  DateTime::Duration dur = DateTime::makeDuration(1, 0, 0, 0);
  TestQuery7(dt - dur, dt + dur);
  std::cout << "\n";
}
//----< query for key >----------------------------------------------

template<typename Data>
void TestExQueries<Data>::TestQuery1(const std::string& arg)
{
  Query<Data>::QueryType getKeyIfExists = [](const std::string& arg, Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n    getKeyIfExists Query for \"" << arg << "\"";
    for (NoSQLDB::Key k : keys)
    {
      if (k == arg)
      {
        returnKeys.push_back(static_cast<std::string>(k));
        break;
      }
    }
    return returnKeys;
  };

  std::cout << "\n  results of query #1:";
  Keys keys = pDb->keys();
  keys = getKeyIfExists(arg, keys);
  if (keys.size() == 1)
    std::cout << "\n    found key \"" << arg << "\"";
  else
    std::cout << "\n    didn't find key \"" << arg << "\"";
}
//----< query for children of specified element >--------------------

template<typename Data>
void TestExQueries<Data>::TestQuery2(const std::string& arg)
{
  Query<Data>::QueryType getChildren = [&](const std::string& arg, Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n    getChildren Query for \"" << arg << "\"";
    for (NoSQLDB::Key k : keys)
    {
      if (k == arg)
      {
        returnKeys = pDb->value(k).children;
        break;
      }
    }
    return returnKeys;
  };

  std::cout << "\n\n  results of query #2:";
  Keys keys = pDb->keys();
  keys = getChildren(arg, keys);
  if (keys.size() > 0)
  {
    std::cout << "\n    found children : ";
    for (Key k : keys)
      std::cout << k << " ";
  }
  else
    std::cout << "\n    didn't find children for \"" << arg << "\"";
}
//----< get keys that match regex >----------------------------------

template<typename Data>
void TestExQueries<Data>::TestQuery3(const std::string& arg)
{
  Query<Data>::QueryType getRegexKeyMatch = [&](const std::string& arg, Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n    key pattern match Query for \"" << arg << "\"";
    std::regex regx(arg);
    for (NoSQLDB::Key k : keys)
    {
      if (std::regex_match(k, regx))
      {
        returnKeys.push_back(k);
      }
    }
    return returnKeys;
  };

  std::cout << "\n\n  results of query #3:";
  Keys keys = pDb->keys();
  keys = getRegexKeyMatch(arg, keys);
  if (keys.size() > 0)
  {
    std::cout << "\n    matches : ";
    for (Key k : keys)
      std::cout << k << " ";
  }
  else
    std::cout << "\n    didn't find match for \"" << arg << "\"";
}
//----< get elements with names that match regex >-------------------

template<typename Data>
void TestExQueries<Data>::TestQuery4(const std::string& arg)
{
  Query<Data>::QueryType getRegexNameMatch = [&](const std::string& arg, Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n    name pattern match Query for \"" << arg << "\"";
    std::regex regx(arg);
    for (NoSQLDB::Key k : keys)
    {
      Element<Data> elem = pDb->value(k);
      if (std::regex_match(static_cast<std::string>(elem.name), regx))
      {
        returnKeys.push_back(k);
      }
    }
    return returnKeys;
  };

  std::cout << "\n\n  results of query #4:";
  Keys keys = pDb->keys();
  keys = getRegexNameMatch(arg, keys);
  if (keys.size() > 0)
  {
    std::cout << "\n    matches : ";
    for (Key k : keys)
      std::cout << k << " ";
  }
  else
    std::cout << "\n    didn't find match for \"" << arg << "\"";
}
//-----< get elements with categories that match regex >-------------

template<typename Data>
void TestExQueries<Data>::TestQuery5(const std::string& arg)
{
  Query<Data>::QueryType getRegexCategoryMatch = [&](const std::string& arg, Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n    category pattern match Query for \"" << arg << "\"";
    std::regex regx(arg);
    for (NoSQLDB::Key k : keys)
    {
      Element<Data> elem = pDb->value(k);
      if (std::regex_match(static_cast<std::string>(elem.category), regx))
      {
        returnKeys.push_back(k);
      }
    }
    return returnKeys;
  };

  std::cout << "\n\n  results of query #5:";
  Keys keys = pDb->keys();
  keys = getRegexCategoryMatch(arg, keys);
  if (keys.size() > 0)
  {
    std::cout << "\n    matches : ";
    for (Key k : keys)
      std::cout << k << " ";
  }
  else
    std::cout << "\n    didn't find match for \"" << arg << "\"";
}
//----< get elements with data that matches regex >------------------

template<typename Data>
void TestExQueries<Data>::TestQuery6(const std::string& arg)
{
  Query<Data>::QueryType getRegexDataMatch = [&](const std::string& arg, Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    std::cout << "\n    data pattern match Query for \"" << arg << "\"";
    std::regex regx(arg);
    for (NoSQLDB::Key k : keys)
    {
      Element<Data> elem = pDb->value(k);
      std::string data = elem.data;
      if (std::regex_match(data, regx))
      {
        returnKeys.push_back(k);
      }
    }
    return returnKeys;
  };

  std::cout << "\n\n  results of query #6:";
  Keys keys = pDb->keys();
  keys = getRegexDataMatch(arg, keys);
  if (keys.size() > 0)
  {
    std::cout << "\n    matches : ";
    for (Key k : keys)
      std::cout << k << " ";
  }
  else
    std::cout << "\n    didn't find match for \"" << arg << "\"";
}
//----< get elements with DateTime in specified interval >-----------

template<typename Data>
void TestExQueries<Data>::TestQuery7(DateTime dt1, DateTime dt2)
{
  Query<Data>::QueryType getDateIntervalMatch = [&](const std::string& arg, Keys keys)
  {
    NoSQLDB::Keys returnKeys;
    Element<Data> elem1 = pDb->value(keys[0]);
    DateTime dt;
    elem1.dateTime = (dt + DateTime::makeDuration(2, 0, 0, 0));
    pDb->saveValue(keys[0], elem1);
    std::cout << "\n    set dateTime of " << keys[0] << " to " << static_cast<DateTime>(elem1.dateTime).time();

    std::cout << "\n    date interval match Query for dates between:";
    std::cout << "\n    " << dt1.time() << " and " << dt2.time();

    for (NoSQLDB::Key k : keys)
    {
      Element<Data> elem = pDb->value(k);
      DateTime dt = elem.dateTime;
      std::cout << "\n    key : " << k << " has dateTime : " << dt.time();
      if (dt1 < dt && dt < dt2)
      {
        returnKeys.push_back(k);
      }
    }
    return returnKeys;
  };

  std::cout << "\n\n  results of query #6:";
  Keys keys = pDb->keys();
  keys = getDateIntervalMatch("", keys);
  if (keys.size() > 0)
  {
    std::cout << "\n    matches : ";
    for (Key k : keys)
      std::cout << k << " ";
  }
  else
    std::cout << "\n    didn't find match for DateTime interval";
}