//Statemanager.h
#ifndef STATEMANAGER_H
#define STATEMANAGER_H

#include "State.h"
#include <map>

class StateManager
{
private:
  //Speichert alle Zustände als Assoziatives Array
  std::map<std::string, State*> _statesById;
  //Aktueller Zustand
  State *_currentState;

public:
  StateManager();
  ~StateManager();

  void AddState(const std::string &id, State *state);
  void SetState(const std::string &id);
  bool Update(float elapsedTime);
  void Render();
};

#endif

//Statemanager.cpp
#include "StateManager.h"

//erzeugt ein StateManager-Objekt
StateManager::StateManager():
  _currentState(NULL)
{
}

//Löscht das StateManager-objekt mit allen Zuständen.
StateManager::~StateManager()
{
    for(std::map<std::string, State*>::iterator it = _statesById.begin(); it != _statesById.end(); ++it)
    {
        delete (*it).second;
    }
}

//Registriert einen Zustand für den Manager an Hand der ID. Diese muss
//eindeutig und nicht leer sein.
void StateManager::AddState(const std::string &id, State *state)
{
    if (id.length() == 0)
        throw std::exception("Id has to be a valid string");
    if (state == NULL)
        throw std::exception("State must not be null");

    std::map<std::string, State*>::iterator it = _statesById.find(id);
    if (it != _statesById.end())
    {
        std::string error("State with ID ");
        error.append(id);
        error.append(" already exist.");
        throw std::exception(error.c_str());
    }

    _statesById[id] = state;
}

//Setzt den aktuellen Zustand
void StateManager::SetState(const std::string &id)
{
    std::map<std::string, State*>::iterator nextStateIt = _statesById.find(id);

    //Wenn der Zustand im Manager registriert ist
    if (nextStateIt != _statesById.end())
    {
        //und nicht der aktuelle ist
        if (nextStateIt->second != _currentState)
        {
            //Rufe OnLeave() vom alten Zustand auf, falls es einen gab
            if (_currentState != NULL)
                _currentState->OnLeave();

            //setze den neuen aktuellen Zustand
            _currentState = nextStateIt->second;

            //Da zu einem neuen Zustand gewechselt worden ist, rufe das Eingangsereignis auf
            _currentState->OnEnter();
        }
    }
    else
        //ansonsten gibt es diesen Zustand nicht!
        throw std::exception("State does not exist.");
}

//Aktualisert den Spielzustand. der Rückgabewert gibt an, ob das Programm weiterläuft.
//Es läuft nicht weiter, wenn der aktuelle Zustand verlassen und kein weiterer Zustand zugewiesen wird.
bool StateManager::Update(float elapsedTime)
{
    //Es muss ein Zustand gesetzt sein!
    if (_currentState == NULL)
        throw std::exception("Current state not set.");

    //aktualisere den Zustand und schaue, ob der Zustand eventuell verlassen werden soll
    bool running = _currentState->OnUpdate(elapsedTime);

    //wenn er verlassen werden soll und der Folgezustand gesetzt ist
    if (!running && !_currentState->NextState().length() > 0)
    {
        //Wechsle den Zustand
        SetState(_currentState->NextState());

        //Programm läuft weiter
        return true;
    }

    //
    return running;
}

//Zeichnet den aktuellen Zustand.
void StateManager::Render()
{
    //Es muss ein Zustand gesetzt sein!
    if (_currentState == NULL)
        throw std::exception("Current state not set.");

    //Zeichne den aktuellen Zustand
    _currentState->OnRender();
}