Autosave

define(['angular', 'lodash'], function(angular, _) {
  'use strict';

  return [AutoSave];

  function AutoSave() {

    var _this = this;

    _this.wait      = 10000;
    _this.maxErrors = 2;


    _this.$get = ['$interval', '$http', '$rootScope', 'slvConfig', 'formValidator', function($interval, $http, $rootScope, slvConfig, formValidator) {

      var _interval       = {},
          _watcherCancel  = {},
          _paused         = {},
          _pausedAll      = false,
          _dataChanged    = {},
          _url            = {},
          _resource       = {},
          _data           = {},
          _ctrlParams     = {},
          _queryParams    = {},
          _saveErrors     = {},
          _formList       = {},
          _formValidation = false,
          _debug          = false;

      return {
        register             : register,
        enableFormValidation : enableFormValidation,
        stopFormValidation   : stopFormValidation,
        start                : register,
        setParams            : setParams,
        stop                 : stop,
        pause                : pause,
        resume               : resume,
        force                : force,
        debug                : debug
      };

      function register(scope, context, name, urlOrResource) {

        _data[name]          = context[name];
        _saveErrors[name]    = 0;

        if (urlOrResource && _.isString(urlOrResource)) {
          _url[name] = urlOrResource;
        } else {
          _resource[name] = context[name];
        }

        _setCtrlParams(scope, context, name);
        _watcherCancel[name] = _watch(scope, context, name);

        _interval[name] = $interval(function() {
          if (_validForms()) {
            _save(name);
          }
        }, _this.wait);
      }

      function enableFormValidation(name, formList) {
        _formValidation = true;
        _formList[name] = formList;
      }

      function stopFormValidation(name) {
        _formValidation = false;
        if (name) {
          delete _formList[name];
        } else {
          _formList = {};
        }
      }

      function setParams(name, params) {
        if (name !== undefined) {
          if (params !== undefined) {
            _queryParams[name] = params;
          } else if (name !== undefined) {
            delete _queryParams[name];
          }
          return _queryParams[name];
        }
      }

      function stop(name, override, save) {

        if (arguments.length === 0) {

          _stop(undefined, undefined, undefined);

        } else if (arguments.length === 1) {

          if (_.isString(name)) {
            _stop(name, undefined, undefined);
          } else if (_.isObject(name)) {
            _stop(undefined, name, undefined);
          } else if (_.isBoolean(name)) {
            _stop(undefined, undefined, name);
          }

        } else if (arguments.length === 2) {

          if (_.isString(name)) {
            if (_.isObject(override)) {
              _stop(name, override, undefined);
            } else if (_.isBoolean(override)) {
              _stop(name, undefined, override);
            }
          } else if (_.isObject(name)) {
            _stop(undefined, name, override);
          }

        } else {
          _stop(name, override, save);
        }
      }

      function _stop(name, override, save) {

        if (_.isUndefined(name)) {
          _.forIn(_interval, function(interval, key) {
            _stop(key, override, save);
          });
        } else {
          if (_.isObject(override)) {
            setParams(name, override);
          }
          if (_.isUndefined(save) || save === true) {
            _save(name, true);
          }
          $interval.cancel(_interval[name]);
          if (_watcherCancel[name]) {
            _watcherCancel[name]();
          }
          delete _watcherCancel[name];
          delete _data[name];
          delete _url[name];
          delete _resource[name];
          delete _saveErrors[name];
          delete _queryParams[name];
          delete _ctrlParams[name];
          stopFormValidation(name);
          _debugLog('Stopped autosave for : ' + name);
        }

      }

      function pause(name) {
        if (name === undefined) {
          _pausedAll = true;
        } else {
          _paused[name] = true;
        }
      }

      function resume(name) {
        if (name === undefined) {
          _pausedAll = false;
        } else {
          delete _paused[name];
        }
      }

      function force(name) {
        console.log('Forcing', name);
        if (name !== undefined) {
          _save(name, true);
        } else {
          _.forIn(_interval, function(value, key) {
            force(key);
          });
        }
      }

      function debug(state) {
        _debug = state !== false;
        console.log({
          debug    : _debug,
          interval : _interval,
          paused   : _paused,
          url      : _url,
          data     : _data
        });
      }

      function _watch(scope, context, name) {
        return scope.$watch(angular.bind(context, function() {
          return this[name];
        }), function(newVal, oldVal) {
          if (newVal !== oldVal) {
            _change(name, newVal);
          }
          if (_debug) {
            console.log('change detected : ' + name);
          }
        }, true);
      }

      function _change(name, newVal) {
        _dataChanged[name] = true;
        _saveErrors[name]  = 0;
        _data[name]        = newVal;
      }

      function _save(name, forceSave) {
        if (((!_pausedAll && !_paused[name] &&
          _dataChanged[name]) ||
          forceSave === true) &&
          _formsValidate(name)) {
          if (_url[name]) {
            _debugLog('autoSaved with url:', _data[name]);
            $http.put(slvConfig.wsBase + _url[name] + _setUrlParams(name)).then(_successSave(name), _errorSave(name));
          } else if (_resource[name]) {
            _debugLog('autoSaved with restangular:', _resource[name]);
            _resourceCheckSave(name);
          }
        }
      }

      function _formsValidate(name) {
        if (_formValidation) {
          if (formValidator.formsValid(_ctrlParams[name].context, _formList[name])) {
            return true;
          } else {
            _debugLog('Not saved because forms are not valid !');
            return false;
          }
        }
        return true;
      }

      function _resourceCheckSave(name) {
        if (_resource[name].put !== undefined) {
          _resource[name].put(_queryParams[name]).then(_successSave(name), _errorSave(name));
        } else {
          _dataChanged[name] = false;
        }
      }

      function _setUrlParams(name) {
        var urlString = '';
        _.forIn(_queryParams[name], function(value, key) {
          var paramString = key + '=' + value;
          if (urlString !== '') {
            urlString += '&';
          }
          urlString += paramString;
        });
        return urlString !== '' ? '?' + urlString : '';
      }

      function _setCtrlParams(scope, context, name) {
        _ctrlParams[name]         = _ctrlParams[name] || {};
        _ctrlParams[name].context = context;
        _ctrlParams[name].scope   = scope;
      }

      function _successSave(name) {
        return function(data) {
          _dataChanged[name] = false;
          $rootScope.$broadcast('newSave', {
            name    : name,
            error   : false,
            message : 'Success',
            data    : data
          });
        };
      }

      function _errorSave(name) {
        return function(err) {
          $rootScope.$broadcast('newSave', {
            name    : name,
            error   : true,
            message : 'Error',
            data    : err
          });
          _errorIncrement(name);
        };
      }

      function _validForms() {
        return _formValidation ?
          formValidator.formsValid() :
          true;
      }

      function _debugLog(title, data) {
        if (_debug) {
          console.log(title);
          if (data) {
            console.log(data);
          }
        }
      }

      function _errorIncrement(name) {
        _saveErrors[name]++;
        if (_saveErrors[name] >= _this.maxErrors) {
          _dataChanged[name] = false;
          _saveErrors[name]  = 0;
        }
      }
    }];
  }
});