// instance/state.js
function initData (vm: Component) {
  let data = vm.$options.data

  /** 将 data 挂载到 实例的 _data 上 */
  data = vm._data = typeof data === 'function'
    ? getData(data, vm) // 将函数调用一下, 获得函数的返回值；局部作用域 
    : data || {}
    ...
  // proxy data on instance  将data代理到_data
  const keys = Object.keys(data)

  const props = vm.$options.props
  const methods = vm.$options.methods
  let i = keys.length
  while (i--) {
    const key = keys[i]

    /** 这里判断只是为了避免 props, data, method 等数据发生冲突, 同名的问题 */
    if (process.env.NODE_ENV !== 'production') {
      if (methods && hasOwn(methods, key)) {
        warn(
          `Method "${key}" has already been defined as a data property.`,
          vm
        )
      }
    }
    if (props && hasOwn(props, key)) {
      process.env.NODE_ENV !== 'production' && warn(
        `The data property "${key}" is already declared as a prop. ` +
        `Use prop default value instead.`,
        vm
      )
    } else if (!isReserved(key)) {

      proxy(vm, `_data`, key) // 循环了 data 的所有属性, 映射到 Vue 实例上, 
                              // 就必须要使用 app._data.xxx 来访问
                              // 而是使用 app.xxx 来方法
    }
  }
  
  // observe data
  observe(data, true /* asRootData */) // 响应式化 响应式入口
}

    /**
 * Attempt to create an observer instance for a value,
 * returns the new observer if successfully observed,
 * or the existing observer if the value already has one.
 * 
 * 就是将传入的数据 value 变成响应式的对象
 * 
 * 算法描述:
 * 
 * - 先看 对象是否含有 __ob__, 并且是 Observer 的实例 ( Vue 中响应式对象的 标记 )
 * - 有, 忽略
 * - 没有, 调用 new Observer( value ), 进行响应式化
 */
export function observe (value: any, asRootData: ?boolean): Observer | void {

  if (!isObject(value) || value instanceof VNode) {
    return // 如果不满足响应式的条件就跳出
  }

  let ob: Observer | void
  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
    ob = value.__ob__
  } else if (
    shouldObserve &&
    !isServerRendering() &&
    (Array.isArray(value) || isPlainObject(value)) &&
    Object.isExtensible(value) &&
    !value._isVue
  ) {
    ob = new Observer(value)
  }
  if (asRootData && ob) {
    ob.vmCount++
  }
  return ob
}

class Observer {
  value: any; // 循环引用: 对象.__ob__ , ob.value
  dep: Dep;
  vmCount: number; // number of vms that have this object as root $data

  constructor (value: any) {
    this.value = value
    this.dep = new Dep() 
    this.vmCount = 0
    def(value, '__ob__', this) // 逻辑上等价于 value.__ob__ = this

    // 响应式化的逻辑
    if (Array.isArray(value)) {

      // 重点: 如何进行浏览器的能力检查
      if (hasProto) { // 判断浏览器是否兼容 __prop__ 
        protoAugment(value, arrayMethods)
      } else {
        copyAugment(value, arrayMethods, arrayKeys)
      }
      this.observeArray(value) // 遍历数组的元素, 进行递归 observe
    } else {
      this.walk(value)  // 遍历对象的属性, 递归 observe
    }
  }

 // 对对象进行递归observe
  walk (obj: Object) {
    const keys = Object.keys(obj)
    for (let i = 0; i < keys.length; i++) {
      defineReactive(obj, keys[i])
    }
  }

  /**
   * Observe a list of Array items.
   */
  observeArray (items: Array<any>) {
    for (let i = 0, l = items.length; i < l; i++) {
      observe(items[i])
    }
  }
}
/**
 * Augment a target Object or Array by intercepting
 * the prototype chain using __proto__
 * 
 * 浏览器支持 __proto__
 */
function protoAugment (target, src: Object) {
  /* eslint-disable no-proto */
  target.__proto__ = src // 完成数组的原型链修改, 从而使得数组变成响应式的 ( pop, push, shift, unshift, ... )
  /* eslint-enable no-proto */
}

/**
 * Augment a target Object or Array by defining
 * hidden properties.
 */
/* istanbul ignore next */
/** 如果浏览器不支持就将这些方法直接混入到当前数组中, 属性访问元素 */
function copyAugment (target: Object, src: Object, keys: Array<string>) {
  for (let i = 0, l = keys.length; i < l; i++) {
    const key = keys[i]
    def(target, key, src[key])
  }
}

/**
 * Define a reactive property on an Object.
 */
