//
//  ScenarioHandler.h
//  SteveMaggieCpp
//
//  Created by Katarzyna Kalinowska-Górska on 23.05.2017.
//
//

#ifndef ScenarioHandler_h
#define ScenarioHandler_h

#include "json/document.h"
#include "LayoutObject.h"
//#include "ScenarioObject.h"
#include "ActionParser.h"
#include "TimeIndicatorInterface.h"

class ParentScene;

class ScenarioHandler : public ScenarioObject, public ActionParseDelegate
{
    public:
    
        static const std::string DEMO_STATE_UNINITIALIZED;
        static const std::string DEMO_STATE_PLAYING;
        static const std::string DEMO_STATE_FINISHED;
        static const std::string DEMO_STATE_NEVER_PLAYED;

        ScenarioHandler(ParentScene* scene);
        virtual ~ScenarioHandler();
    
        virtual void end();
        virtual void loadScenarioFromJSONString(std::string jsonString, bool skipDemoActions);
        virtual void loadScenarioFromJSONObject(const rapidjson::Value& jsonObject, bool skipDemoActions, bool isReplay = false);
        virtual void reloadScenario(bool skipDemo, bool isReplay);
        virtual void runScenario();
        virtual void pauseScenario();
        virtual void resumeScenario();
        virtual void resetScenario(bool skipDemo, bool reloadLayout = true);
    
        virtual std::string getDemoState(){ return _demoState; };
        virtual void stopAllActions();
    
        // sounds
    
        void preloadSoundEffects(std::vector<rapidjson::Value*> actions);
        void preloadSoundEffects(const rapidjson::Value& action);
        void stopAllSoundEffects();
    
        // timer
        void startTimer(float pTimeToFinish, float step, const rapidjson::Value* actionsOnProgressStep, const rapidjson::Value* actionsOnTimeUp, bool finishScenarioAfterTimeUp, std::string timeIndicatorObjectName);
        void stopTimer();
        void pauseTimer();
        void resumeTimer();
        
    
        // ActionParseDelegate
        virtual ScenarioObject* getObjectByName(std::string objectName) override;
        virtual ScenarioObject* getDefaultObjectForAction(std::string actionType) override;
        virtual ScenarioObject* getDefaultObjectForConditionCheck() override;
        virtual void addNewObject(std::string objectName, ScenarioObject* newObject) override;
        virtual std::string getDefaultSoundsPath() override;
        virtual std::string getAlternativeSoundsPath() override;
        virtual std::string getValueStorageContainerName() override;
        virtual void runAction(cocos2d::Action* action) override;
        virtual void actionFinished(const rapidjson::Value& jsonActionObject) override;
        virtual void runInstantly(std::function<void()> actionFunction) override;
        virtual void runCompletingAction(cocos2d::Action* action) override;
        virtual void cancelAllCompletingActions() override;
        virtual void schedule(std::function<void(float)> callback, std::string key, float delay) override;
        virtual void scheduleOnce(std::function<void(float)> callback, float delay, std::string key) override;
        virtual void unschedule(std::string key) override;
        virtual void newTouchHandler(std::string key, TouchHandlerFunction touchHandler, TouchHandlerType touchType) override;
        virtual void removeTouchHandler(std::string key, TouchHandlerType touchType) override;
        virtual long long getLastScreenTouchTime() override;
        virtual int getLoopActionCounter(std::string loopId) override;
        virtual int addNewLoopActionCounter(std::string loopId, int timesRepeated) override;
        virtual int decrementLoopActionCounter(std::string loopId) override;
        virtual void deleteLoopActionCounter(std::string loopId) override;
        virtual void setLastActionIndex(int index) override;
        virtual unsigned int removeStoredSoundId(std::string soundPath) override;
        virtual void storeSoundId(std::string soundPath, unsigned int newSoundId) override;
    
        // ScenarioObject
        virtual void setProperty(std::string propertyName, const rapidjson::Value& newValue, ActionParseDelegate* parseDelegate) override;
        virtual void callFunctionByName(std::string methodName, const rapidjson::Value* arguments, ActionParseDelegate* parseDelegate, std::function<void()> callback = [](){}) override;
    
        virtual bool shouldSkipLayoutReloadOnFastForward(){return _shouldSkipLayoutReloadOnFastForward; }
    
    protected:
    
        ParentScene* _scene;
    
        std::string _soundsResFolder;
        std::string _altSoundsResFolder;
    
        bool _shouldSkipLayoutReloadOnFastForward;
    
        std::string _valueStorageContainerName;
        std::string _cachedJSONString;
        rapidjson::Document* _cachedJSONData;
        std::vector<rapidjson::Value*> _actionsSequence;
        std::map<std::string, rapidjson::Value*> _predefinedActions;
        std::map<std::string, int> _loopActionCounters;
        int _lastActionIndex;
        std::vector<int> _currentCompletingActionTags;
    
//        rapidjson::Value* _onTimerCountdownAction;
        std::vector<rapidjson::Value*> _actionsOnTimerUp;
    
        bool _scenarioPaused;
        bool _scenarioBarred;
        bool _scenarioFinished;
        bool _timerRunning;
        float _timerStep;
        float _timePassed;
        float _totalTimerTime;
        TimeIndicatorInterface* _timeSlider;
    
        std::string _demoState;
        std::map<std::string, int> _storedSoundIds;
    
        virtual void clearSetup();
        virtual void clearAllScheduledActions();
    
        virtual void prepareAction(const rapidjson::Value* action);
        virtual void trimActions(std::vector<rapidjson::Value*>& actions);
        virtual void mergeSequences(std::vector<rapidjson::Value*>& actions);
        void simpleCopyActionsToMainSequence(std::vector<rapidjson::Value*> actions);
};

#endif /* ScenarioHandler_h */