//Tyler Glaiel, 2015

//usage:

//create an instance of the Tweens class somewhere.
//I recommend you do this on your gameobject class,
//so when the game object gets destroyed it cancels
//all its tweens with it

//to make a tween, do myTweens.doTween(&valueToTween, endgoal, time, curve)

//you can chain additional tweens to happen after one tween finishes like so:
//doTween(...) -> then (endgoal, time, curve) -> then(...) -> etc;

//a single value can only be tweened by one tween at a time, setting new ones will overwrite old ones

//to cancel an in progress tween, do myTweens.cancelTween(&valueToTween)
//cancel tween will not fail if there is no tween on that value,
//it will just do nothing

//to update ALL tweens, call myTweens.updateTweens(timestep)


#pragma once
#include <vector>
#include <cmath>

struct TweenCurves {
    static float LINEAR(float t){ return t; }
    static float EASEIN(float t){ return t*t; }
    static float EASEOUT(float t){ return 1.0 - (1.0 - t)*(1.0 - t); }
    static float EASEINOUT(float t){ return 1.0 - (std::cos(t*3.141592) + 1.0)*.5f; }
    //write more curves wherever you want
};


//internal classes
class TweenData_Base {
public:
    void* _value; //only used to detect multiple tweens of the same data
    virtual void updateTween(float t)=0;
    virtual ~TweenData_Base(){};
};

template<typename T, typename F>
class TweenData : public TweenData_Base {
public:
    T begin;
    T end;

    T* value;
    F curve;

    TweenData(T* value, T begin, T end, F curve) : value(value), begin(begin), end(end), curve(curve) {_value=value;}

    virtual void updateTween(float t) {
        double t_adj = curve(t);
        *value = begin*(1.0 - t_adj) + end*t_adj;
    }
};

//the main tween class
class Tweens {
private:
    struct SingleTween {
        bool active;
        TweenData_Base* tween;
        float t;
        float totaltime;
        SingleTween* chain;
        SingleTween():active(false),tween(0),t(0),chain(0){}
        ~SingleTween(){ delete tween; delete chain; }

        template<typename T, typename F>
        SingleTween* then(T end, float totaltime = 1, F curve = TweenCurves::LINEAR){
            delete[] chain;
            TweenData<T, F>* tw = (TweenData<T, F>*)(tween);

            chain = new SingleTween();
            chain->active = false;
            chain->tween = new TweenData<T, F>(tw->value, tw->end, end, curve);
            chain->t = 0;
            chain->totaltime = totaltime;

            return chain;
        }
    };
    std::vector<SingleTween> tweens;

    //assignment, copying forbidden
    Tweens& operator=(const Tweens& rhs);
    Tweens(const Tweens& rhs);
public:
    Tweens(){}
    //curves

    template<typename T, typename F>
    SingleTween* doTween(T* value, T end, float totaltime = 1, F curve = TweenCurves::LINEAR){
        CancelTween(value);
        TweenData<T, F> *newTween = new TweenData<T, F>(value, *value, end, curve);
        return addTween(newTween, totaltime);
    }

    void CancelTween(void* value){
        for (int i = 0; i < tweens.size(); i++){
            if (tweens[i].active && tweens[i].tween->_value == value){
                tweens[i].active = false;
            }
        }
    }

    SingleTween* AddTweenAt(int i, TweenData_Base* tween, float totaltime){
        delete tweens[i].tween;
        delete tweens[i].chain;
        tweens[i].tween = tween;
        tweens[i].t = 0;
        tweens[i].active = true;
        tweens[i].totaltime = totaltime;
        tweens[i].chain = 0;
        return &tweens[i];
    }

    SingleTween* addTween(TweenData_Base* tween, float totaltime){
        for(int i = 0; i<tweens.size(); i++){
            if(!tweens[i].active){
                return AddTweenAt(i, tween, totaltime);
            }
        }
        tweens.push_back(SingleTween());
        return AddTweenAt(tweens.size()-1, tween, totaltime);
    }


    void updateTweens(float deltaTime = 1.0/60.0){
        for (int i = 0; i < tweens.size(); i++){
            if (tweens[i].active){
                tweens[i].t += deltaTime / tweens[i].totaltime;
                if(tweens[i].t > 1){
                    tweens[i].t = 1;
                    tweens[i].tween->updateTween(1);

                    if(tweens[i].chain){
                        delete tweens[i].tween;
                        tweens[i].tween = tweens[i].chain->tween;
                        tweens[i].t = 0;
                        tweens[i].totaltime = tweens[i].chain->totaltime;
                        SingleTween* oldchain = tweens[i].chain;
                        tweens[i].chain = tweens[i].chain->chain;
                        oldchain->chain = 0;
                        oldchain->tween = 0;
                        delete oldchain;
                    } else {
                        tweens[i].active = false;
                    }
                } else {
                    tweens[i].tween->updateTween(tweens[i].t);
                }
            }
        }
    }
};