//
//  Tween.h
//
//  This code is derived from Universal Tween Engine
//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
//

#ifndef __Tween__
#define __Tween__

#include <TweenEngine/Tweenable.h>
#include <TweenEngine/BaseTween.h>
#include <TweenEngine/Pool.h>
#include <TweenEngine/TweenEquation.h>
#include <TweenEngine/TweenPath.h>
#include <TweenEngine/TweenEquations.h>
#include <TweenEngine/TweenPaths.h>

namespace TweenEngine
{
    class TweenPool;
    class TweenPoolCallback;
    
    class Tween : public BaseTween
    {
        friend class TweenPoolCallback;
        
    private:
        static int combinedAttrsLimit;
        static int waypointsLimit;
        
        // Main
        Tweenable *targetObj;
        int type;
        TweenEquation *equation;
        TweenPath *pathAlgorithm;

        // General
        bool isFrom;
        bool isRelative;
        int combinedAttrsCnt;
        int waypointsCnt;

        // Values
        float* startValues;
        float* targetValues;
        float* waypoints;
        
        // Buffers
        float *accessorBuffer;
        int accessorBufferSize;
        float *pathBuffer;
        int pathBufferSize;

        //static TweenPoolCallback *poolCallback;
        static TweenPool &pool;
        
        void setup(Tweenable *target, int tweenType, float duration);
        
    protected:
        virtual void reset();
        virtual void forceStartValues();
        virtual void forceEndValues();
        virtual void initializeOverride();
        virtual void updateOverride(int step, int lastStep, bool isIterationStep, float delta);
        
    public:
        static const int ACCESSOR_READ = 0;
        static const int ACCESSOR_WRITE = 1;

        static void setCombinedAttributesLimit(int limit);
        static void setWaypointsLimit(int limit);
        static const char *getVersion();
        
        static int getPoolSize();
        static void ensurePoolCapacity(int minCapacity);

        static Tween &to(Tweenable& target, int tweenType, float duration);
        static Tween &from(Tweenable& target, int tweenType, float duration);
        static Tween &set(Tweenable& target, int tweenType);
        static Tween &call(TweenCallback &callback);
        static Tween &mark();
        
        Tween();
        ~Tween();

        virtual int getTweenCount();
        virtual int getTimelineCount();
        
        virtual Tween &build();
        virtual void free();
        
        Tween &ease(TweenEquation &easeEquation);
        Tween &target(float targetValue);
        Tween &target(float targetValue1, float targetValue2);
        Tween &target(float targetValue1, float targetValue2, float targetValue3);
        Tween &target(float *targetValues, int len);
        Tween &targetRelative(float targetValue);
        Tween &targetRelative(float targetValue1, float targetValue2);
        Tween &targetRelative(float targetValue1, float targetValue2, float targetValue3);
        Tween &targetRelative(float *targetValues, int len);
        Tween &waypoint(float targetValue);
        Tween &waypoint(float targetValue1, float targetValue2);
        Tween &waypoint(float targetValue1, float targetValue2, float targetValue3);
        Tween &waypoint(float *targetValues, int len);
        Tween &path(TweenPath &path);
        int getType();
        TweenEquation *getEasing();
        float *getTargetValues();
        int getCombinedAttributesCount();

        
    };
}

#endif /* defined(__Tween__) */