///////////////////////////////////////////////////////////////
// MT2-Q1 - Class declaration for Scope Stack                //
//                                                           //
// Jim Fawcett, CSE687 - Object Oriented Design, Spring 2018 //
///////////////////////////////////////////////////////////////

#include <deque>

//// beginning of required solution ///////////////////////////

template<typename T>
class ScopeStack
{
public:
  using iterator = typename std::deque<T>::iterator;
  using const_iterator = typename std::deque<T>::const_iterator;

  void push(T);
  T pop();
  T top();
  void clear();
  size_t size();
  T& operator[](size_t i);
  T operator[](size_t i) const;
  iterator begin();
  iterator end();
  const_iterator begin() const;
  const_iterator end() const;
private:
  std::deque<T> stack_;
};

//// end of required solution /////////////////////////////////

template<typename T>
void ScopeStack<T>::push(T t)
{
  stack_.push_front(t);
}

template<typename T>
T ScopeStack<T>::pop()
{
  if (size() == 0)
    throw std::exception("attempt to pop empty stack");
  T temp = stack_.front();
  stack_.pop_front();
  return temp;
}

template<typename T>
T ScopeStack<T>::top()
{
  if (size() == 0)
    throw std::exception("attempt to view empty stack");
  return stack_[0];
}

template<typename T>
void ScopeStack<T>::clear()
{
  stack_.clear();
}

template<typename T>
size_t ScopeStack<T>::size()
{
  return stack_.size();
}

template<typename T>
T& ScopeStack<T>::operator[](size_t i)
{
  if (i < 0 || i >= stack_.size())
    throw std::out_of_range;
  return stack_[i];
}

template<typename T>
T ScopeStack<T>::operator[](size_t i) const
{
  if (i < 0 || i >= stack_.size())
    throw std::out_of_range;
  return stack_[i];
}

template<typename T>
typename ScopeStack<T>::iterator ScopeStack<T>::begin()
{
  return stack_.begin();
}

template<typename T>
typename ScopeStack<T>::iterator ScopeStack<T>::end()
{
  return stack_.end();
}

template<typename T>
typename ScopeStack<T>::const_iterator ScopeStack<T>::begin() const
{
  return stack_.begin();
}

template<typename T>
typename ScopeStack<T>::const_iterator ScopeStack<T>::end() const
{
  return stack_.end();
}

/*---- demonstrating ScopeStack Operations ----*/

#include <iostream>

template<typename T>
void showElement(const T& t)
{
  std::cout << "{" << t.name.c_str() << ", " << t.type.c_str() << "} ";
}
template<typename T>
void show(const ScopeStack<T>& ss)
{
  std::cout << "\n  ";
  for (auto item : ss)  // uses iterator, begin(), and end()
    showElement(item);
}

int main()
{
  std::cout << "\n  MT2-Q1 - ScopeStack";
  std::cout << "\n ----------------------\n";

  struct Node { std::string name; std::string type; };

  ScopeStack<Node> scopeStack;
  scopeStack.push(Node{ "Test", "namespace" });
  scopeStack.push(Node{ "X", "class" });
  scopeStack.push(Node{ "open", "function" });
  scopeStack.push(Node{ "if", "control" });

  std::cout << "\n  There are " << scopeStack.size() << " elements in ScopeStack";
  std::cout << "\n  Top element is ";
  showElement(scopeStack.top());

  std::cout << "\n  Iterating front to back:";
  show(scopeStack);

  scopeStack.clear();
  std::cout << "\n  stack size after clearing = " << scopeStack.size();
  try {
    Node n = scopeStack.top();
  }
  catch (std::exception& ex)
  {
    std::cout << "\n\n  exception: " << ex.what();
  }
  std::cout << "\n\n";
}