/**
 * The outline of a ignite property which is a managed property that
 * can be used to invoke call back functions when the value of the property changes.
 */
class IgniteProperty {
    constructor(val) {
        this.onChangeCallbacks = [];
        this.onPushCallbacks = [];
        this.onPopCallbacks = [];
        this._value = val;

        //Attempt to patch the value if it's a list.
        this.patchListValue();
    }

    get value() {
        return this._value;
    }

    set value(val) {
        var old = this._value;
        this._value = val;

        //Attempt to patch the value if it's a list.
        this.patchListValue();

        //Invoke any callbacks letting them know the value changed.
        this.invokeOnChange(old, val);
    }

    patchListValue() {
        if (Array.isArray(this._value)) {
            let prop = this;

            this._value.push = function () {
                var len = Array.prototype.push.apply(this, arguments);
                prop.invokeOnPush();
                return len;
            };

            this._value.pop = function () {
                var len = Array.prototype.pop.apply(this, arguments);
                prop.invokeOnPop();
                return len;
            }
        }
    }

    invokeOnChange(oldValue, newValue) {
        for (var i = 0; i < this.onChangeCallbacks.length; i++) {
            this.onChangeCallbacks[i].invoke(oldValue, newValue);
        }
    }

    invokeOnPush() {
        for (var i = 0; i < this.onPushCallbacks.length; i++) {
            this.onPushCallbacks[i].invoke(null, this._value);
        }
    }

    invokeOnPop() {
        for (var i = 0; i < this.onPopCallbacks.length; i++) {
            this.onPopCallbacks[i].invoke(null, this._value);
        }
    }

    attachOnChange(onChange) {
        var callback = new IgnitePropertyOnChangeCallback(this, onChange);
        this.onChangeCallbacks.push(callback);
        return callback;
    }

    attachOnPush(onPush) {
        var callback = new IgnitePropertyOnPushCallback(this, onPush);
        this.onPushCallbacks.push(callback);
        return callback;
    }

    attachOnPop(onPop) {
        var callback = new IgnitePropertyOnPopCallback(this, onPop);
        this.onPopCallbacks.push(callback);
        return callback;
    }
}

/**
 * Return the value of the property if we try to convert
 * the property to a string.
 */
IgniteProperty.prototype.toString = function () {
    return this.value.toString();
}

/**
 * The outline of a ignite property onchange callback that allows
 * disconnecting of callbacks on demand when they are no longer needed.
 */
class IgnitePropertyOnChangeCallback {
    constructor(property, callback) {
        this.callback = callback;
        this.property = property;
    }

    invoke(oldValue, newValue) {
        if (this.callback) {
            this.callback(oldValue, newValue);
        }
    }

    disconnect() {
        this.callback = null;

        if (this.property) {
            this.property.onChangeCallbacks = this.property.onChangeCallbacks.filter(callback => callback != this);
            this.property = null;
        }
    }
}

/**
 * The outline of a ignite property onpush callback that allows
 * disconnecting of callbacks on demand when they are no longer needed.
 */
class IgnitePropertyOnPushCallback {
    constructor(property, callback) {
        this.callback = callback;
        this.property = property;
    }

    invoke(oldValue, newValue) {
        if (this.callback) {
            this.callback(oldValue, newValue);
        }
    }

    disconnect() {
        this.callback = null;

        if (this.property) {
            this.property.onPushCallbacks = this.property.onPushCallbacks.filter(callback => callback != this);
            this.property = null;
        }
    }
}

/**
 * The outline of a ignite property onpop callback that allows
 * disconnecting of callbacks on demand when they are no longer needed.
 */
class IgnitePropertyOnPopCallback {
    constructor(property, callback) {
        this.callback = callback;
        this.property = property;
    }

    invoke(oldValue, newValue) {
        if (this.callback) {
            this.callback(oldValue, newValue);
        }
    }

    disconnect() {
        this.callback = null;

        if (this.property) {
            this.property.onPopCallbacks = this.property.onPopCallbacks.filter(callback => callback != this);
            this.property = null;
        }
    }
}

/**
 * The outline of a simple rendering context which allows us to 
 * know if we are currently rendering anything ignite related. This works
 * because Javascript is single threaded, if events could break the current execution
 * this would fail. But it's safe since events cannot do that.
 */
class IgniteRenderingContext {
    static enter() {
        if (!IgniteRenderingContext.RenderCount) {
            IgniteRenderingContext.RenderCount = 0;
        }

        IgniteRenderingContext.RenderCount++;
    }

    static leave() {
        if (IgniteRenderingContext.RenderCount) {
            IgniteRenderingContext.RenderCount--;
        }
    }

    static get rendering() {
        if (IgniteRenderingContext.RenderCount && IgniteRenderingContext.RenderCount > 0) {
            return true;
        }

        return false;
    }
}

window.IgniteRenderingContext = IgniteRenderingContext;

export {
    IgniteProperty
};