Ticker factory

import { animation, animationtickers, constructors, tween } from '../core/library.js';

import { convertTime, doCreate, isa_obj, mergeOver, pushUnique, removeItem, xt, Ωempty } from '../helper/utilities.js';

import { makeAnimation } from './animation.js';

import { releaseArray, requestArray } from '../helper/array-pool.js';

import baseMix from '../mixin/base.js';

import { _floor, _now, FUNCTION, PC, T_ACTION, T_RENDER_ANIMATION, T_TICKER, T_TWEEN, ZERO_STR } from '../helper/shared-vars.js';

const ANIMATIONTICKERS = 'animationtickers'

const Ticker = function (items = Ωempty) {

    this.makeName(items.name);
    this.register();

    this.subscribers = [];
    this.subscriberObjects = [];

    this.set(this.defs);
    this.set(items);

    this.cycleCount = 0;
    this.active = false;
    this.effectiveDuration = 0;
    this.startTime = 0;
    this.currentTime = 0;
    this.tick = 0;

    if (items.subscribers) this.subscribe(items.subscribers);

    this.setEffectiveDuration();
    return this;
};

const P = Ticker.prototype = doCreate();
P.type = T_TICKER;
P.lib = ANIMATIONTICKERS;
P.isArtefact = false;
P.isAsset = false;

baseMix(P);

const defaultAttributes = {

    order: 1,

    duration: 0,

    subscribers: null,

    killOnComplete: false,

    cycles: 1,

    observer: null,

    onRun: null,
    onHalt: null,
    onReverse: null,
    onResume: null,
    onSeekTo: null,
    onSeekFor: null,
    onComplete: null,
    onReset: null,
};
P.defs = mergeOver(P.defs, defaultAttributes);

P.packetExclusions = pushUnique(P.packetExclusions, ['subscribers']);
P.packetFunctions = pushUnique(P.packetFunctions, ['onRun', 'onHalt', 'onReverse', 'onResume', 'onSeekTo', 'onSeekFor', 'onComplete', 'onReset']);

P.kill = function (killTweens = true, autokill = true) {

    if (killTweens) {

        const subs = [...this.subscribers];

        for (let i = 0, iz = subs.length; i < iz; i++) {

            const sub = tween[subs[i]];

            if (sub) {

                sub.completeAction();
                sub.kill();
            }
        }
    }

    if (autokill) {

        if (this.active) this.halt();

        removeItem(tickerAnimations, this.name);
        tickerAnimationsFlag = true;

        this.deregister();

        return true;
    }
    return this;
};

P.killTweens = function(autokill = false) {

    return this.kill(true, autokill);
};

const G = P.getters,
    S = P.setters;

G.subscribers = function () {

    return [...this.subscribers];
};
S.subscribers = function (item) {

    this.subscribe(item);
};

S.order = function (item) {

    this.order = item;

    if (this.active) tickerAnimationsFlag = true;
};

S.cycles = function (item) {

    this.cycles = item;

    if (!this.cycles) this.cycleCount = 0;
};

S.duration = function (item) {

    let i, iz, target;

    const subscribers = this.subscribers;

    this.duration = item;
    this.setEffectiveDuration();

    if(xt(subscribers)){

        for (i = 0, iz = subscribers.length; i < iz; i++) {

            target = tween[subscribers[i]];

            if (target) {

                target.calculateEffectiveTime();

                if (target.type === T_TWEEN) target.calculateEffectiveDuration();
            }
        }
    }
};

P.subscribe = function (...args) {

    const items = args.flat(Infinity);

    if (items.length) {

        items.forEach(item => {

            let obj;

            if (item.substring) obj = tween[item];
            else if (isa_obj(item) && (item.type === T_ACTION || item.type === T_TWEEN)) obj = item;

            if (obj) {

                pushUnique(this.subscribers, obj.name);
                obj.ticker = this.name;
                obj.calculateEffectiveTime();
            }
        });

        this.sortSubscribers();
        this.recalculateEffectiveDuration();
    }
    return this;
};

P.unsubscribe = function (...args) {

    const items = args.flat(Infinity);

    if (items.length) {

        items.forEach(item => {

            let obj;

            if (item.substring) obj = tween[item];
            else if (isa_obj(item) && (item.type === T_ACTION || item.type === T_TWEEN)) obj = item;

            if (obj) {

                removeItem(this.subscribers, obj.name);
                obj.ticker = ZERO_STR;
            }
        });

        this.sortSubscribers();
        this.recalculateEffectiveDuration();
    }
    return this;
};

P.repopulateSubscriberObjects = function () {

    const arr = this.subscriberObjects,
        subs = this.subscribers;

    let t;

    arr.length = 0;

    subs.forEach(sub => {

        t = tween[sub];
        if (t) arr.push(t);
    });
};

