var config      = require('./config'),
    ViewModel   = require('./viewmodel'),
    directives  = require('./directives'),
    filters     = require('./filters'),
    utils       = require('./utils')

/**
 *  Set config options
 *  设置配置选项
 */
ViewModel.config = function (opts) {
    if (opts) {
        utils.extend(config, opts)
        if (opts.prefix) updatePrefix()
    }
    return this
}

/**
 *  Allows user to register/retrieve a directive definition
 *  允许用户注册/检索指令定义
 */
ViewModel.directive = function (id, fn) {
    if (!fn) return directives[id]
    directives[id] = fn
    return this
}

/**
 *  Allows user to register/retrieve a filter function
 *  允许用户注册/检索筛选函数
 */
ViewModel.filter = function (id, fn) {
    if (!fn) return filters[id]
    filters[id] = fn
    return this
}

/**
 *  Allows user to register/retrieve a ViewModel constructor
 *  允许用户注册/检索ViewModel构造函数
 */
ViewModel.component = function (id, Ctor) {
    if (!Ctor) return utils.components[id]
    utils.components[id] = utils.toConstructor(Ctor)
    return this
}

/**
 *  Allows user to register/retrieve a Custom element constructor
 *  允许用户注册/检索自定义元素构造函数
 */
ViewModel.element = function (id, Ctor) {
    if (!Ctor) return utils.elements[id]
    utils.elements[id] = utils.toConstructor(Ctor)
    return this
}

/**
 *  Allows user to register/retrieve a template partial
 *  允许用户注册/检索部分模板
 */
ViewModel.partial = function (id, partial) {
    if (!partial) return utils.partials[id]
    utils.partials[id] = utils.toFragment(partial)
    return this
}

/**
 *  Allows user to register/retrieve a transition definition object
 *  允许用户注册/检索转换定义对象
 */
ViewModel.transition = function (id, transition) {
    if (!transition) return utils.transitions[id]
    utils.transitions[id] = transition
    return this
}

ViewModel.extend = extend

/**
 *  Expose the main ViewModel class
 *  and add extend method
 *  公开主ViewModel类并添加extend方法
 */
function extend (options) {

    var ParentVM = this

    // inherit options
    // 继承选项
    options = inheritOptions(options, ParentVM.options, true)
    utils.processOptions(options)

    var ExtendedVM = function (opts) {
        opts = inheritOptions(opts, options, true)
        ParentVM.call(this, opts)
    }

    // inherit prototype props
    // 继承原型props属性
    var proto = ExtendedVM.prototype = Object.create(ParentVM.prototype)
    utils.defProtected(proto, 'constructor', ExtendedVM)

    // copy prototype props
    // 复制原型props属性
    var protoMixins = options.proto
    if (protoMixins) {
        for (var key in protoMixins) {
            if (!(key in ViewModel.prototype)) {
                proto[key] = protoMixins[key]
            }
        }
    }

    // allow extended VM to be further extended
    // 允许扩展VM进一步扩展
    ExtendedVM.extend = extend
    ExtendedVM.super = ParentVM
    ExtendedVM.options = options
    return ExtendedVM
}

/**
 *  Inherit options
 *  继承选项
 *
 *  For options such as `scope`, `vms`, `directives`, 'partials',
 *  they should be further extended. However extending should only
 *  be done at top level.
 *  对于'scope'、'vms'、'directives'、'partials'等选项，它们应该进一步扩展。
 *  然而，扩展只能在顶层完成。
 * 
 *  `proto` is an exception because it's handled directly on the
 *  prototype.
 *  `proto`是一个例外，因为它直接在原型上处理。
 *
 *  `el` is an exception because it's not allowed as an
 *  extension option, but only as an instance option.
 *  `el`是一个例外，因为它不允许作为扩展选项，而只能作为实例选项。
 */
function inheritOptions (child, parent, topLevel) {
    child = child || utils.hash()
    if (!parent) return child
    for (var key in parent) {
        if (key === 'el' || key === 'proto') continue
        if (!child[key]) { // child has priority
            child[key] = parent[key]
        } else if (topLevel && utils.typeOf(child[key]) === 'Object') {
            inheritOptions(child[key], parent[key], false)
        }
    }
    return child
}

/**
 *  Update prefix for some special directives
 *  that are used in compilation.
 *  更新编译中使用的某些特殊指令的前缀。
 */
var specialAttributes = [
    'id',
    'pre',
    'text',
    'repeat',
    'partial',
    'component',
    'transition'
]

function updatePrefix () {
    specialAttributes.forEach(setPrefix)
}

function setPrefix (attr) {
    config.attrs[attr] = config.prefix + '-' + attr
}

updatePrefix()
module.exports = ViewModel

var ViewModel = {};

ViewModel.config = function (opts) {
    if (opts) {
        utils.extend(config, opts)
        if (opts.prefix) updatePrefix()
    }
    return this
}

ViewModel.directive = function (id, fn) {
    if (!fn) return directives[id]
    directives[id] = fn
    return this
}

ViewModel.filter = function (id, fn) {
    if (!fn) return filters[id]
    filters[id] = fn
    return this
}

ViewModel.component = function (id, Ctor) {
    if (!Ctor) return utils.components[id]
    utils.components[id] = utils.toConstructor(Ctor)
    return this
}

ViewModel.element = function (id, Ctor) {
    if (!Ctor) return utils.elements[id]
    utils.elements[id] = utils.toConstructor(Ctor)
    return this
}

ViewModel.transition = function (id, transition) {
    if (!transition) return utils.transitions[id]
    utils.transitions[id] = transition
    return this
}

ViewModel.extend = extend;

function extend (options) {

    var ParentVM = this

    // inherit options
    // 继承选项
    options = inheritOptions(options, ParentVM.options, true)
    utils.processOptions(options)

    var ExtendedVM = function (opts) {
        opts = inheritOptions(opts, options, true)
        ParentVM.call(this, opts)
    }

    // inherit prototype props
    // 继承原型props属性
    var proto = ExtendedVM.prototype = Object.create(ParentVM.prototype)
    utils.defProtected(proto, 'constructor', ExtendedVM)

    // copy prototype props
    // 复制原型props属性
    var protoMixins = options.proto
    if (protoMixins) {
        for (var key in protoMixins) {
            if (!(key in ViewModel.prototype)) {
                proto[key] = protoMixins[key]
            }
        }
    }

    // allow extended VM to be further extended
    // 允许扩展VM进一步扩展
    ExtendedVM.extend = extend
    ExtendedVM.super = ParentVM
    ExtendedVM.options = options
    return ExtendedVM
}

console.log("ViewModel对象这些属性的数据类型：");
console.log("config属性的数据类型：" + (typeof ViewModel.config));
console.log("directive属性的数据类型：" + (typeof ViewModel.directive));
console.log("filter属性的数据类型：" + (typeof ViewModel.filter));
console.log("component属性的数据类型：" + (typeof ViewModel.component));
console.log("element属性的数据类型：" + (typeof ViewModel.element));
console.log("transition属性的数据类型：" + (typeof ViewModel.transition));
console.log("extend属性的数据类型：" + (typeof ViewModel.extend));