var _ = require('../util').lodash,
    PropertyList = require('./property-list').PropertyList,
    Property = require('./property').Property,
    Variable = require('./variable').Variable,

    VariableList;

_.inherit((

    /**
     * @constructor
     * @extends {PropertyList}
     *
     * @param {Property} parent -
     * @param {Object|Array} populate -
     */
    VariableList = function PostmanVariableList (parent, populate) {
        // this constructor is intended to inherit and as such the super constructor is required to be executed
        VariableList.super_.call(this, Variable, parent, populate);
    }), PropertyList);

_.assign(VariableList.prototype, /** @lends VariableList.prototype */ {
    /**
     * Replaces the variable tokens inside a string with its actual values.
     *
     * @param {String} str -
     * @param {Object} [overrides] - additional objects to lookup for variable values
     * @returns {String}
     */
    replace (str, overrides) {
        return Property.replaceSubstitutions(str, this, overrides);
    },

    /**
     * Recursively replace strings in an object with instances of variables. Note that it clones the original object. If
     * the `mutate` param is set to true, then it replaces the same object instead of creating a new one.
     *
     * @param {Array|Object} obj -
     * @param {?Array<Object>=} [overrides] - additional objects to lookup for variable values
     * @param {Boolean=} [mutate=false] -
     * @returns {Array|Object}
     */
    substitute (obj, overrides, mutate) {
        var resolutionQueue = [], // we use this to store the queue of variable hierarchy

            // this is an intermediate object to stimulate a property (makes the do-while loop easier)
            variableSource = {
                variables: this,
                __parent: this.__parent
            };

        do { // iterate and accumulate as long as you find `.variables` in parent tree
            variableSource.variables && resolutionQueue.push(variableSource.variables);
            variableSource = variableSource.__parent;
        } while (variableSource);

        variableSource = null; // cautious cleanup

        return Property.replaceSubstitutionsIn(obj, _.union(resolutionQueue, overrides), mutate);
    },

    /**
     * Using this function, one can sync the values of this variable list from a reference object.
     *
     * @param {Object} obj -
     * @param {Boolean=} track -
     * @param {Boolean} [prune=true] -
     *
     * @returns {Object}
     */
    syncFromObject (obj, track, prune) {
        var list = this,
            ops = track && {
                created: [],
                updated: [],
                deleted: []
            },
            indexer = list._postman_listIndexKey,
            tmp;

        if (!_.isObject(obj)) { return ops; }

        // ensure that all properties in the object is updated in this list
        _.forOwn(obj, function (value, key) {
            // we need to create new variable if exists or update existing
            if (list.has(key)) {
                list.one(key).set(value);
                ops && ops.updated.push(key);
            }
            else {
                tmp = { value };
                tmp[indexer] = key;
                list.add(tmp);
                tmp = null;
                ops && ops.created.push(key);
            }
        });

        // now remove any variable that is not in source object
        // @note - using direct `this.reference` list of keys here so that we can mutate the list while iterating
        // on it
        if (prune !== false) {
            _.forEach(list.reference, function (value, key) {
                if (_.has(obj, key)) { return; } // de not delete if source obj has this variable
                list.remove(key); // use PropertyList functions to remove so that the .members array is cleared too
                ops && ops.deleted.push(key);
            });
        }

        return ops;
    },

    /**
     * Transfer all variables from this list to an object
     *
     * @param {Object=} [obj] -
     * @returns {Object}
     */
    syncToObject (obj) {
        var list = this;

        // in case user did not provide an object to mutate, create a new one
        !_.isObject(obj) && (obj = {});

        // delete extra variables from object that are not present in list
        _.forEach(obj, function (value, key) {
            !_.has(list.reference, key) && (delete obj[key]);
        });

        // we first sync all variables in this list to the object
        list.each(function (variable) {
            obj[variable.key] = variable.valueOf();
        });

        return obj;
    },

    /**
     * Fetches a variable and normalize its reference if disabled.
     * This updates the disabled variable `reference` in VariableList with its
     * last enabled duplicate(if found) in the `members` list.
     *
     * @private
     * @param {String} variableName - The name of the variable to get
     * @returns {Variable} - In case of duplicates, returns last enabled
     */
    oneNormalizedVariable (variableName) {
        var indexKey = this._postman_listIndexKey, // `key` for Variable
            variable = this.reference[variableName],
            i;

        if (variable && !variable.disabled) {
            return variable;
        }

        // traverse the members list in reverse direction in order to find the last enabled
        for (i = this.members.length - 1; i >= 0; i--) {
            variable = this.members[i];
            if (variable[indexKey] === variableName && !variable.disabled) {
                // update the input variable reference if comparison is not disabled
                this.reference[variableName] = variable;
                break; // return updated reference variable
            }
        }

        return this.reference[variableName];
    }
});

_.assign(VariableList, /** @lends VariableList */ {
    /**
     * Defines the name of this property for internal use.
     *
     * @private
     * @readOnly
     * @type {String}
     *
     * @note that this is directly accessed only in case of VariableList from _.findValue lodash util mixin
     */
    _postman_propertyName: 'VariableList',

    /**
     * Checks whether an object is a VariableList
     *
     * @param {*} obj -
     * @returns {Boolean}
     */
    isVariableList: function (obj) {
        return Boolean(obj) && ((obj instanceof VariableList) ||
            _.inSuperChain(obj.constructor, '_postman_propertyName', VariableList._postman_propertyName));
    }
});

module.exports = {
    VariableList
};