#ifndef STATE_HPP_INCLUDED
#define STATE_HPP_INCLUDED

#include <map>
#include <deque>

#include <boost/shared_ptr.hpp>

#include "types.hpp"

namespace game
{

    class stateStack;
    class state
    {
        private:
            engine::string _name;

        public:

            const engine::string &name() const
            {
                return _name;
            }

            state(const engine::string &name):
                _name(name)
            {
            }

            virtual ~state()
            {
            }

            virtual void tick(engine::real dt, stateStack &stack) = 0;
            virtual void render() = 0;

            virtual void suspend() = 0; // still on stack, but not top (stop)
            virtual void resume() = 0; // on stack, now top (keep going)
            virtual void pushed() = 0; // pushed onto stack (load)
            virtual void popped() = 0; // popped off stack (unload)


    };

    typedef boost::shared_ptr<state> statePtr;

//    template<typename A, typename B>
//    boost::shared_ptr<A> stateCast(const boost::shared_ptr<B> &ptr)
//    {
//        return boost::static_pointer_cast<A>(ptr);
//    }

    typedef std::map<engine::string, statePtr> stateMap;
    typedef std::deque<statePtr> stateDeque;

    class stateStack
    {
        private:

            stateMap _states;
            stateDeque _stack;

        public:

            // register state
            void operator+=(const statePtr &ptr);
            // remove state
            statePtr operator-=(const engine::string &name);
//            // remove state
//            void operator-=(statePtr s);
//            // retreive state
//            statePtr operator[](const engine::string &name) const;

            // push a state onto the stack
            stateStack &operator<<(const engine::string &name);
            //stateStack operator<<(const statePtr &s);
            // pop a state off the stack
            stateStack &pop();

            bool tick(engine::real dt);
            void render();
    };

    typedef boost::shared_ptr<stateStack> stateStackPtr;

}

#include "log.hpp"

#include "state.hpp"

namespace game
{



    void stateStack::operator+=(const statePtr &ptr)
    {
        if (!ptr)
        {
            log("tried to register null state in stack");
            return;
        }

        stateMap::const_iterator i = _states.find(ptr->name());
        if (i != _states.end())
        {
            log("state \"" + ptr->name() + "\" already registered in stack");
            return;
        }

        _states[ptr->name()] = ptr;
    }

    statePtr stateStack::operator-=(const engine::string &name)
    {
        stateMap::const_iterator i = _states.find(name);
        if (i == _states.end())
        {
            log("could not unregister state \"" + name + "\", not found in stack");
            return statePtr();
        }
        return i->second;
    }

    stateStack &stateStack::operator<<(const engine::string &name)
    {
        stateMap::const_iterator i = _states.find(name);
        if (i == _states.end())
        {
            log("could not push state \"" + name + "\", not found in stack");
            return *this;
        }

        _stack.push_back(i->second);
        i->second->pushed(); // tell the state it got pushed

        return *this;
    }

    stateStack &stateStack::pop()
    {
        if (_stack.empty())
        {
            log("nothing to pop off stack");
            return *this;
        }
        statePtr ptr = _stack.back();
        _stack.pop_back();
        ptr->popped(); // tell the state it got popped
        return *this;
    }

    void stateStack::render()
    {
        if (_stack.empty())
        {
            log("no state on stack to render");
            return;
        }

        _stack.back()->render();
    }

    bool stateStack::tick(engine::real dt)
    {
        if (_stack.empty())
        {
            log("no state on stack to tick");
            return false;
        }

        _stack.back()->tick(dt, *this);

        return !_stack.empty();
    }


}