P.getSubscriberObjects = function () {

    if (this.subscribers.length && !this.subscriberObjects.length) this.repopulateSubscriberObjects();

    return this.subscriberObjects;
};

P.sortSubscribers = function () {

    const subs = this.subscribers,
        len = subs.length;

    if(len > 1) {

        const buckets = requestArray();

        let i, sub;

        for (i = 0; i < len; i++) {

            sub = tween[subs[i]];

            if (sub) buckets.push(sub);
        }

        if (buckets.length > 1) buckets.sort((a, b) => a.effectiveTime - b.effectiveTime);

        subs.length = 0;

        for (i = 0; i < buckets.length; i++) {

            subs.push(buckets[i].name);
        }

        releaseArray(buckets);
    }
    this.repopulateSubscriberObjects();
};

P.updateSubscribers = function(items, reversed) {

    reversed = (xt(reversed)) ? reversed : false;

    const subs = this.getSubscriberObjects();

    let i, iz;

    if (reversed) {

        for (i = subs.length - 1; i >= 0; i--) {

            subs[i].set(items);
        }
    }
    else{

        for (i = 0, iz = subs.length; i < iz; i++) {

            subs[i].set(items);
        }
    }
    return this;
};

P.changeSubscriberDirection = function () {

    const subs = this.getSubscriberObjects();

    subs.forEach(sub => sub.reversed = !sub.reversed);

    return this;
};

P.recalculateEffectiveDuration = function() {

    const subs = this.getSubscriberObjects();

    let durationValue,
        duration = 0;

    if (!this.duration) {

        subs.forEach(sub => {

            durationValue = sub.getEndTime();

            if (durationValue > duration) duration = durationValue;
        });
        this.effectiveDuration = duration;
    }

    else this.setEffectiveDuration();

    return this;
};

P.setEffectiveDuration = function() {

    let temp;

    if (this.duration) {

        temp = convertTime(this.duration);

        if (temp[0] === PC) {

            this.duration = 0
            this.recalculateEffectiveDuration();
        }
        else this.effectiveDuration = temp[1];
    }
    return this;
};

P.checkObserverRunningState = function () {

    let observer = this.observer;

    if (observer) {

        if (observer.substring) {

            const anim = animation[observer];

            if (anim && anim.type === T_RENDER_ANIMATION) {

                observer = this.observer = anim;
            }
            else return true;
        }
        if (observer.type === T_RENDER_ANIMATION) {

            return observer.isRunning();
        }
    }
    return true;
};

P.fn = function (reverseOrder) {

    reverseOrder = xt(reverseOrder) ? reverseOrder : false;

    const result = requestResultObject();

    const startTime = this.startTime,
        cycles = this.cycles,
        effectiveDuration = this.effectiveDuration;

    let i, iz, subs,
        currentTime, tick,
        active = this.active,
        cycleCount = this.cycleCount;

    if (active && startTime) {

        if (!cycles || cycleCount < cycles) {

            currentTime = this.currentTime = _now();
            tick = this.tick = currentTime - startTime;

            if (!cycles || cycleCount + 1 < cycles) {

                if (tick >= effectiveDuration) {

                    tick = this.tick = 0;
                    this.startTime = this.currentTime;
                    result.tick = effectiveDuration;
                    result.reverseTick = 0;
                    result.willLoop = true;

                    if (cycles) {

                        cycleCount++;
                        this.cycleCount = cycleCount;
                    }
                }
                else {

                    result.tick = tick;
                    result.reverseTick = effectiveDuration - tick;
                }
                result.next = true;
            }

            else {

                if (tick >= effectiveDuration) {

                    result.tick = effectiveDuration;
                    result.reverseTick = 0;
                    active = this.active = false;

                    if (cycles) {

                        cycleCount++
                        this.cycleCount = cycleCount;
                    }
                }
                else {

                    result.tick = tick;
                    result.reverseTick = effectiveDuration - tick;
                    result.next = true;
                }
            }

            subs = this.getSubscriberObjects();

            if (reverseOrder) {

                for (i = subs.length - 1; i >= 0; i--) {

                    subs[i].update(result);
                }
            }
            else{

                for (i = 0, iz = subs.length; i < iz; i++) {

                    subs[i].update(result);
                }
            }

            if (!active) this.halt();

            if (this.killOnComplete && cycleCount >= cycles) this.killTweens(true);
        }
    }

    releaseResultObject(result);
};

P.run = function () {

    if (!this.active) {

        this.startTime = this.currentTime = _now();
        this.cycleCount = 0;

        this.updateSubscribers({
            reversed: false
        });

        this.active = true;

        pushUnique(tickerAnimations, this.name);
        tickerAnimationsFlag = true;

        if (typeof this.onRun === FUNCTION) this.onRun();
    }
    return this;
};

