'use strict';

var Promise = require('sporks/scripts/promise'),
  sporks = require('sporks');

var Config = function (slouch) {
  this._slouch = slouch;
};

Config.prototype._couchDB2Request = function (node, path, opts, parseBody) {
  opts.uri = this._slouch._url + '/_node/' + node + '/_config/' + path;
  opts.parseBody = parseBody;
  return this._slouch._req(opts);
};

// Warning: as per https://github.com/klaemo/docker-couchdb/issues/42#issuecomment-169610897, this
// isn't really the best approach as a more complete solution would implement some rollback
// mechanism when a node fails after several attempts. (Retries are already attempted by the
// request).
Config.prototype._couchDB2Requests = function (path, opts, parseBody, maxNumNodes) {
  var self = this,
    promises = [],
    i = 0;

  return self._slouch.membership.get().then(function (members) {
    members.cluster_nodes.forEach(function (node) {
      if (typeof maxNumNodes === 'undefined' || i++ < maxNumNodes) {
        // Clone the opts as we need a separate copy per node
        var clonedOpts = sporks.clone(opts);
        promises.push(self._couchDB2Request(node, path, clonedOpts, parseBody));
      }
    });

    // Only return a single promise when there is a single promise so that the return value
    // is consistent for a single node.
    return promises.length > 1 ? Promise.all(promises) : promises[0];
  });
};

Config.prototype._couchDB1Request = function (path, opts, parseBody) {
  opts.uri = this._slouch._url + '/_config/' + path;
  opts.parseBody = parseBody;
  return this._slouch._req(opts);
};

Config.prototype._request = function (path, opts, parseBody, maxNumNodes) {
  var self = this;
  return self._slouch.system.isCouchDB1().then(function (isCouchDB1) {
    if (isCouchDB1) {
      return self._couchDB1Request(path, opts, parseBody);
    } else {
      return self._couchDB2Requests(path, opts, parseBody, maxNumNodes);
    }
  });
};

Config.prototype.get = function (path) {
  return this._request(path, {
    method: 'GET'
  }, true);
};

Config.prototype.set = function (path, value) {
  return this._request(path, {
    method: 'PUT',
    body: JSON.stringify(this._toString(value))
  });
};

Config.prototype.unset = function (path) {
  return this._request(path, {
    method: 'DELETE'
  });
};

Config.prototype.unsetIgnoreMissing = function (path) {
  var self = this;
  return self._slouch.doc.ignoreMissing(function () {
    return self.unset(path);
  });
};

Config.prototype.setCouchHttpdAuthTimeout = function (timeoutSecs) {
  // Convert timeout value to a string
  return this.set('couch_httpd_auth/timeout', timeoutSecs + '');
};

Config.prototype._toString = function (value) {
  if (typeof value === 'boolean') {
    return value ? 'true' : 'false';
  } else if (typeof value === 'string') {
    return value;
  } else {
    return value + ''; // convert to string
  }
};

Config.prototype.setCouchHttpdAuthAllowPersistentCookies = function (allow) {
  return this.set('couch_httpd_auth/allow_persistent_cookies', allow);
};

Config.prototype.setLogLevel = function (level) {
  return this.set('log/level', level);
};

Config.prototype.setCompactionRule = function (dbName, rule) {
  return this.set('compactions/' + encodeURIComponent(dbName), rule);
};

Config.prototype.setCouchDBMaxDBsOpen = function (maxDBsOpen) {
  return this.set('couchdb/max_dbs_open', maxDBsOpen);
};

Config.prototype.setHttpdMaxConnections = function (maxConnections) {
  return this.set('httpd/max_connections', maxConnections);
};

module.exports = Config;