//
//  AniMapLayer.h
//  SteveMaggieCpp
//
//  Created by Katarzyna Kalinowska-Górska on 17.05.2017.
//
//

#ifndef AniBasicMapController_h
#define AniBasicMapController_h

#include "IMapController.h"
#include "IMapAdventureObjectMapper.h"
#include "IMapControlInterface.h"

class AniBasicMapController : public IMapController, public IMapAdventureImageObjectLinker {
    
public:
    AniBasicMapController(cocos2d::TMXTiledMap* p_map, IMapAdventureObjectMapper* p_adventureObjectMapper);
    
    virtual void addBlockedTiles(std::vector<AniMapUtils::TileData> p_tiles, bool recalculateGraph) override;
    virtual void removeBlockedTiles(std::vector<AniMapUtils::TileData> p_tiles, bool recalculateGraph) override;
    
    inline cocos2d::TMXLayer* getTileLayer() override { return m_map->getLayer(TmxLayerName); }
    virtual cocos2d::TMXLayer* getTileObjectLayer() override { return m_map->getLayer(TmxLayerObjectsName);}
    inline int getBackgroundDepth() override { return m_backgroundDepth; }
    inline int getMaxObjectDepth() override { return m_maxObjectDepth; }
    
    virtual IMapImageObject* getMapImageObject(std::string p_objectName) override;
    virtual std::vector<IMapImageObject*> getMapImageObjects() override;
    virtual std::vector<IMapImageObject*> getMapImageObjectsBoundByRect(cocos2d::Rect p_rect) override;
    
    // map adventure objects
    virtual void parseAdventureObjects(const std::string& p_mapAdventureObjectsFile, IMapAdventureObjectDelegate* p_objectsDelegate) override;
    virtual std::vector<IMapAdventureObject*> getAdventureObjectsAtTile(const AniMapUtils::TileData& p_tileData, bool activeObjectsOnly = true) override;
    virtual void clearAdventureObjects(bool clearAssociatedImageObjects = true) override;
    virtual void clearAdventureObject(IMapAdventureObject* p_adventureObject, bool clearAssociatedImageObjects = true) override;
    virtual void remapAdventureObject(IMapAdventureObject* p_adventureObject) override;
    
    //TEMP
    virtual void insertMapImageObject(std::string objectName, IMapImageObject* object) override { m_mapImageObjects.insert({objectName, object}); }
    
    // camera
    virtual cocos2d::Vec2 moveCamera(float deltaX, float deltaY, bool animated = false) override;
    virtual bool setCameraCenter(cocos2d::Point position, bool instantEffect = false) override;
    virtual bool centerCameraOnNode(cocos2d::Node* p_node, bool instantEffect = false) override;
    virtual bool isInZoomMode() override {return m_isInZoomMode;}
    virtual void cancelZoomMode() override;
    
    virtual void revealTile(cocos2d::Vec2 tileCoord) override;
    virtual void revealTilesInRadius(cocos2d::Point p_center, float p_radiusX, float p_radiusY) override;
    
    // update
    virtual void update(float dt) override;
    
    virtual void reset() override;
    
    void setOnZoomModeEnteredCallback(std::function<void()> callback) { m_onZoomEnteredCallback = callback; }

    // IMapControlInterface
        
    virtual void handleCommandSingleXYPress(const IMapControlSingleXYEventData& eventData) override;
    virtual void handleCommandSingleXYMove(const IMapControlSingleXYEventData& eventData) override;
    virtual void handleCommandSingleXYRelease(const IMapControlSingleXYEventData& eventData) override;
    
    virtual void handleCommandMultipleXYPress(const std::vector<IMapControlSingleXYEventData>& eventData) override;
    virtual void handleCommandMultipleXYMove(const std::vector<IMapControlSingleXYEventData>& eventData) override;
    virtual void handleCommandMultipleXYRelease(const std::vector<IMapControlSingleXYEventData>& eventData) override;
    
    virtual void handleCommandSingleXYLongPress(const IMapControlSingleXYEventData& eventData) override {};
    virtual void handleCommandSingleXYTap(const IMapControlSingleXYEventData& eventData) override;
    virtual void handleCommandTicklingStarted() override {};
    virtual void handleCommandTicklingContinued() override {};
    virtual void handleCommandTicklingEnded() override {};
    virtual void handleCommandFastSwipe(const IMapControlSwipeEventData& eventData) override {};
    
protected:
    static constexpr char* TmxLayerName { const_cast<char*>("TileLayer") };
    static constexpr char* TmxLayerObjectsName { const_cast<char*>("TileLayerObjects") };
    const float MapAcceleration = -15000;
    
    cocos2d::Layer* m_mapAdditionalDarknessLayer {nullptr};
    
    // map image objects
    std::map<std::string, IMapImageObject*> m_mapImageObjects;
    int m_backgroundDepth {0}; //TODO THIS IS TEMP fill when parsing image objects
    int m_maxObjectDepth {30}; //TODO THIS IS TEMP fill when parsing image objects
    
    // map adventure objects
    std::vector<IMapAdventureObject*> m_adventureObjects; // here are the adv object allocated
    std::multimap<AniMapUtils::TileData, IMapAdventureObject*> m_adventureObjectsMapping; // mapping - tiles as keys, the same tile might host more than one adventure object, and multiple tiles might point to the same object
    
    // darkness handling
    struct TileDarknessData {
        TileDarknessData(bool p_dark) : dark(p_dark){}
        bool dark;
        std::vector<cocos2d::Sprite*> additionalSprites;
    };
    std::vector<std::vector<TileDarknessData> > m_darknessData;
//    std::multimap<cocos2d::Vec2, cocos2d::Sprite*> m_additionalDarknessSprites; // for tiles. key is tile coords.
    
    
    // TODO rename to m_
    bool _movingMap {false};
    double _currentMapVelocityX {0};
    double _currentMapVelocityY {0};
    long long _mapMoveStartTime;
    cocos2d::Point _mapMoveStartLocation;
    float m_mapZoomStartDistance;
    float m_mapZoomStartScale;
    float m_originalMapParentScale;
    cocos2d::Point m_originalAnchorPoint;
    cocos2d::Point m_originalMapPosition;
    bool m_isInZoomMode {false};
    bool m_isReturningFromZoomMode {false};
    float m_minMapScale {1.f};
    float m_maxMapScale {1.f};

    double _cutLeft {0};
    double _cutTop {0};
    double _cutRight {0};
    
    std::function<void()> m_onZoomEnteredCallback { [](){} };
    
    void parseMapProperties();
    
    float getMinAvailableCameraX(cocos2d::Size winSize);
    float getMaxAvailableCameraX(cocos2d::Size winSize);
    float getMinAvailableCameraY(cocos2d::Size winSize);
    float getMaxAvailableCameraY(cocos2d::Size winSize);
    
    void tut_sendMapMovingFinishedEvent();
    void tut_sendTappedToFinishMapMovingEvent();

};

#endif /* AniBasicMapController_h */