import { isObject,
          doRequest,
          getRequestOptions } from './utils';

export default class {
  constructor (host, auth, headers) {
    this.host = host;
    this.auth = auth;
    this.headers = headers;
  }

    getMetadataAndVersionsByApplicationkey (orgKey, applicationKey, options) {
      const operationSettings = {
  "requiresBody": false,
  "queryParams": [
    {
      "name": "limit",
      "nameCamelCase": "limit"
    },
    {
      "name": "offset",
      "nameCamelCase": "offset"
    }
  ],
  "isApplicationJson": false,
  "isFormUrlEncoded": false,
  "method": "GET"
};

      return getRequestOptions(operationSettings, options)
        .then((opts) => {
          const uri = `${this.host}/${orgKey}/metadata/${applicationKey}/versions`;
          const auth = opts.auth || this.auth;
          const headers = this.headers || {};

          // Layer in some options local to this class
          const requestOpts = Object.assign({ headers }, opts, {
            auth,
            uri
          });

          return doRequest(requestOpts).then(function (serverResponse) {
            switch (serverResponse.statusCode) {
              case 200:
                if (requestOpts.json) {
                  return Promise.resolve(serverResponse.body);
                } else {
                  return Promise.resolve(JSON.parse(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));
            }
          });
        });
    }

    getMetadataAndVersionsAndLatesttxtByApplicationkey (orgKey, applicationKey, options) {
      const operationSettings = {
  "requiresBody": false,
  "queryParams": [],
  "isApplicationJson": false,
  "isFormUrlEncoded": false,
  "method": "GET"
};

      return getRequestOptions(operationSettings, options)
        .then((opts) => {
          const uri = `${this.host}/${orgKey}/metadata/${applicationKey}/versions/latest.txt`;
          const auth = opts.auth || this.auth;
          const headers = this.headers || {};

          // Layer in some options local to this class
          const requestOpts = Object.assign({ headers }, opts, {
            auth,
            uri
          });

          return doRequest(requestOpts).then(function (serverResponse) {
            switch (serverResponse.statusCode) {
              case 200:
                if (requestOpts.json) {
                  return Promise.resolve(serverResponse.body);
                } else {
                  return Promise.resolve(JSON.parse(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));
            }
          });
        });
    }

    get (orgKey, options) {
      const operationSettings = {
  "requiresBody": false,
  "queryParams": [
    {
      "name": "name",
      "nameCamelCase": "name"
    },
    {
      "name": "guid",
      "nameCamelCase": "guid"
    },
    {
      "name": "key",
      "nameCamelCase": "key"
    },
    {
      "name": "has_version",
      "nameCamelCase": "hasVersion"
    },
    {
      "name": "limit",
      "nameCamelCase": "limit"
    },
    {
      "name": "offset",
      "nameCamelCase": "offset"
    },
    {
      "name": "sort_by",
      "nameCamelCase": "sortBy"
    },
    {
      "name": "order",
      "nameCamelCase": "order"
    }
  ],
  "isApplicationJson": false,
  "isFormUrlEncoded": false,
  "method": "GET"
};

      return getRequestOptions(operationSettings, options)
        .then((opts) => {
          const uri = `${this.host}/${orgKey}`;
          const auth = opts.auth || this.auth;
          const headers = this.headers || {};

          // Layer in some options local to this class
          const requestOpts = Object.assign({ headers }, opts, {
            auth,
            uri
          });

          return doRequest(requestOpts).then(function (serverResponse) {
            switch (serverResponse.statusCode) {
              case 200:
                if (requestOpts.json) {
                  return Promise.resolve(serverResponse.body);
                } else {
                  return Promise.resolve(JSON.parse(serverResponse.body));
                }
              default:
                return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
            }
          });
        });
    }

    post (orgKey, options) {
      const operationSettings = {
  "requiresBody": true,
  "bodyType": "application_form",
  "queryParams": [],
  "isApplicationJson": true,
  "isFormUrlEncoded": false,
  "method": "POST"
};

      return getRequestOptions(operationSettings, options)
        .then((opts) => {
          const uri = `${this.host}/${orgKey}`;
          const auth = opts.auth || this.auth;
          const headers = this.headers || {};

          // Layer in some options local to this class
          const requestOpts = Object.assign({ headers }, opts, {
            auth,
            uri
          });

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

    putByApplicationkey (orgKey, applicationKey, options) {
      const operationSettings = {
  "requiresBody": true,
  "bodyType": "application_form",
  "queryParams": [],
  "isApplicationJson": true,
  "isFormUrlEncoded": false,
  "method": "PUT"
};

      return getRequestOptions(operationSettings, options)
        .then((opts) => {
          const uri = `${this.host}/${orgKey}/${applicationKey}`;
          const auth = opts.auth || this.auth;
          const headers = this.headers || {};

          // Layer in some options local to this class
          const requestOpts = Object.assign({ headers }, opts, {
            auth,
            uri
          });

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

    deleteByApplicationkey (orgKey, applicationKey, options) {
      const operationSettings = {
  "requiresBody": false,
  "queryParams": [],
  "isApplicationJson": false,
  "isFormUrlEncoded": false,
  "method": "DELETE"
};

      return getRequestOptions(operationSettings, options)
        .then((opts) => {
          const uri = `${this.host}/${orgKey}/${applicationKey}`;
          const auth = opts.auth || this.auth;
          const headers = this.headers || {};

          // Layer in some options local to this class
          const requestOpts = Object.assign({ headers }, opts, {
            auth,
            uri
          });

          return doRequest(requestOpts).then(function (serverResponse) {
            switch (serverResponse.statusCode) {
              case 204:
                return Promise.resolve();
              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));
            }
          });
        });
    }

    postMoveByApplicationkey (orgKey, applicationKey, options) {
      const operationSettings = {
  "requiresBody": true,
  "bodyType": "move_form",
  "queryParams": [],
  "isApplicationJson": true,
  "isFormUrlEncoded": false,
  "method": "POST"
};

      return getRequestOptions(operationSettings, options)
        .then((opts) => {
          const uri = `${this.host}/${orgKey}/${applicationKey}/move`;
          const auth = opts.auth || this.auth;
          const headers = this.headers || {};

          // Layer in some options local to this class
          const requestOpts = Object.assign({ headers }, opts, {
            auth,
            uri
          });

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

}