module.exports = {

  friendlyName: 'Cache',
  description: 'Cache something.',

  inputs: {
    action: {
      type: 'string'
    },
    key: {
      type: 'string'
    },
    value: {
      type: 'ref'
    },
    EX: {
      type: 'number'
    }
  },

  exits: {
  },

  fn: async (inputs, exits) => {
    inputs.key = 'nwz:'+inputs.key;
    var read = key =>
      new Promise(resolve =>
        sails.getDatastore('cache').leaseConnection((cache, proceed) => {
          if (!cache) return proceed('no redis');
          cache.get(key, (error, data) => {
            if(error) return proceed(error);
            var obj = false;
            try{
              obj = JSON.parse(data);
            }catch(error){}
            return proceed(undefined, obj);
          });
        }).exec((error, obj) => {
          if(error) return resolve(-1);
          resolve(obj);
        })
      );

    var hashRead = (hash, key) =>
      new Promise(resolve =>
        sails.getDatastore('cache').leaseConnection((cache, proceed) => {
          if (!cache) return proceed('no redis');
          cache.hget(hash, key, (error, data) => {
            if(error) return proceed(error);
            var obj = data;
            try{
              obj = JSON.parse(data);
            }catch(error){}
            return proceed(undefined, obj);
          });
        }).exec((error, obj) => {
          if(error) return resolve(-1);
          resolve(obj);
        })
      );

    var hashReadAll = hash =>
      new Promise(resolve =>
        sails.getDatastore('cache').leaseConnection((cache, proceed) => {
          if (!cache) return proceed('no redis');
          cache.hgetall(hash, (error, data) => {
            if(error) return proceed(error);
            var obj = data;
            for (let key in obj) try{ obj[key] = JSON.parse(data[key]); }catch(error){}
            return proceed(undefined, obj);
          });
        }).exec((error, obj) => {
          if(error) return resolve(-1);
          resolve(obj);
        })
      );

    var write = async (key, value, EX) =>
      new Promise(resolve =>
        sails.getDatastore('cache').leaseConnection((cache, proceed) => {
          if (!cache) return proceed('no redis');
          if(EX)
            cache.set(key, JSON.stringify(value), 'EX', EX, error => {
              if(error) return proceed(error);
              return proceed(undefined);
            });
          else
            cache.set(key, JSON.stringify(value), error => {
              if(error) return proceed(error);
              return proceed(undefined);
            });
        }).exec((error) => {
          if(error) return resolve(-1);
          resolve(0);
        })
      );

    var hashWrite = async (key, value, EX) => {
      for(let index in value)
        value[index] = JSON.stringify(value[index]);
      return new Promise(resolve =>
        sails.getDatastore('cache').leaseConnection((cache, proceed) => {
          if (!cache) return proceed('no redis');
          if(EX)
            cache.HMSET(key, value, 'EX', EX, error => {
              if(error) return proceed(error);
              return proceed(undefined);
            });
          else
            cache.HMSET(key, value, error => {
              if(error) return proceed(error);
              return proceed(undefined);
            });
        }).exec((error) => {
          if(error) return resolve(-1);
          resolve(0);
        })
      );
    };

    var remove = async (key) =>
      new Promise(resolve =>
        sails.getDatastore('cache').leaseConnection((cache, proceed) => {
          if (!cache) return proceed('no redis');
          cache.del(key, error => {
            if(error) return proceed(error);
            return proceed(undefined);
          });
        }).exec((error) => {
          if(error) return resolve(-1);
          resolve(null);
        })
      );

    if(!inputs.EX) inputs.EX = 0;
    var res = null;
    switch(inputs.action) {
      case 'get':
        res = exits.success(await read(inputs.key));
        break;

      case 'hget':
        res = exits.success(await hashRead(inputs.key, inputs.value));
        break;

      case 'hgetall':
        res = exits.success(await hashReadAll(inputs.key));
        break;

      case 'set':
        res = exits.success(await write(inputs.key, inputs.value, inputs.EX));
        break;

      case 'hmset':
        res = exits.success(await hashWrite(inputs.key, inputs.value, inputs.EX));
        break;

      case 'del':
        res = exits.success(await remove(inputs.key));
    }

    return res;
  },
};