var util = require("./core/utils/data_structure_util");

var env = require("./core/env");

var Group = require("./graphic/Group");

var timsort = require("./core/utils/timsort");

// Use timsort because in most case elements are partially sorted
// https://jsfiddle.net/pissang/jr4x7mdm/8/

/**
 * @class qrenderer.core.Storage
 * 内容仓库 (M)，用来存储和管理画布上的所有对象，同时提供绘制和更新队列的功能。
 * 需要绘制的对象首先存储在 Storage 中，然后 Painter 类会从 Storage 中依次取出进行绘图。
 * 利用 Storage 作为内存中转站，对于不需要刷新的对象可以不进行绘制，从而可以提升整体性能。
 * @docauthor 大漠穷秋 damoqiongqiu@126.com
 */

/**
 * @method constructor Storage
 */
var Storage = function Storage() {
  // jshint ignore:line

  /**
   * @private
   * @property _roots
   */
  this._roots = []; //直接放在画布上的对象为根对象

  /**
   * @private
   * @property _displayList
   */

  this._displayList = [];
  /**
   * @private
   * @property _displayListLen
   */

  this._displayListLen = 0;
};

Storage.prototype = {
  constructor: Storage,

  /**
   * @method traverse
   * @param  {Function} cb
   * @param  {Object} context
   */
  traverse: function traverse(cb, context) {
    for (var i = 0; i < this._roots.length; i++) {
      this._roots[i].traverse(cb, context);
    }
  },

  /**
   * @method getDisplayList
   * 返回所有图形的绘制队列
   * @param {boolean} [update=false] 是否在返回前更新该数组
   * @param {boolean} [includeIgnore=false] 是否包含 ignore 的数组, 在 update 为 true 的时候有效
   *
   * 详见{@link Displayable.prototype.updateDisplayList}
   * @return {Array<Displayable>}
   */
  getDisplayList: function getDisplayList(update, includeIgnore) {
    includeIgnore = includeIgnore || false;

    if (update) {
      this.updateDisplayList(includeIgnore);
    }

    return this._displayList;
  },

  /**
   * @method updateDisplayList
   * 更新图形的绘制队列。
   * 每次绘制前都会调用，该方法会先深度优先遍历整个树，更新所有Group和Shape的变换并且把所有可见的Shape保存到数组中，
   * 最后根据绘制的优先级（zlevel > z > 插入顺序）排序得到绘制队列
   * @param {boolean} [includeIgnore=false] 是否包含 ignore 的数组
   */
  updateDisplayList: function updateDisplayList(includeIgnore) {
    this._displayListLen = 0;
    var roots = this._roots;
    var displayList = this._displayList;

    for (var i = 0, len = roots.length; i < len; i++) {
      this._updateAndAddDisplayable(roots[i], null, includeIgnore);
    }

    displayList.length = this._displayListLen;
    env.canvasSupported && timsort(displayList, this.displayableSortFunc);
  },

  /**
   * @method _updateAndAddDisplayable
   * @param {*} el 
   * @param {*} clipPaths 
   * @param {*} includeIgnore 
   */
  _updateAndAddDisplayable: function _updateAndAddDisplayable(el, clipPaths, includeIgnore) {
    if (el.ignore && !includeIgnore) {
      return;
    }

    el.beforeUpdate();

    if (el.__dirty) {
      el.update();
    }

    el.afterUpdate();
    var userSetClipPath = el.clipPath;

    if (userSetClipPath) {
      // FIXME 效率影响
      if (clipPaths) {
        clipPaths = clipPaths.slice();
      } else {
        clipPaths = [];
      }

      var currentClipPath = userSetClipPath;
      var parentClipPath = el; // Recursively add clip path

      while (currentClipPath) {
        // clipPath 的变换是基于使用这个 clipPath 的元素
        currentClipPath.parent = parentClipPath;
        currentClipPath.updateTransform();
        clipPaths.push(currentClipPath);
        parentClipPath = currentClipPath;
        currentClipPath = currentClipPath.clipPath;
      }
    }

    if (el.isGroup) {
      var children = el._children;

      for (var i = 0; i < children.length; i++) {
        var child = children[i]; // Force to mark as dirty if group is dirty
        // FIXME __dirtyPath ?

        if (el.__dirty) {
          child.__dirty = true;
        }

        this._updateAndAddDisplayable(child, clipPaths, includeIgnore);
      } // Mark group clean here


      el.__dirty = false;
    } else {
      el.__clipPaths = clipPaths;
      this._displayList[this._displayListLen++] = el;
    }
  },

  /**
   * @method addRoot
   * 添加图形(Shape)或者组(Group)到根节点
   * @param {Element} el
   */
  addRoot: function addRoot(el) {
    if (el.__storage === this) {
      return;
    }

    if (el instanceof Group) {
      el.addChildrenToStorage(this);
    }

    this.addToStorage(el);

    this._roots.push(el);
  },

  /**
   * @method
   * 删除指定的图形(Shape)或者组(Group)
   * @param {string|Array.<String>} [el] 如果为空清空整个Storage
   */
  delRoot: function delRoot(el) {
    if (el == null) {
      // 不指定el清空
      for (var i = 0; i < this._roots.length; i++) {
        var root = this._roots[i];

        if (root instanceof Group) {
          root.delChildrenFromStorage(this);
        }
      }

      this._roots = [];
      this._displayList = [];
      this._displayListLen = 0;
      return;
    }

    if (el instanceof Array) {
      for (var _i = 0, l = el.length; _i < l; _i++) {
        this.delRoot(el[_i]);
      }

      return;
    }

    var idx = util.indexOf(this._roots, el);

    if (idx >= 0) {
      this.delFromStorage(el);

      this._roots.splice(idx, 1);

      if (el instanceof Group) {
        el.delChildrenFromStorage(this);
      }
    }
  },

  /**
   * @method addToStorage
   * @param {Element} el 
   */
  addToStorage: function addToStorage(el) {
    if (el) {
      el.__storage = this;
      el.dirty(false);
    }

    return this;
  },

  /**
   * @method delFromStorage
   * @param {Element} el 
   */
  delFromStorage: function delFromStorage(el) {
    if (el) {
      el.__storage = null;
    }

    return this;
  },

  /**
   * @method dispose
   * 清空并且释放Storage
   */
  dispose: function dispose() {
    this._renderList = this._roots = null;
  },
  displayableSortFunc: function displayableSortFunc(a, b) {
    if (a.qlevel === b.qlevel) {
      if (a.z === b.z) {
        // if (a.z2 === b.z2) {
        //     // FIXME Slow has renderidx compare
        //     // http://stackoverflow.com/questions/20883421/sorting-in-javascript-should-every-compare-function-have-a-return-0-statement
        //     // https://github.com/v8/v8/blob/47cce544a31ed5577ffe2963f67acb4144ee0232/src/js/array.js#L1012
        //     return a.__renderidx - b.__renderidx;
        // }
        return a.z2 - b.z2;
      }

      return a.z - b.z;
    }

    return a.qlevel - b.qlevel;
  }
};
var _default = Storage;
module.exports = _default;