/**
 * This class is the root stub for managing a `ViewModel`.
 * @private
 */
Ext.define('Ext.app.bind.RootStub', {
    extend: 'Ext.app.bind.AbstractStub',
    requires: [
        'Ext.app.bind.LinkStub',
        'Ext.app.bind.Stub'
    ],
 
    isRootStub: true,
    
    depth: 0,
 
    createRootChild: function(name, direct) {
        var me = this,
            owner = me.owner,
            ownerData = owner.getData(),
            children = me.children,
            previous = children && children[name],
            parentStub = previous ? null : me,
            parentVM, stub;
 
        if (direct || ownerData.hasOwnProperty(name) || !(parentVM = owner.getParent())) {
            stub = new Ext.app.bind.Stub(owner, name, parentStub);
        }
        else {
            stub = new Ext.app.bind.LinkStub(owner, name, parentStub);
            stub.link('{' + name + '}', parentVM);
        }
 
        if (previous) {
            previous.graft(stub);
        }
 
        return stub;
    },
    
    createStubChild: function(name) {
        return this.createRootChild(name, true);
    },
 
    descend: function(path, index) {
        var me = this,
            children = me.children,
            pos = index || 0,
            name = path[pos++],
            ret = (children && children[name]) || me.createRootChild(name);
 
        if (pos < path.length) {
            ret = ret.descend(path, pos);
        }
 
        return ret;
    },
 
    getFullName: function() {
        return this.fullName || (this.fullName = this.owner.id + ':');
    },
 
    // The root Stub is associated with the owner's "data" object
 
    getDataObject: function() {
        return this.owner.data;
    },
 
    getRawValue: function() {
        return this.owner.data;
    },
 
    getValue: function() {
        return this.owner.data;
    },
 
    isDescendantOf: function() {
        return false;
    },
 
    set: function(value, preventClimb) {
        //<debug>
        if (!value || value.constructor !== Object) {
            Ext.raise('Only an object can be set at the root');
        }
        //</debug>
 
        /* eslint-disable-next-line vars-on-top */
        var me = this,
            children = me.children || (me.children = {}),
            owner = me.owner,
            data = owner.data,
            parentVM = owner.getParent(),
            stub, v, key, setSelf, created;
 
        for (key in value) {
            //<debug>
            if (key.indexOf('.') >= 0) {
                Ext.raise('Value names cannot contain dots');
            }
            //</debug>
 
            // Setting the value.
            // Ensure the Stub exists for the name, and set its value.
            v = value[key];
            
            if (v !== undefined) {
                stub = children[key];
                setSelf = preventClimb || !me.shouldClimb(key);
                
                if (!stub) {
                    stub = me.createRootChild(key, setSelf);
                    created = true;
                }
                else if (setSelf && stub.isLinkStub && !stub.getLinkFormulaStub()) {
                    stub = me.insertChild(key);
                }
 
                if (!created || !data.hasOwnProperty(value)) {
                    owner.invalidateChildLinks(key);
                }
                
                stub.set(v, setSelf);
            }
            // Clearing the value. Delete the data item
            // Invalidate the Stub if it exists.
            else if (data.hasOwnProperty(key)) {
                delete data[key];
 
                stub = children[key];
                
                if (stub) {
                    if (!stub.isLinkStub && parentVM) {
                        stub = me.createRootChild(key);
                    }
                    
                    owner.invalidateChildLinks(key, true);
                    stub.invalidate(true);
                }
            }
        }
    },
 
    schedule: Ext.emptyFn,
    
    unschedule: Ext.emptyFn,
 
    privates: {
        checkAvailability: function() {
            // Always available
            return true;
        },
 
        insertChild: function(name) {
            return this.createRootChild(name, true);
        },
 
        invalidateChildLink: function(name, clear) {
            var children = this.children,
                stub = children && children[name];
 
            if (stub && stub.isLinkStub && !stub.getLinkFormulaStub()) {
                stub = this.createRootChild(name);
                
                if (clear) {
                    stub.invalidate(true);
                }
                
                this.owner.invalidateChildLinks(name, clear);
            }
        },
 
        shouldClimb: function(name) {
            var parent = this.owner.getParent();
 
            while (parent) {
                if (parent.getData().hasOwnProperty(name)) {
                    return true;
                }
                
                parent = parent.getParent();
            }
 
            return false;
        }
    }
});