#ifndef MT1Q5A_H
#define MT1Q5A_H
/////////////////////////////////////////////
// MT1Q5a.h - Scope Interface and Factory

#include <string>
#include <vector>
#include <initializer_list>

struct IScope
{
  using Name = std::string;
  using Type = std::string;
  using Complexity = size_t;

  virtual ~IScope() {}

  static IScope* Create();
  static IScope* Create(const Name& name, const Type& type, Complexity comp);

  virtual Name& name() = 0;
  virtual Type& type() = 0;
  virtual Complexity& complexity() = 0;
  virtual bool match(const IScope* pS) = 0;
  virtual bool operator<(const IScope* pS) = 0;
};

class Scope : public IScope
{
public:
  Scope(Name n, Type t, Complexity c)
    : _name(n), _type(t), _complexity(c) {}
  Scope() {}

  Name& name() { return _name; }
  Type& type() { return _type; }
  Complexity& complexity() { return _complexity; }

  bool match(const IScope* pS);
  bool operator<(const IScope* pS);

private:
  Name _name = "unknown";
  Type _type = "unknown";
  Complexity _complexity = 0;
};

inline IScope* IScope::Create() { return new Scope; }

IScope* IScope::Create(const Name& name, const Type& type, Complexity comp)
{
  return new Scope(name, type, comp);
}

inline bool Scope::match(const IScope* pS)
{
  IScope* pCS = const_cast<IScope*>(pS);
  Scope::Complexity complexityTolerance = 1;
  bool complexityMatch =
    (this->complexity() < pCS->complexity() + complexityTolerance) &&
    (this->complexity() > pCS->complexity() - complexityTolerance);
  return complexityMatch;
}

inline bool Scope::operator<(const IScope* pS)
{
  IScope* pCS = const_cast<IScope*>(pS);
  return this->complexity() > pCS->complexity();
}

///////////////////////////////////////////////////////////
// ScopeCollection

template <typename Compare> // bool compare(const Scope* pS1, const Scope* pS2)
struct IScopeCollection
{
  using Scopes = std::vector<IScope*>;
  using iterator = Scopes::iterator;

  static IScopeCollection<Compare>* create();
  virtual ~IScopeCollection() {}
  virtual iterator begin() = 0;
  virtual iterator end() = 0;
  virtual IScopeCollection<Compare>& add(IScope* pS) = 0;
  virtual void sort(Compare& compare) = 0;
};

template<typename Compare>
class ScopeCollection : public IScopeCollection<Compare>
{
public:
  ScopeCollection() {}
  ScopeCollection(std::initializer_list<IScope*> lsp)
  {
    for (auto pScope : lsp)
      _scopes.push_back(pScope);
  }
  ScopeCollection<Compare>& add(IScope* pS) 
  { 
    _scopes.push_back(pS);
    return *this;
  }
  typename IScopeCollection<Compare>::iterator begin() { return _scopes.begin(); }
  typename IScopeCollection<Compare>::iterator end() { return _scopes.end(); }
  void sort(Compare& compare)
  {
    std::sort(
      _scopes.begin(), 
      _scopes.end(), 
      compare);
  }
private:
  std::vector<IScope*> _scopes;
};

template<typename Compare>
IScopeCollection<Compare>* IScopeCollection<Compare>::create()
{
  return new ScopeCollection<Compare>();
}

#endif