/*
 * typeahead.js
 * https://github.com/twitter/typeahead.js
 * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
 */

var Transport = (function() {
  'use strict';

  var pendingRequestsCount = 0,
    pendingRequests = {},
    maxPendingRequests = 6,
    sharedCache = new LruCache(10);

  // constructor
  // -----------

  function Transport(o) {
    o = o || {};

    this.cancelled = false;
    this.lastUrl = null;

    this._send = o.transport ? callbackToDeferred(o.transport) : $.ajax;
    this._get = o.rateLimiter ? o.rateLimiter(this._get) : this._get;

    // eh, should this even exist? relying on the browser's cache may be enough
    this._cache = o.cache === false ? new LruCache(0) : sharedCache;
  }

  // static methods
  // --------------

  Transport.setMaxPendingRequests = function setMaxPendingRequests(num) {
    maxPendingRequests = num;
  };

  Transport.resetCache = function resetCache() {
    sharedCache.reset();
  };

  // instance methods
  // ----------------

  _.mixin(Transport.prototype, {
    // ### private

    _get: function(url, o, cb) {
      var that = this,
        jqXhr;

      // #149: don't make a network request if there has been a cancellation
      // or if the url doesn't match the last url Transport#get was invoked with
      if (this.cancelled || url !== this.lastUrl) {
        return;
      }

      // a request is already in progress, piggyback off of it
      if ((jqXhr = pendingRequests[url])) {
        jqXhr.done(done).fail(fail);
      } else if (pendingRequestsCount < maxPendingRequests) {
        // under the pending request threshold, so fire off a request
        pendingRequestsCount++;
        pendingRequests[url] = this._send(url, o)
          .done(done)
          .fail(fail)
          .always(always);
      } else {
        // at the pending request threshold, so hang out in the on deck circle
        this.onDeckRequestArgs = [].slice.call(arguments, 0);
      }

      function done(resp) {
        cb && cb(null, resp);
        that._cache.set(url, resp);
      }

      function fail() {
        cb && cb(true);
      }

      function always() {
        pendingRequestsCount--;
        delete pendingRequests[url];

        // ensures request is always made for the last query
        if (that.onDeckRequestArgs) {
          that._get.apply(that, that.onDeckRequestArgs);
          that.onDeckRequestArgs = null;
        }
      }
    },

    // ### public

    get: function(url, o, cb) {
      var resp;

      if (_.isFunction(o)) {
        cb = o;
        o = {};
      }

      this.cancelled = false;
      this.lastUrl = url;

      // in-memory cache hit
      if ((resp = this._cache.get(url))) {
        // defer to stay consistent with behavior of ajax call
        _.defer(function() {
          cb && cb(null, resp);
        });
      } else {
        this._get(url, o, cb);
      }

      // return bool indicating whether or not a cache hit occurred
      return !!resp;
    },

    cancel: function() {
      this.cancelled = true;
    },
  });

  return Transport;

  // helper functions
  // ----------------

  function callbackToDeferred(fn) {
    return function customSendWrapper(url, o) {
      var deferred = $.Deferred();

      fn(url, o, onSuccess, onError);

      return deferred;

      function onSuccess(resp) {
        // defer in case fn is synchronous, otherwise done
        // and always handlers will be attached after the resolution
        _.defer(function() {
          deferred.resolve(resp);
        });
      }

      function onError(err) {
        // defer in case fn is synchronous, otherwise done
        // and always handlers will be attached after the resolution
        _.defer(function() {
          deferred.reject(err);
        });
      }
    };
  }
})();
