'use strict';

var debug = require('debug')('store:server');
var m = require('mithril');
var resources = require('server/rest/resources');
var request = require('supertest');

function noop(){}

function load(type, id, model, options) {
  debug('load', type, id, options);
  if (!resources[type]) {
    throw Error('Resource with type "' + type + '" does not exist');
  }
  return new Promise(function(resolve) {
    request(resources[type])
      .get('/' + id)
      .query(options)
      .expect(function(res) {
        resolve(model(res.body));
      })
      .end(noop);
    });
}

function identity(thing) {
  return thing;
}

function loadWhere(type, where, model, options) {
  if (typeof model !== 'function') {
    options = model;
    model = identity;
  }
  debug('loadWhere', type, where, options);
  return new Promise(function(resolve) {
    request(resources[type])
      .get('/')
      .query(options)
      .query({where: where})
      .expect(function(res) {
        resolve(res.body.map(model));
      })
      .end(noop);
    });
}

var store = {
  load: load,
  loadWhere: loadWhere
};

// these two functions are only for testing purposes. NEVER use them in normal code!
store._mock = function _mock(fnName, cb, result, err) {
  var origFn = store[fnName];
  // cb is optional argument
  // if left out, cb parameter is result
  if (typeof cb !== 'function') {
    err = result;
    result = cb;
    cb = null;
  }
  store[fnName] = function() {
    store[fnName] = origFn;
    if (cb) {
      var cbResult = cb.apply(null, arguments);
      result = result || cbResult;
    }
    var deferred = m.deferred();
    if (err) {
      deferred.reject(err);
    } else {
      deferred.resolve(result);
    }
    return deferred.promise;
  };
};

store._resetAll = function _resetAll() {
  store.save = save;
  store.load = load;
  store.remove = remove;
  store.loadWhere = loadWhere;
};

module.exports = store;