function defineReactive (
  obj: Object,
  key: string,
  val: any,
  customSetter?: ?Function,
  shallow?: boolean
) {
  const dep = new Dep()

  // 获得对象的 属性描述, 就是定义 Object.defineProperty 需要传入 对象 ( { enumerable, writable, ... } )
  const property = Object.getOwnPropertyDescriptor(obj, key)
  if (property && property.configurable === false) {
    return
  }

  // cater for pre-defined getter/setters 保存之前的getter 和setter 以获取之前的val
  const getter = property && property.get
  const setter = property && property.set
  if ((!getter || setter) && arguments.length === 2) {
    val = obj[key]
  }

  let childOb = !shallow && observe(val) // 对其属性值也进行响应式

  Object.defineProperty(obj, key, {
    enumerable: true,
    configurable: true,
    get: function reactiveGetter () {
      const value = getter ? getter.call(obj) : val // 保证了如果已经定义的 get 方法可以被继承下来, 不会丢失

      if (Dep.target) {
        dep.depend() // 关联的当前属性

        /** 收集子属性 */
        if (childOb) {
        // 在数组/对象中 如果是对属性的新增或者删除；则监听不到对象的setter方法；所以就需要在数组/对象上挂在__ob__属性，在__ob__上挂载dep实例，用来处理改变内容的情况，以便能够形成追踪链路；这样可为Vue.set 提供手动调用dep.notify()进行派发更新；
          childOb.dep.depend()
          if (Array.isArray(value)) {
            dependArray(value)
          }
        }

      }

      return value
    },
    set: function reactiveSetter (newVal) {
      const value = getter ? getter.call(obj) : val  
      
      
      /* eslint-disable no-self-compare */
      
      // 如果数据没有发生变化 就不会进行派发更新
      if (newVal === value || (newVal !== newVal && value !== value)) {
        return
      }
      
      // #7981: for accessor properties without setter
      if (getter && !setter) return

      if (setter) {
        setter.call(obj, newVal) // 保证了如果已经定义的 set 方法可以被继承下来, 不会丢失
      } else {
        val = newVal
      }
      childOb = !shallow && observe(newVal) // 对新值进行响应式化
      dep.notify() // 派发更新
    }
  })
}

class Dep {
  static target: ?Watcher;
  id: number;
  subs: Array<Watcher>;
  constructor () {
    this.id = uid++
    this.subs = []
  }
  // 给这个依赖添加对应的watcher
  addSub (sub: Watcher) {
    this.subs.push(sub)
  }
  // 移除这个依赖收集项
  removeSub (sub: Watcher) {
    remove(this.subs, sub)
  }
  // 将watcher与dep 相互关联
  depend () {
    if (Dep.target) {
      Dep.target.addDep(this)
    }
  }
  /** 
   * 每一个属性 都会包含一个 dep 实例
   * 这个 dep 实例会记录下 参与计算或渲染的 watcher
   */
  notify () {
    // stabilize the subscriber list first
    const subs = this.subs.slice()
    
    for (let i = 0, l = subs.length; i < l; i++) {
      subs[i].update()
    }
  }
}
Dep.target = null; // 全局变量，标记当前的watcher

class Watcher {
  vm: Component;
  expression: string; // 关联表达式 或 渲染方法体
  cb: Function; // 在定义 Vue 构造函数的时候, 传入的 watch 
  id: number;
  deep: boolean;
  user: boolean;
  lazy: boolean; // 计算属性, 和 watch 来控制不要让 Watcher 立即执行
  sync: boolean;
  dirty: boolean;
  active: boolean;
                        // 在 Vue 中使用了 二次提交的概念
                        // 每次在数据 渲染 或 计算的时候 就会访问响应式的数据, 就会进行依赖收集
                        // 就将关联的 Watcher 与 dep 相关联,
                        // 在数据发生变化的时候, 根据 dep 找到关联的 watcher, 依次调用 update
                        // 执行完成后会清空 watcher
  deps: Array<Dep>;
  depIds: SimpleSet;
  
  newDeps: Array<Dep>;
  newDepIds: SimpleSet;
  
  before: ?Function; // Watcher 触发之前的, 类似于 生命周期


  getter: Function; // 就是 渲染函数 ( 模板或组件的渲染 ) 或 计算函数 ( watch )
  
  value: any; // 如果是渲染函数, value 无效; 如果是计算属性, 就会有一个值, 值就存储在 value 中

  constructor (
    vm: Component,
    expOrFn: string | Function,
    cb: Function,
    options?: ?Object,
    isRenderWatcher?: boolean
  ) {
    this.vm = vm
    if (isRenderWatcher) {
      vm._watcher = this
    }
    vm._watchers.push(this)

    // options
    if (options) {
      this.deep = !!options.deep
      this.user = !!options.user
      this.lazy = !!options.lazy
      this.sync = !!options.sync
      this.before = options.before
    } else {
      this.deep = this.user = this.lazy = this.sync = false
    }
    this.cb = cb
    this.id = ++uid // uid for batching
    this.active = true
    this.dirty = this.lazy // for lazy watchers
    this.deps = []
    this.newDeps = []
    this.depIds = new Set()
    this.newDepIds = new Set()

    this.expression = process.env.NODE_ENV !== 'production'
      ? expOrFn.toString()
      : ''

    
    // parse expression for getter
    if (typeof expOrFn === 'function') { // 就是 render 函数
      this.getter = expOrFn
    } else {
      this.getter = parsePath(expOrFn)
      if (!this.getter) {
        this.getter = noop
        process.env.NODE_ENV !== 'production' && warn(
          `Failed watching path: "${expOrFn}" ` +
          'Watcher only accepts simple dot-delimited paths. ' +
          'For full control, use a function instead.',
          vm
        )
      }
    }


    // 如果是 lazy 就什么也不做, 否则就立即调用 getter 函数求值 ( expOrFn )
    this.value = this.lazy
      ? undefined
      : this.get()
  }

