/**

 * @裁剪版backbone，仅包含Events、Model模块，适用于轻量级的移动终端APP

 * window.Minibone

 */

(function(){

  var root = this;

  var array = [];

  var push = array.push;

  var slice = array.slice;

  var splice = array.splice;

  var ArrayProto = Array.prototype;

  var nativeIsArray = Array.isArray;

  var nativeForEach = ArrayProto.forEach;

  var ObjProto = Object.prototype;

  var toString = ObjProto.toString;

  var hasOwnProperty   = ObjProto.hasOwnProperty;

  var Minibone = root.Minibone = {};

  var _ = root._ = {};

  var breaker = {};

  _.clone = function(obj) {

    if (!_.isObject(obj)) return obj;

    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);

  };

  // Fill in a given object with default properties.

  _.defaults = function(obj) {

    _.each(slice.call(arguments, 1), function(source) {

      for (var prop in source) {

        if (obj[prop] == null) obj[prop] = source[prop];

      }

    });

    return obj;

  };

  _.isArray = nativeIsArray || function(obj) {

    return toString.call(obj) == '[object Array]';

  };

  // Internal recursive comparison function.

  function eq(a, b, stack) {

   if(typeof a === 'object' || typeof b === 'object'){

   throw new Error('Function eq only support basic data types:number,string,boolean');

   }

    var className = toString.call(a);

    if (className != toString.call(b)) return false;

    switch (className) {

      case '[object String]':

        return a == String(b);

      case '[object Number]':

        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);

      case '[object Boolean]':

        return +a == +b;

    }

    return true;

  }

  // only support basic data types:number,string,boolean

  _.isEqual = function(a, b) {

    return eq(a, b, []);

  };

  _.isEmpty = function(obj) {

    if (obj == null) return true;

    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;

    for (var key in obj) if (_.has(obj, key)) return false;

    return true;

  };

  _.isObject = function(obj) {

    return obj === Object(obj);

  };

  _.isFunction = function(obj) {

    return toString.call(obj) == '[object Function]';

  };

  _.isString = function(obj) {

    return toString.call(obj) == '[object String]';

  };

  _.result = function(object, property) {

    if (object == null) return null;

    var value = object[property];

    return _.isFunction(value) ? value.call(object) : value;

  };

  _.has = function(obj, key) {

    return hasOwnProperty.call(obj, key);

  };

  // The cornerstone, an `each` implementation, aka `forEach`.

  // Handles objects with the built-in `forEach`, arrays, and raw objects.

  // Delegates to **ECMAScript 5**'s native `forEach` if available.

  _.each = _.forEach = function(obj, iterator, context) {

    if (obj == null) return;

    if (nativeForEach && obj.forEach === nativeForEach) {

      obj.forEach(iterator, context);

    } else if (obj.length === +obj.length) {

      for (var i = 0, l = obj.length; i < l; i++) {

        if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;

      }

    } else {

      for (var key in obj) {

        if (_.has(obj, key)) {

          if (iterator.call(context, obj[key], key, obj) === breaker) return;

        }

      }

    }

  };

  _.extend = function(obj) {

    _.each(slice.call(arguments, 1), function(source) {

      for (var prop in source) {

        obj[prop] = source[prop];

      }

    });

    return obj;

  };

  var idCounter = 0;

  _.uniqueId = function(prefix) {

    var id = idCounter++;

    return prefix ? prefix + id : id;

  };

  // Minibone.Events

  var triggerEvents = function(obj, events, args) {

    var ev, i = -1, l = events.length;

    switch (args.length) {

    case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx);

    return;

    case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0]);

    return;

    case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1]);

    return;

    case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1], args[2]);

    return;

    default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);

    }

  };

  var Events = Minibone.Events = {

    on: function(name, callback, context) {

      this._events || (this._events = {});

      var list = this._events[name] || (this._events[name] = []);

      list.push({callback: callback, context: context, ctx: context || this});

      return this;

    },

    off: function(name, callback, context) {

      var list, ev, events, names, i, l, j, k;

      if (!this._events) return this;

      if (!name && !callback && !context) {

        this._events = {};

        return this;

      }

      names = name ? [name] : _.keys(this._events);

      for (i = 0, l = names.length; i < l; i++) {

        name = names[i];

        if (list = this._events[name]) {

          events = [];

          if (callback || context) {

            for (j = 0, k = list.length; j < k; j++) {

              ev = list[j];

              if ((callback && callback !== (ev.callback._callback || ev.callback)) ||

                  (context && context !== ev.context)) {

                events.push(ev);

              }

            }

          }

          this._events[name] = events;

        }

      }

      return this;

    },

    trigger: function(name) {

      if (!this._events) return this;

      var args = slice.call(arguments, 1);

      var events = this._events[name];

      var allEvents = this._events.all;

      if (events) triggerEvents(this, events, args);

      if (allEvents) triggerEvents(this, allEvents, arguments);

      return this;

    }

  };

  _.extend(Minibone, Events);

  // Minibone.Model

  var Model = Minibone.Model = function(attributes, options) {

    var defaults;

    var attrs = attributes || {};

    this.cid = _.uniqueId('c');

    this.changed = {};

    this.attributes = {};

    this._changes = [];

    if (options && options.collection) this.collection = options.collection;

    if (options && options.parse) attrs = this.parse(attrs);

    if (defaults = _.result(this, 'defaults')) _.defaults(attrs, defaults);

    this.set(attrs, {silent: true});

    this._currentAttributes = _.clone(this.attributes);

    this._previousAttributes = _.clone(this.attributes);

    this.initialize.apply(this, arguments);

  };

  _.extend(Model.prototype, Events, {

    changed: null,

    idAttribute: 'id',

    initialize: function(){},

    get: function(attr) {

      return this.attributes[attr];

    },

    // Set a hash of model attributes on the object, firing `"change"`. This is

    // the core primitive operation of a model, updating the data and notifying

    // anyone who needs to know about the change in state. The heart of the beast.

    set: function(key, val, options) {

      var attr, attrs, unset, changes, silent, changing, prev, current;

      if (key == null) return this;

      // Handle both `"key", value` and `{key: value}` -style arguments.

      if (typeof key === 'object') {

        attrs = key;

        options = val;

      } else {

        (attrs = {})[key] = val;

      }

      options || (options = {});

      if (!this._validate(attrs, options)) return false;

      unset           = options.unset;

      silent          = options.silent;

      changes         = [];

      changing        = this._changing;

      this._changing  = true;

      if (!changing) {

        this._previousAttributes = _.clone(this.attributes);

        this.changed = {};

      }

      current = this.attributes, prev = this._previousAttributes;

      // Check for changes of `id`.

      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];

      // For each `set` attribute, update or delete the current value.

      for (attr in attrs) {

        val = attrs[attr];

        if (!_.isEqual(current[attr], val)) changes.push(attr);

        if (!_.isEqual(prev[attr], val)) {

          this.changed[attr] = val;

        } else {

          delete this.changed[attr];

        }

        unset ? delete current[attr] : current[attr] = val;

      }

      // Trigger all relevant attribute changes.

      if (!silent) {

        if (changes.length) this._pending = true;

        for (var i = 0, l = changes.length; i < l; i++) {

          this.trigger('change:' + changes[i], this, current[changes[i]], options);

        }

      }

      if (changing) return this;

      if (!silent) {

        while (this._pending) {

          this._pending = false;

          this.trigger('change', this, options);

        }

      }

      this._pending = false;

      this._changing = false;

      return this;

    },

    _validate: function(attrs, options) {

      if (!options.validate || !this.validate) return true;

      attrs = _.extend({}, this.attributes, attrs);

      var error = this.validationError = this.validate(attrs, options) || null;

      if (!error) return true;

      this.trigger('invalid', this, error, _.extend(options || {}, {validationError: error}));

      return false;

    }

  });

  // Helpers

  var extend = function(protoProps, staticProps) {

    var parent = this;

    var child;

    if (protoProps && _.has(protoProps, 'constructor')) {

      child = protoProps.constructor;

    } else {

      child = function(){ parent.apply(this, arguments); };

    }

    _.extend(child, parent, staticProps);

    var Surrogate = function(){ this.constructor = child; };

    Surrogate.prototype = parent.prototype;

    child.prototype = new Surrogate;

    if (protoProps) _.extend(child.prototype, protoProps);

    child.__super__ = parent.prototype;

    return child;

  };

  Model.extend = extend;

}).call(this);