/*
  Copyright (C) 2018-present evan GmbH.

  This program is free software: you can redistribute it and/or modify it
  under the terms of the GNU Affero General Public License, version 3,
  as published by the Free Software Foundation.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License
  along with this program. If not, see http://www.gnu.org/licenses/ or
  write to the Free Software Foundation, Inc., 51 Franklin Street,
  Fifth Floor, Boston, MA, 02110-1301 USA, or download the license from
  the following URL: https://evan.network/license/

  You can be released from the requirements of the GNU Affero General Public
  License by purchasing a commercial license.
  Buying such a license is mandatory as soon as you use this software or parts
  of it on other blockchains than evan.network.

  For more information, please contact evan GmbH at this address:
  https://evan.network/license/
*/
System.register(["./core", "./utils"], function (exports_1, context_1) {
    "use strict";
    var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
        return new (P || (P = Promise))(function (resolve, reject) {
            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
            function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    };
    var __generator = (this && this.__generator) || function (thisArg, body) {
        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f) throw new TypeError("Generator is already executing.");
            while (_) try {
                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
                if (y = 0, t) op = [op[0] & 2, t.value];
                switch (op[0]) {
                    case 0: case 1: t = op; break;
                    case 4: _.label++; return { value: op[1], done: false };
                    case 5: _.label++; y = op[1]; op = [0]; continue;
                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
                    default:
                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                        if (t[2]) _.ops.pop();
                        _.trys.pop(); continue;
                }
                op = body.call(thisArg, _);
            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
        }
    };
    var _this, core, utils, startWatchers, watchForEveLow;
    _this = this;
    var __moduleName = context_1 && context_1.id;
    return {
        setters: [
            function (core_1) {
                core = core_1;
            },
            function (utils_1) {
                utils = utils_1;
            }
        ],
        execute: function () {
            /**
             * Start watchers for handling special frontend events. (e.g. eve's too low)
             */
            exports_1("startWatchers", startWatchers = function () {
                setInterval(function () { return watchForEveLow(); }, 10 * 1000);
            });
            /**
             * Check if the current active accounts balance is low or empty and sends an event.
             *
             * @return     {Promise<void>}  resolved when done
             */
            exports_1("watchForEveLow", watchForEveLow = function () { return __awaiter(_this, void 0, void 0, function () {
                var activeAccount, balance, disableWarnings;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            activeAccount = core.activeAccount();
                            if (!activeAccount) return [3 /*break*/, 2];
                            return [4 /*yield*/, core.getBalance(activeAccount)];
                        case 1:
                            balance = _a.sent();
                            // send a warning, when the amount of eves gets low
                            if (balance <= 0.1) {
                                utils.sendEvent('evan-warning', {
                                    type: 'eve-empty',
                                    value: balance
                                });
                            }
                            else if (balance <= 1) {
                                utils.sendEvent('evan-warning', {
                                    type: 'eve-low',
                                    value: balance
                                });
                            }
                            else {
                                disableWarnings = window.localStorage['evan-warnings-disabled'] || '{ }';
                                try {
                                    disableWarnings = JSON.parse(disableWarnings);
                                }
                                catch (ex) { }
                                // reset low eve amount
                                delete disableWarnings['eve-low'];
                                delete disableWarnings['eve-empty'];
                                window.localStorage['evan-warnings-disabled'] = JSON.stringify(disableWarnings);
                            }
                            _a.label = 2;
                        case 2: return [2 /*return*/];
                    }
                });
            }); });
        }
    };
});

//# sourceMappingURL=src/build/watchers.js.map
