'use strict';
  
  

  
  var Backbone = (window && window.Backbone) || require('backbone');
  var _ = (window && window._) || require('underscore');
  var querystring = require('qs');
  var diff = require('deep-diff');
  
  
  

  
  var QueryHistory = Backbone.History.extend( /** @lends QueryHistory# **/{
  
  
  

  
    constructor: function() {
      this.previousQuery = {};
      this.queryHandlers = [];
      this.listenTo(this.query, 'change', this.onQueryModelChange);
      Backbone.History.call(this);
    },
  
  
  

  
    queryMatcher: /^([^?]*?)(?:\?([\s\S]*))?$/,
  
  
  

  
    query: Backbone.NestedModel ? new Backbone.NestedModel() : new Backbone.Model(),
  
  
  

  
    loadQuery: function(fragment, options) {
      var query = this._fragmentToQueryObject(fragment);
      var previous = this.previousQuery;
  
  
  

  
      this.previousQuery = query;
  
  
  

  
      var diffs = this._getDiffs(previous, query);
      if (!diffs.length) return;
  
  
  

  
      this.stopListening(this.query, 'change', this.onQueryModelChange);
      this.resetQuery(query);
      this.listenTo(this.query, 'change', this.onQueryModelChange);
  
  
  

  
      _.each(this.queryHandlers, function(handler) {
        var intersections = _.intersection(diffs, handler.bindings);
        if (intersections.length) {
          handler.callback(fragment, intersections, _.pick(query, intersections));
        }
      });
    },
  
  
  

  
    loadUrl: function(fragment) {
      if (this._previousBaseFragment !== this._stripQuery(fragment)) {
        return Backbone.History.prototype.loadUrl.apply(this, arguments);
      }
      return false;
    },
  
  
  

  
    navigate: function(fragment, options) {
      if (!Backbone.History.started) return false;
      if (!options) options = {};
  
  
  

  
      this._previousBaseFragment = this._stripQuery(this.fragment);
  
  
  

  
      if (options.trigger) {
        this.loadQuery(fragment, options);
      }
  
  
  

  
      Backbone.History.prototype.navigate.call(this, fragment, options);
    },
  
  
  

  
    navigateBase: function(fragment, options) {
      var currentQuery = this._fragmentToQueryString(Backbone.history.fragment);
      return this.navigate(this._stripQuery(fragment) + "?" + currentQuery, options);
    },
  
  
  

  
    onQueryModelChange: function(model, options) {
      var fragment = this.fragment || '';
      var oldQS = querystring.stringify(this.previousQuery);
      var newQS = querystring.stringify(model.toJSON());
  
  
  

  
      if (oldQS) {
        fragment = fragment.replace(oldQS, newQS);
      } else {
  
  

  
        if (fragment.slice(-1) !== '?') fragment += '?';
        fragment += newQS;
      }
      this.navigate(fragment, {trigger: true});
    },
  
  
  

  
    queryHandler: function(bindings, callback) {
      this.queryHandlers.push({bindings: bindings, callback: callback});
    },
  
  
  

  
    resetQuery: function(queryObject, options) {
      if (_.isString(queryObject)) {
        queryObject = this._fragmentToQueryObject(queryObject);
      }
      if (!options) options = {};
      var queryModel = this.query;
  
  
  

  
      queryModel._changing = true;
  
  
  

  
      if (options.unset !== false) {
        _.each(queryModel.attributes, function(attr, key){
          if (!queryObject[key]) queryModel.unset(key);
        });
      }
  
  
  

  
      if (options.set !== false) {
        _.each(queryObject, function(attr, key){
          queryModel.set(key, attr);
        });
      }
  
  
  

  
      queryModel._changing = false;
      if (!options.silent && !_.isEmpty(queryModel.changed)){
        queryModel.trigger('change', queryModel, options);
      }
    },
  
  
  

  
    _getDiffs: function(lhs, rhs) {
      var diffs = diff(lhs, rhs);
      var diffKeys = _.reduce(diffs, function(result, diff) {
        var paths = _.map(diff.path, function(path, i) {
          return _.first(diff.path, i + 1).join('.');
        });
        return result.concat(paths);
      }, []);
      return _.uniq(diffKeys);
    },
  
  
  

  
    _fragmentToQueryObject: function(fragment) {
      try {
        return querystring.parse(this._fragmentToQueryString(fragment));
      } catch(e) {
        throw new Error("Unable to parse fragment into query object: " + fragment);
      }
    },
  
  
  

  
    _fragmentToQueryString: function(fragment) {
      if (!fragment) return '';
      var match = fragment.match(this.queryMatcher);
      return match[2] || '';
    },
  
  
  

  
    _stripQuery: function(fragment) {
      return fragment ? fragment.split('?')[0] : '';
    }
  });
  
  var RouterProto = Backbone.Router.prototype;
  
  

  
  var QueryRouter = Backbone.Router.extend(/** @lends QueryRouter# */{
  
  

  
    _bindRoutes: function() {
      if (!this.queryRoutes) return;
      this.queryRoutes = _.result(this, 'queryRoutes');
      var qRoute, qRoutes = _.keys(this.queryRoutes);
      while ((qRoute = qRoutes.pop()) != null) {
        this.queryHandler(qRoute, this.queryRoutes[qRoute]);
      }
      RouterProto._bindRoutes.apply(this, arguments);
    },
  
  
  

  
    navigateBase: function(fragment, options) {
      Backbone.history.navigateBase(fragment, options);
      return this;
    },
  
  
  

  
    queryHandler: function(bindings, name, callback) {
      bindings = this._normalizeBindings(bindings);
      if (_.isFunction(name)) {
        callback = name;
        name = '';
      }
      if (!callback) callback = this[name];
      if (!callback) throw new Error("QueryHandler not found: " + this[name]);
      var router = this;
      Backbone.history.queryHandler(bindings, function(fragment, queryKeys, queryObj) {
        router.execute(callback, [queryKeys, queryObj]);
        router.trigger.apply(router, ['route:' + name].concat(queryKeys));
        router.trigger('route', name, queryKeys, queryObj);
        Backbone.history.trigger('route', router, name, queryKeys, queryObj);
      });
      return this;
    },
  
  
  

  
    _normalizeBindings: function(bindings) {
      if (_.isString(bindings)) {
        bindings = bindings.split(',');
      }
      return _.invoke(bindings, 'trim');
    }
  });
  
  
  

  
  Backbone.Router = QueryRouter;
  
  
  

  
  Backbone.history = new QueryHistory();