// event-emitter.js
// Позволяет создавать свои события типа:
// thisModel.emit('login.fail', obj)
// И отлавливаем:
// thisController.model.on('login.fail', function(error) {
//   *Выводим на экран ошибку*
// })
function EventEmitter() {
  this.__listeners = {};
}

function EventListener(fn, scope, once) {
  this.fn = fn;
  this.scope = scope;
  this.once = once;
}

EventEmitter.prototype = {
  /* Вызывает fn в контексте scope при возникновении события type. Если
   * once == true, то выполнится всего один раз.
   */
  on: function(type, fn, scope, once) {
    var index = this.__indexOf(type, fn);
    if (index != -1) {
      // Если обработчик уже задан, то обновляем scope и once для слушателя
      var listener = this.__listeners[type][index];
      listener.scope = scope;
      listener.once = once;
    } else {
      var listeners = this.__listeners[type] || (this.__listeners[type] = []);
      // Добавляем нового слушателя
      var listener = new EventListener(fn, scope, once);
      listeners.push(listener);
    }
    return this;
  },
  /* Вызывает fn в контексте scope при возникновении события type один раз. */
  once: function(type, fn, scope) {
    return this.on(type, fn, scope, true);
  },
  /* Удаляет всех слушателей, либо удаляет слушателей для события type, либо
   * удаляет слушателя с обработчиком fn для события type.
   */
  off: function(type, fn) {
    if (!arguments.length) {
      // .off() - удаляем всех слушателей
      this.__listeners = {};
    } else if (arguments.length == 1) {
      // .off(type) - удаляем слушателей для события type
      if (this.__listeners.hasOwnProperty(type)) {
        delete this.__listeners[type];
      }
    } else {
      // .off(type, fn) - удаляем слушателя для события type с обработчиком fn
      var index = this.__indexOf(type, fn);
      if (index != -1) {
        // Удаляем обработчик
        this.__listeners[type].splice(index, 1);
        if (!this.__listeners[type].length) {
          // Если массив слушателей пуст, то удаляем свойство с именем type
          delete this.__listeners[type];
        }
      }
    }
    return this;
  },
  /* Генерирует событие type и вызывает их обработчики. В функцию обработчик
   * передаются аргументы после type.
   */
  emit: function(type, args) {
    if (!this.__listeners.hasOwnProperty(type)) {
      return;
    }
    args = [].slice.call(arguments, 1);
    var i = 0;
    var listeners = this.__listeners[type];
    while (i < listeners.length) {
      var listener = listeners[i];
      listener.fn.apply(listener.scope || this, args);
      if (listener.once) {
        // Если обработчик должен выполниться лишь один раз, то удаляем
        // слушателя
        listeners.splice(i, 1);
      } else {
        ++i;
      }
    }
    if (!listeners.length) {
      // Если массив слушателей пуст, то удаляем свойство с именем type
      delete this.__listeners[type];
    }
  },
  __indexOf: function(type, fn) {
    if (this.__listeners.hasOwnProperty(type)) {
      var listeners = this.__listeners[type];
      var i = listeners.length;
      while (i--) {
        if (listeners[i].fn === fn) {
          return i;
        }
      }
    }
    return -1;
  }
};

EventEmitter.mixin = function(obj) {
  if (typeof obj == "function") {
    obj = obj.prototype;
  }
  var proto = new EventEmitter();
  for (var i in proto) {
    obj[i] = proto[i];
  }
  return obj;
};

var testEvents = {};
EventEmitter.mixin(testEvents);
// End event-emitter.js
// =============================================================================
// http.js
// Набор функций для работы с сетью
// .import "http.js" as http
function encodeQueryParameters(parameters) {
  var pairs = [];
  for (var i in parameters) {
    if (parameters.hasOwnProperty(i)) {
      var name = encodeURIComponent(i);
      var value = encodeURIComponent(parameters[i]);
      pairs.push(name + '=' + value);
    }
  }
  return pairs.join('&');
}

function parseQueryString(str) {
  var pairs = str.split("&");
  var ret = {};
  for (var i = 0; i < pairs.length; ++i) {
    var pair = pairs[i].split('=', 2);
    var name = decodeURIComponent(pair[0]);
    var value = pair.length == 2 ? decodeURIComponent(pair[1]) : '';
    ret[name] = value;
  }
  return ret;
}

