HaveAction.hpp

/*
 * HaveAction.hpp
 *
 *  Created on: 06.05.2017
 *      Author: jakub
 */

#ifndef HAVEACTION_HPP_
#define HAVEACTION_HPP_

#include <SFML/System/String.hpp>
#include <map>
#include <functional>
#include "HaveEnabled.hpp"

template<typename T>
struct HaveActionHelper {
    using function_type = std::function<void (T)>;
};

template <>
struct HaveActionHelper<void> {
    using function_type = std::function<void ()>;
};


namespace ActionType {
    const char* const main = "main";
    const char* const destruction = "destruction";
}

template <typename T>
class HaveAction {
public:
    using function_type = typename HaveActionHelper<T>::function_type;

    HaveAction() {
        mainActionType = ActionType::main;
    }
    virtual ~HaveAction() {
        doAction(ActionType::destruction);
    }
    virtual void onSetAction(const sf::String& type) {}
    virtual void setAction(function_type&& action, const sf::String& type = ActionType::main) {
        if(type == ActionType::main) {
            onSetAction(mainActionType);
            this->action[mainActionType] = action;
        } else {
            onSetAction(type);
            this->action[type] = action;
        }
    }
    virtual void setAction(function_type& action, const sf::String& type = ActionType::main) {
        if(type == ActionType::main) {
            onSetAction(mainActionType);
            this->action[mainActionType] = action;
        } else {
            onSetAction(type);
            this->action[type] = action;
        }
    }
    virtual void setAction(std::function<void ()>&& action, const sf::String& type = ActionType::main) {
        if(type == ActionType::main) {
            onSetAction(mainActionType);
            actionVoid[mainActionType] = action;
        } else {
            onSetAction(type);
            actionVoid[type] = action;
        }
    }
    virtual void setAction(std::function<void ()>& action, const sf::String& type = ActionType::main) {
        if(type == ActionType::main) {
            onSetAction(mainActionType);
            actionVoid[mainActionType] = action;
        } else {
            onSetAction(type);
            actionVoid[type] = action;
        }
    }
    virtual void doAction(const sf::String& type = ActionType::main) {
        auto he = dynamic_cast<const HaveEnabled*>(this);
        if(he != nullptr && !he->isEnabled()) {
            return;
        }

        if(type == ActionType::main) {
            if(action[mainActionType]) {
                action[mainActionType](dynamic_cast<T>(*this));
            } else if(actionVoid[mainActionType]) {
                actionVoid[mainActionType]();
            }
        } else {
            if(action[type]) {
                action[type](dynamic_cast<T>(*this));
            } else if(actionVoid[type]) {
                actionVoid[type]();
            }
        }
    }

protected:
    std::map<sf::String,function_type> action;
    std::map<sf::String, std::function<void ()>> actionVoid;
    sf::String mainActionType;
};

template<>
class HaveAction<void> {
public:
    using function_type = typename HaveActionHelper<void>::function_type;

    HaveAction() {
        mainActionType = ActionType::main;
    }
    virtual ~HaveAction() {}
    virtual void onSetAction(const sf::String& type) {}
    virtual void setAction(function_type&& action, const sf::String& type = ActionType::main) {
        if(type == ActionType::main) {
            onSetAction(mainActionType);
            this->action[mainActionType] = action;
        } else {
            onSetAction(type);
            this->action[type] = action;
        }
    }
    virtual void setAction(function_type& action, const sf::String& type = ActionType::main) {
        if(type == ActionType::main) {
            onSetAction(mainActionType);
            this->action[mainActionType] = action;
        } else {
            onSetAction(type);
            this->action[type] = action;
        }
    }
    virtual void doAction(const sf::String& type = ActionType::main) {
        auto he = dynamic_cast<const HaveEnabled*>(this);
        if(he != nullptr && !he->isEnabled()) {
            return;
        }

        if(type == ActionType::main && action[mainActionType]) {
            action[mainActionType]();
        } else if(action[type]) {
            action[type]();
        }
    }

protected:
    std::map<sf::String,function_type> action;
    sf::String mainActionType;

};

#endif /* HAVEACTION_HPP_ */