var request = require('request');

/**
 * ## Responses
 * Responses from this API with be wrapped in an envelope to assist the caller
 * in dealing with the various responses from the service. There are no types
 * to check against in JavaScript, so this facilitates that.
 *
 *    {
 *      status: 200,
 *      data: { name: "John", age: 29 }
 *    }
 *
 * ## Logging
 * To enable logging, use the NODE_DEBUG environment variable.
 *
 *    NODE_DEBUG=apidoc
 *
 * @constructor
 */
function Github (host) {
  var showLogMessages = process.env.NODE_DEBUG ? process.env.NODE_DEBUG.indexOf('apidoc') !== -1 : false;

  function log (message) {
    if (showLogMessages) {
      console.log('[apidoc] ' + message);
    }
  }

  function getQueryString (options) {
    var params = [];
    var qs = options.qs || {};

    for (var key in qs) {
      if (qs[key]) {
        params.push(key + '=' + qs[key]);
      }
    }

    return params.join('&');
  }

  function doRequest (options) {
    var startMs = Date.now();
    options = options || {};

    if (!options.json) {
      options.json = true;
    }

    options.qsStringifyOptions = {
      arrayFormat: 'repeat'
    };

    var queryString = getQueryString(options);
    var url = options.uri + (queryString ? '?' + queryString : '');

    log(options.method + ' ' + url);
    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
      log('|--> With body:\n\t\t' + JSON.stringify(options.json));
    }

    return new Promise(function (resolve, reject) {
      request(options, function (err, response) {
        if (err) {
          reject(err);
          return;
        }

        var duration = Date.now() - startMs;
        var requestHref = response.request ? response.request.href : '<unknown url>';

        log('Completed ' + options.method + ' ' + requestHref + ' ' + response.statusCode + ' ' + duration + 'ms');

        resolve(response);
      });
    });
  }

  /**
   * Simple plain object check. This is actually really involved to be 100%
   * accurate
   */
  function isObject (obj) {
    return typeof obj === 'object' && !Array.isArray(obj);
  }

  var Blobs = (function Blobs() {
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {string} sha
       */
      function getGitBlobsByOwnerAndRepoAndSha(owner, repo, sha) {


        var url = host + '/repos/' + owner + '/' + repo + '/git/blobs/' + sha + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postGitBlobsByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/repos/' + owner + '/' + repo + '/git/blobs';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getGitBlobsByOwnerAndRepoAndSha: getGitBlobsByOwnerAndRepoAndSha,
      postGitBlobsByOwnerAndRepo: postGitBlobsByOwnerAndRepo,
    };
  }());

  var Commits = (function Commits() {
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {string} sha
       */
      function getGitCommitsByOwnerAndRepoAndSha(owner, repo, sha) {


        var url = host + '/repos/' + owner + '/' + repo + '/git/commits/' + sha + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postGitCommitsByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/repos/' + owner + '/' + repo + '/git/commits';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getGitCommitsByOwnerAndRepoAndSha: getGitCommitsByOwnerAndRepoAndSha,
      postGitCommitsByOwnerAndRepo: postGitCommitsByOwnerAndRepo,
    };
  }());

  var Contents = (function Contents() {
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {string} options.ref
       */
      function getReadmeByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/repos/' + owner + '/' + repo + '/readme';
        var queryString = {
          ref: options.ref,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {string} path
       * @param {Object} options
       * @param {string} options.ref
       */
      function getContentsByOwnerAndRepoAndPath(owner, repo, path, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/repos/' + owner + '/' + repo + '/contents/' + path + '';
        var queryString = {
          ref: options.ref,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getReadmeByOwnerAndRepo: getReadmeByOwnerAndRepo,
      getContentsByOwnerAndRepoAndPath: getContentsByOwnerAndRepoAndPath,
    };
  }());

  var Hooks = (function Hooks() {
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       */
      function getHooksByOwnerAndRepo(owner, repo) {


        var url = host + '/repos/' + owner + '/' + repo + '/hooks';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {string} id
       */
      function getHooksByOwnerAndRepoAndId(owner, repo, id) {


        var url = host + '/repos/' + owner + '/' + repo + '/hooks/' + id + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postHooksByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/repos/' + owner + '/' + repo + '/hooks';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {string} id
       */
      function deleteHooksByOwnerAndRepoAndId(owner, repo, id) {


        var url = host + '/repos/' + owner + '/' + repo + '/hooks/' + id + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'DELETE'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 204:
              return Promise.resolve();
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getHooksByOwnerAndRepo: getHooksByOwnerAndRepo,
      getHooksByOwnerAndRepoAndId: getHooksByOwnerAndRepoAndId,
      postHooksByOwnerAndRepo: postHooksByOwnerAndRepo,
      deleteHooksByOwnerAndRepoAndId: deleteHooksByOwnerAndRepoAndId,
    };
  }());

  var PullRequests = (function PullRequests() {
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postPullsByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/repos/' + owner + '/' + repo + '/pulls';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {number} options.page
       */
      function getPullsByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/repos/' + owner + '/' + repo + '/pulls';
        var queryString = {
          page: options.page,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      postPullsByOwnerAndRepo: postPullsByOwnerAndRepo,
      getPullsByOwnerAndRepo: getPullsByOwnerAndRepo,
    };
  }());

  var Refs = (function Refs() {
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       */
      function getGitRefsByOwnerAndRepo(owner, repo) {


        var url = host + '/repos/' + owner + '/' + repo + '/git/refs';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {string} ref
       */
      function getGitRefsByOwnerAndRepoAndRef(owner, repo, ref) {


        var url = host + '/repos/' + owner + '/' + repo + '/git/refs/' + ref + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postGitRefsByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/repos/' + owner + '/' + repo + '/git/refs';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {string} ref
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putGitRefsByOwnerAndRepoAndRef(owner, repo, ref, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/repos/' + owner + '/' + repo + '/git/refs/' + ref + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getGitRefsByOwnerAndRepo: getGitRefsByOwnerAndRepo,
      getGitRefsByOwnerAndRepoAndRef: getGitRefsByOwnerAndRepoAndRef,
      postGitRefsByOwnerAndRepo: postGitRefsByOwnerAndRepo,
      putGitRefsByOwnerAndRepoAndRef: putGitRefsByOwnerAndRepoAndRef,
    };
  }());

  var Repositories = (function Repositories() {
      /**
       * 
       * 
       * @param {Object} options
       * @param {number} options.page
       * @param {*} options.visibility
       * @param {string} options.affiliation
       * @param {string} options.type
       * @param {string} options.sort
       * @param {string} options.direction
       */
      function getRepos(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/user/repos';
        var queryString = {
          page: options.page,
          visibility: options.visibility,
          affiliation: options.affiliation,
          type: options.type,
          sort: options.sort,
          direction: options.direction,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * List public repositories for the specified user.
       * 
       * @param {string} username
       * @param {Object} options
       * @param {number} options.page
       * @param {string} options.type
       * @param {string} options.sort
       * @param {string} options.direction
       */
      function getReposByUsername(username, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/users/' + username + '/repos';
        var queryString = {
          page: options.page,
          type: options.type,
          sort: options.sort,
          direction: options.direction,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * List repositories for the specified org.
       * 
       * @param {string} org
       * @param {Object} options
       * @param {number} options.page
       * @param {string} options.type
       * @param {string} options.sort
       * @param {string} options.direction
       */
      function getReposByOrg(org, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/orgs/' + org + '/repos';
        var queryString = {
          page: options.page,
          type: options.type,
          sort: options.sort,
          direction: options.direction,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getRepos: getRepos,
      getReposByUsername: getReposByUsername,
      getReposByOrg: getReposByOrg,
    };
  }());

  var Tags = (function Tags() {
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {number} options.page
       * @param {number} options.perPage
       */
      function getTagsByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/repos/' + owner + '/' + repo + '/tags';
        var queryString = {
          page: options.page,
          per_page: options.perPage,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {string} sha
       */
      function getTagsByOwnerAndRepoAndSha(owner, repo, sha) {


        var url = host + '/repos/' + owner + '/' + repo + '/tags/' + sha + '';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postGitTagsByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/repos/' + owner + '/' + repo + '/git/tags';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getTagsByOwnerAndRepo: getTagsByOwnerAndRepo,
      getTagsByOwnerAndRepoAndSha: getTagsByOwnerAndRepoAndSha,
      postGitTagsByOwnerAndRepo: postGitTagsByOwnerAndRepo,
    };
  }());

  var Trees = (function Trees() {
      /**
       * 
       * 
       * @param {string} owner
       * @param {string} repo
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postGitTreesByOwnerAndRepo(owner, repo, options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/repos/' + owner + '/' + repo + '/git/trees';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 201:
              return Promise.resolve(serverResponse.body);
            case 404:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            case 422:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      postGitTreesByOwnerAndRepo: postGitTreesByOwnerAndRepo,
    };
  }());

  var Users = (function Users() {
      /**
       * 
       * 
       */
      function get() {


        var url = host + '/user';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }
      /**
       * 
       * 
       * @param {Object} options
       * @param {number} options.page
       * @param {number} options.perPage
       */
      function getOrgs(options) {
        // if options is not defined, set it
        options = options || {};

        // otherwise if it's not the kind of object we want...
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }


        var url = host + '/user/orgs';
        var queryString = {
          page: options.page,
          per_page: options.perPage,
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      get: get,
      getOrgs: getOrgs,
    };
  }());

  var UserEmails = (function UserEmails() {
      /**
       * 
       * 
       */
      function getEmails() {


        var url = host + '/user/emails';
        var queryString = {
        };
        var requestOpts = {
          qs: queryString,
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve(serverResponse.body);
            case 401:
              return Promise.reject({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

    return {
      getEmails: getEmails,
    };
  }());

  this.Blobs = Blobs;
  this.Commits = Commits;
  this.Contents = Contents;
  this.Hooks = Hooks;
  this.PullRequests = PullRequests;
  this.Refs = Refs;
  this.Repositories = Repositories;
  this.Tags = Tags;
  this.Trees = Trees;
  this.Users = Users;
  this.UserEmails = UserEmails;
}



module.exports = Github;