function request(method, url, callback, headers, data) {
  var xhr = new XMLHttpRequest();
  xhr.open(method, url);
  xhr.onload = function() {
    if (typeof callback == "function") {
      try {
        xhr.responseJSON = JSON.parse(xhr.responseText);
      } catch (e) {}
      var data = xhr.responseJSON || xhr.responseText;
      callback(data, xhr.status, xhr);
    }
  };
  if ({}.toString.call(headers) == "[object Object]") {
    for (var i in headers) {
      if (headers.hasOwnProperty(i)) {
          xhr.setRequestHeader(i, headers[i]);
      }
    }
  }
  xhr.send(data);
}

function get(url, callback, parameters, headers) {
  if ({}.toString.call(parameters) == "[object Object]") {
    parameters = encodeQueryParameters(parameters);
    url += (url.indexOf('?') == -1 ? '?' : '&') + parameters;
  }
  request('GET', url, callback, headers);
}

function post(url, callback, data, headers) {
  if ({}.toString.call(data) == "[object Object]") {
    data = encodeQueryParameters(data);
    headers = headers || {};
    // Если content-type уже задан, то его значение будет выглядеть как:
    // <someshit>, application/x-www-form-urlencoded
    headers["Content-Type"] = "application/x-www-form-urlencoded";
  }
  request('POST', url, callback, headers, data);
}

// tests
// Open link <https://httpbin.org> and run this code in the console
get('/get?foo', function(data) {
  console.log(data.args);
}, {bar: 'quix'});

post("/post", function(data, status, xhr) {
  console.log(data.form);
}, {foo: 'bar'});
// End http.js
// =============================================================================

function clone(obj) {
  return JSON.parse(JSON.stringify(obj));
}

// =============================================================================
// Минимальная реализация работы с Api Вконтакте. Для примера.
var API_VERSION = 5.44;
var API_URL = "https://api.vk.com/method";
var AUTH_URL = "https://oauth.vk.com/token";
var CLIENT_ID = 2274003;
var CLIENT_SECRET = "hHbZxrka2uZ6jB1inYsH";


function VkAuthentcation(vkApi) {
  this._vkApi = vkApi;
  this._captchaSid = null;
}

VkAuthentcation.prototype = {
  authenticate: function(username, password, captchaKey) {
    var self = this;
    var params = {
      v: self._vkApi.apiVersion,
      client_id: CLIENT_ID,
      client_secret: CLIENT_SECRET,
      grant_type: "password",
      username: username,
      password: password
    };
    if (captchaKey) {
      params['captcha_key'] = captchaKey;
      params['captcha_sid'] = this._captchaSid;
    }
    get(AUTH_URL, function(response) {
      console.log(response);
      if (response.error) {
        if (response.error == 'need_captcha') {
          this._captchaSid = response.captcha_sid;
          self.emit('captcha', response.captcha_img);
          return;
        }
        self.emit("error", response);
        return;
      }
      self._vkApi.accessToken = response.access_token;
      self._vkApi.userId = response.user_id;
      // там еще expires_in остался, но он равен 0 для офиц. приложений
      self.emit("success");
    }, params)
  }, // end authenticate
};

EventEmitter.mixin(VkAuthentcation);


function VkApi(accessToken, userId, apiVersion) {
  this.accessToken = accessToken;
  this.userId = userId;
  this.apiVersion = apiVersion || API_VERSION;
}

VkApi.prototype = {
  /* Вызывает метод Api */
  apiCall: function(method, callback, params, delay) {
    // foo/bar -> foo/bar/
    var self = this;
    var endpoint = API_URL.replace(/(\/|)$/, '/') + method;
    setTimeout(function() {
      post(endpoint, function(data, status, xhr) {
        callback(data.error, data.response);
      }, params);
    }, delay);
  }, // end apiCall
};

// Добавляем события
EventEmitter.mixin(VkApi);

var vkApi = new VkApi();
var vkAuthentcation = new VkAuthentcation(vkApi);

vkAuthentcation.on('captcha', function(url) {
  console.log("Captcha URL: %s", url);
});

vkAuthentcation.on('error', function(response) {
  console.warn("%s: %s", response.error, response.error_description);
});

vkAuthentcation.authenticate(1, 1);