P.isRunning = function () {

    return this.active;
};

P.reset = function () {

    if (this.active) this.halt();

    this.startTime = this.currentTime = _now();
    this.cycleCount = 0;

    this.updateSubscribers({
        reversed: false
    });

    this.active = true;

    this.fn(true);
    this.active = false;

    if (typeof this.onReset === FUNCTION) this.onReset();

    return this;
};

P.complete = function () {

    if (this.active) this.halt();

    this.startTime = this.currentTime = _now();
    this.cycleCount = 0;

    this.updateSubscribers({
        reversed: true
    });

    this.active = true;

    this.fn();
    this.active = false;

    if (typeof this.onComplete === FUNCTION) this.onComplete();

    return this;
};

P.reverse = function (resume = false) {

    if (this.active) this.halt();

    const timePlayed = this.currentTime - this.startTime;
    this.startTime = this.currentTime - (this.effectiveDuration - timePlayed);
    this.changeSubscriberDirection();
    this.active = true;

    this.fn();
    this.active = false;

    if (typeof this.onReverse === FUNCTION) this.onReverse();

    if (resume) this.resume();

    return this;
};

P.halt = function () {

    this.active = false;
    removeItem(tickerAnimations, this.name);
    tickerAnimationsFlag = true;

    if (typeof this.onHalt === FUNCTION) this.onHalt();

    return this;
};

P.resume = function () {

    let now, current, start;

    if (!this.active) {

        now = _now();
        current = this.currentTime;
        start = this.startTime;
        this.startTime = now - (current - start);
        this.currentTime = now;
        this.active = true;
        pushUnique(tickerAnimations, this.name);
        tickerAnimationsFlag = true;

        if (typeof this.onResume === FUNCTION) this.onResume();

    }
    return this;
};

P.seekTo = function (milliseconds = 0, resume = false) {

    let backwards = false;

    if (this.active) this.halt();

    if (this.cycles && this.cycleCount >= this.cycles) this.cycleCount = this.cycles - 1;

    if (milliseconds < this.tick) backwards = true;

    this.currentTime = _now();
    this.startTime = this.currentTime - milliseconds;
    this.active = true;

    this.fn(backwards);
    this.active = false;

    if (typeof this.onSeekTo === FUNCTION) this.onSeekTo();

    if (resume) this.resume();

    return this;
};

P.seekFor = function (milliseconds = 0, resume = false) {

    let backwards = false;

    if (this.active) this.halt();

    if (this.cycles && this.cycleCount >= this.cycles) this.cycleCount = this.cycles - 1;

    this.startTime -= milliseconds;

    if (milliseconds < 0) backwards = true;

    this.active = true;

    this.fn(backwards);
    this.active = false;

    if (typeof this.onSeekFor === FUNCTION) this.onSeekFor();

    if (resume) this.resume();

    return this;
};

const tickerAnimations = [];
let tickerAnimationsFlag = true;

makeAnimation({

    name: 'SC-core-tickers-animation',
    order: 0,
    fn: function () {

        let arr, obj, order, i, iz, name;

        if (tickerAnimationsFlag) {

            tickerAnimationsFlag = false;

            const buckets = requestArray();

            for (i = 0, iz = tickerAnimations.length; i < iz; i++) {

                obj = animationtickers[tickerAnimations[i]];

                if (obj) {

                    order = _floor(obj.order) || 0;

                    if (!buckets[order]) buckets[order] = requestArray();

                    buckets[order].push(obj.name);
                }
            }
            tickerAnimations.length = 0;

            for (i = 0, iz = buckets.length; i < iz; i++) {

                arr = buckets[i];

                if (arr) {

                    tickerAnimations.push(...arr);
                    releaseArray(arr);
                }
            }
            releaseArray(buckets);
        }

        for (i = 0, iz = tickerAnimations.length; i < iz; i++) {

            name = tickerAnimations[i];
            obj= animationtickers[name];

            if (obj && obj.fn && obj.checkObserverRunningState()) obj.fn();
        }
    }
});

const resultObjectPool = [];

const requestResultObject = function () {

    if (!resultObjectPool.length) {

        resultObjectPool.push({
            tick: 0,
            reverseTick: 0,
            willLoop: false,
            next: false
        });
    }

    return resultObjectPool.pop();
};

const releaseResultObject = function (r) {

    if (r) {

        r.tick = 0;
        r.reverseTick = 0;
        r.willLoop = false;
        r.next = false;
        resultObjectPool.push(r);
    }
};

export const makeTicker = function (items) {

    if (!items) return false;
    return new Ticker(items);
};

constructors.Ticker = Ticker;