  /**
   * Evaluate the getter, and re-collect dependencies.
   */
  get () {
    pushTarget(this)
    let value
    const vm = this.vm
    try {
      value = this.getter.call(vm, vm)
    } catch (e) {
      if (this.user) {
        handleError(e, vm, `getter for watcher "${this.expression}"`)
      } else {
        throw e
      }
    } finally {
      // "touch" every property so they are all tracked as
      // dependencies for deep watching
      if (this.deep) {
        traverse(value)
      }
      popTarget()
      this.cleanupDeps() // "清空" 关联的 dep 数据
    }
    return value
  }

  /**
   * Add a dependency to this directive.
   */
  addDep (dep: Dep) {
    const id = dep.id
    if (!this.newDepIds.has(id)) {
      
      this.newDepIds.add(id)
      this.newDeps.push(dep) // 让 watcher 关联到 dep

      if (!this.depIds.has(id)) {
        dep.addSub(this) // 让 dep 关联到 watcher
      }
    }
  }

  /**
   * Clean up for dependency collection.
   *那么为什么需要做 deps 订阅的移除呢，在添加 deps 的订阅过程，已经能通过 id 去重避免重复订阅了。
考虑到一种场景，我们的模板会根据 v-if 去渲染不同子模板 a 和 b，当我们满足某种条件的时候渲染 a 的时候，会访问到 a 中的数据，这时候我们对 a 使用的数据添加了 getter，做了依赖收集，那么当我们去修改 a 的数据的时候，理应通知到这些订阅者。那么如果我们一旦改变了条件渲染了 b 模板，又会对 b 使用的数据添加了 getter，如果我们没有依赖移除的过程，那么这时候我去修改 a 模板的数据，会通知 a 数据的订阅的回调，这显然是有浪费的。
   *
   */
  cleanupDeps () {
    let i = this.deps.length
    while (i--) {
      const dep = this.deps[i]
      if (!this.newDepIds.has(dep.id)) { // 在 二次提交中 归档就是 让 旧的 deps 和 新 的 newDeps 一致
        dep.removeSub(this)
      }
    }
    let tmp = this.depIds
    this.depIds = this.newDepIds
    this.newDepIds = tmp
    this.newDepIds.clear()
    tmp = this.deps
    this.deps = this.newDeps // 同步
    this.newDeps = tmp
    this.newDeps.length = 0
  }

  /**
   * Subscriber interface.
   * Will be called when a dependency changes.
   */
  update () {
    /* istanbul ignore else */
    if (this.lazy) {            // 主要针对计算属性, 一般用于求值计算
      this.dirty = true
    } else if (this.sync) {     // 同步, 主要用于 SSR, 同步就表示立即计算 
      this.run()
    } else {
      queueWatcher(this)        // 一般浏览器中的异步运行, 本质上就是异步执行 run
                                // 类比: setTimeout( () => this.run(), 0 )
    }
  }

  /**
   * Scheduler job interface.
   * Will be called by the scheduler.
   * 
   * 调用 get 求值或渲染, 如果求值, 新旧值不同, 触发 cb
   */
  run () {
    if (this.active) {
      const value = this.get() // 要么渲染, 要么求值
      if (
        value !== this.value ||
        // Deep watchers and watchers on Object/Arrays should fire even
        // when the value is the same, because the value may
        // have mutated.
        isObject(value) ||
        this.deep
      ) {
        // set new value
        const oldValue = this.value
        this.value = value
        if (this.user) {
          try {
            this.cb.call(this.vm, value, oldValue)
          } catch (e) {
            handleError(e, this.vm, `callback for watcher "${this.expression}"`)
          }
        } else {
          this.cb.call(this.vm, value, oldValue)
        }
      }
    }
  }

  /**
   * Evaluate the value of the watcher.
   * This only gets called for lazy watchers.
   */
  evaluate () {
    this.value = this.get()
    this.dirty = false
  }

  /**
   * Depend on all deps collected by this watcher.
   */
  depend () {
    let i = this.deps.length
    while (i--) {
      this.deps[i].depend()
    }
  }

  /**
   * Remove self from all dependencies' subscriber list.
   */
  teardown () {
    if (this.active) {
      // remove self from vm's watcher list
      // this is a somewhat expensive operation so we skip it
      // if the vm is being destroyed.
      if (!this.vm._isBeingDestroyed) {
        remove(this.vm._watchers, this)
      }
      let i = this.deps.length
      while (i--) {
        this.deps[i].removeSub(this)
      }
      this.active = false
    }
  }
}