/////////////////////////////////////////////////////////////////////
// MT1Q7.cpp - TestResults Container                               //
//                                                                 //
// Jim Fawcett, CSE687 - OOD : Midterm Exam, Fall 2018             //
/////////////////////////////////////////////////////////////////////

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>

#include "../Utilities/Properties/Properties.h"
#include "../Utilities/StringUtilities/StringUtilities.h"
#include "../Utilities/DateTime/DateTime.h"

namespace Midterm
{
  using namespace Utilities;

  template<typename P>
  class TestResult
  {
  public:
    Property<std::string> name;
    Property<std::string> author;
    Property<std::string> date;
    Property<bool> result;
    Property<P> appSpecific;  // will use here for log
  };

  using Key = std::string;
  template<typename P>
  using iterator = typename std::unordered_map<Key, TestResult<P>>::iterator;

  template<typename P>
  class TestResults
  {
  public:
    void add(const TestResult<P>& tr);
    bool contains(const Key& key);
    typename iterator<P> begin();
    typename iterator<P> end();
    size_t size() const;
    TestResult<P>& operator[](const Key& key);
    TestResult<P> operator[](const Key& key) const;
    std::string toXml() const;
  private:
    std::unordered_map<Key, TestResult<P>> results_;
  };

  template<typename P>
  void TestResults<P>::add(const TestResult<P>& tr)
  {
    // std::unordered_map indexer won't change value of index
    // so cast away const to allow this to compile

    TestResult<P>* pResult = const_cast<TestResult<P>*>(&tr);
    results_[pResult->name()] = tr;
  }

  template<typename P>
  bool TestResults<P>::contains(const Key& key)
  {
    return results_.contains(key);
  }
  template<typename P>
  typename iterator<P> TestResults<P>::begin()
  {
    return results_.begin();
  }

  template<typename P>
  typename iterator<P> TestResults<P>::end()
  {
    return results_.end();
  }

  template <typename P>
  TestResult<P>& TestResults<P>::operator[](const Key& key)
  {
    return results_[key];
  }

  template<typename P>
  TestResult<P> TestResults<P>::operator[](const Key& key) const
  {
    return results_[key];
  }

  template<typename P>
  size_t TestResults<P>::size() const
  {
    return results_.size();
  }

  template<typename P>
  std::string TestResults<P>::toXml() const
  {
    return "faking XML conversion";
  }

  template <typename P>
  void show(TestResult<P>& tr)
  {
    std::cout << "\n  Test:   \"" + tr.name() << "\"";
    std::cout << "\n  Author: \"" + tr.author() << "\"";

    if(tr.result() == true)
      std::cout << "\n  Result: \"" + std::string("true") << "\"";
    else
      std::cout << "\n  Result: \"" + std::string("false") << "\"";

    std::cout << "\n  Log:    \"" + tr.appSpecific() + "\"";

    std::cout << "\n";
  }

  template<typename P>
  void show(TestResults<P>& trs)
  {
    for (auto item : trs)
      show(item.second);
  }
}

int main()
{
  using namespace Midterm;

  Utilities::Title("MT1Q7 - Test Results Container");

  TestResults<std::string> trs;

  TestResult<std::string> tr1;
  tr1.name("tr1");
  tr1.author("Fawcett");
  tr1.date(DateTime().now());
  tr1.result("true");
  tr1.appSpecific("a stunningly short test log");
  trs.add(tr1);

  TestResult<std::string> tr2;
  tr2.name("tr2");
  tr2.author("Bhosale");
  tr2.date(DateTime().now());
  tr2.result("true");
  tr2.appSpecific("another short test log");
  trs.add(tr2);

  TestResult<std::string> tr3;
  tr3.name("tr3");
  tr3.author("Salman");
  tr3.date(DateTime().now());
  tr3.result("true");
  tr3.appSpecific("a still quite short test log");
  trs.add(tr3);

  TestResult<std::string> tr4;
  tr4.name("tr4");
  tr4.author("Sandra");
  tr4.date(DateTime().now());
  tr4.result("true");
  tr4.appSpecific("a somewhat longer, but still quite petite, test log");
  trs.add(tr4);

  TestResult<std::string> tr5;
  tr5.name("tr5");
  tr5.author("Bandaru");
  tr5.date(DateTime().now());
  tr5.result("true");
  tr5.appSpecific("a very short test log");
  trs.add(tr5);

  TestResult<std::string> tr6;
  tr6.name("tr6");
  tr6.author("Patil");
  tr6.date(DateTime().now());
  tr6.result("true");
  tr6.appSpecific("a test log");
  trs.add(tr6);

  show(trs);

  return 0;
}