app.requires.push('ngResource');
app.requires.push('ngSanitize');
app.requires.push('ngMessages');
app.requires.push('chart.js');
app.requires.push('ui.router');
app.requires.push('ui.router.util');
app.requires.push('ngContextMenu');
app.requires.push('angular-md5');
app.requires.push('angular-noty');
app.requires.push('ngFileUpload');
app.requires.push('angularMoment');
app.requires.push('ui.select');
app.requires.push('ngStorage');
app.requires.push('ngBootbox');
app.requires.push('ngBatubox');
app.requires.push('permission');
app.requires.push('permission.ui');
app.requires.push('ui.bootstrap');
app.requires.push('ui.sortable');
app.requires.push('green.inputmask4angular');
app.requires.push('ng.ckeditor');

app.run(function ($rootScope, $filter, $location, $state, $parse, $timeout, amMoment, Engine5, md5, noty) {

    $rootScope.Engine5 = Engine5;
    $rootScope.AdminConfig = Engine5.Admin.config || {};

    if (angular.isUndefined($rootScope.AdminConfig.editor)) {
        $rootScope.AdminConfig.editor = 'html5';
    }

    let wsPort = $rootScope.AdminConfig.ws.port || 8080;
    let wsHost = $rootScope.AdminConfig.ws.host || $location.host();
    let wsUri = "ws://" + wsHost + ":" + wsPort + "/";
    var ws = new WebSocket(wsUri);

    ws.onopen = function () {
        console.log(wsUri, "Socket has been opened!");
    };

    ws.onmessage = function (message) {
        const $message = JSON.parse(message.data);
        if (angular.isUndefined($message.type)) {
            return;
        }

        if (angular.isDefined($message.text) && $message.type === 'notify') {
            if (angular.isUndefined($message.notify_type) || $message.notify_type === 'alert') {
                noty.showAlert($message.text);
            } else if ($message.notify_type === 'success') {
                noty.showError($message.text);
            } else if ($message.notify_type === 'error') {
                noty.showError($message.text);
            }
        } else {
            $rootScope.$broadcast('ws-' + $message.type, $message);
        }
    };



    $rootScope.Math = window.Math;
    amMoment.changeLocale('pl');
    function makeId() {
        var text = "";
        var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

        for (var i = 0; i < 5; i++)
            text += possible.charAt(Math.floor(Math.random() * possible.length));

        return text;
    }

    var $$loadCacheData = {};
    var $$countCacheData = {};
    $rootScope.$sorting = function (column) {
        this.filter.reverse = (this.filter.predicate === column) ? !this.filter.reverse : true;
        this.filter.predicate = column;
    };
    $rootScope.$search = function (input) {
        return $filter('filter')(input, this.filter.search);
    };
    $rootScope.$clearCache = function () {
        $$loadCacheData = {};
        $$countCacheData = {};
    };

    var lastHash = null;
    var inputChangedPromise;
    var inputCountChangedPromise;
    $rootScope.$load = function (Model) {
        var ctrlId = $state.current.name;
        if (angular.isUndefined(Model))
            return;
        if (angular.isUndefined(Model.$$uid)) {
            Model.$$uid = "aaa" + ctrlId;
        }

        if (angular.isUndefined(Model.$$method)) {
            Model.$$method = "query";
        }

        var page = parseInt(this.filter.page || 1);
        var limit = parseInt(this.filter.limit || 10);
        var params = angular.extend({ 'limit': limit, 'page': page, 'search': this.search, 'sort': this.filter.predicate, 'revers': this.filter.reverse }, Model.$$params);
        var hash = md5.createHash(ctrlId + " " + Model.$$method + " " + Model.$$uid + " " + JSON.stringify(params)).toString();


        if (lastHash !== hash) {
            lastHash = hash;
            document.body.scrollTop = document.documentElement.scrollTop = 0;
        }

        if (angular.isUndefined($$loadCacheData[hash])) {
            $$loadCacheData[hash] = [];
            $$loadCacheData[hash].$resolved = true;

            if (inputChangedPromise) {
                $timeout.cancel(inputChangedPromise);
            }

            inputChangedPromise = $timeout(function () {
                $$loadCacheData[hash] = Model[Model.$$method](params, function () {
                    if (Model.$$onLoad) {
                        Model.$$onLoad();
                    }
                });
            }, 1000);
        }

        return $$loadCacheData[hash];
    };

    $rootScope.$prevPage = function (pages) {
        pages = pages || 1;

        var prevPage = (this.filter.page - pages);

        if (prevPage >= 1) {
            this.filter.page = prevPage;
        } else {
            this.filter.page = 1;
        }
    };
    $rootScope.$nextPage = function (pages) {
        pages = pages || 1;
        var count = this.$count(this.Model).length;
        var maxPage = Math.ceil(count / this.filter.limit);
        var nextPage = (this.filter.page + pages);

        if (nextPage <= maxPage) {
            this.filter.page = nextPage;
        } else {
            this.filter.page = maxPage;
        }
    };
    $rootScope.$setPage = function (page) {
        var count = this.$count(this.Model).length;
        var maxPage = Math.ceil(count / this.filter.limit);

        if (page <= maxPage && page > 0) {
            this.filter.page = page;
        }
    };
    $rootScope.$count = function (Model) {
        if (angular.isUndefined(Model)) {
            return;
        }

        if (angular.isUndefined(Model.$$uid)) {
            Model.$$uid = makeId();
        }

        if (angular.isUndefined(Model.$$count)) {
            Model.$$count = "count";
        }

        var $filter = this.filter;

        var page = parseInt(this.filter.page || 1);
        var limit = parseInt(this.filter.limit || 10);
        var params = angular.extend({ 'search': this.search }, Model.$$params);
        var hash = md5.createHash(Model.$$count + " " + Model.$$uid + " " + JSON.stringify(params)).toString();
        if (angular.isUndefined($$countCacheData[hash])) {
            $$countCacheData[hash] = [];

            if (inputCountChangedPromise) {
                $timeout.cancel(inputCountChangedPromise);
            }

            inputCountChangedPromise = $timeout(function () {
                $$countCacheData[hash] = Model[Model.$$count](params, function () {
                    if (page > 1 && (limit * (page - 1)) > $$countCacheData[hash].length) {
                        $filter.page = 1;
                    }
                });
            }, 1000);
        } else if (angular.isDefined($$countCacheData[hash])) {
            if (page > 1 && (limit * (page - 1)) > $$countCacheData[hash].length) {
                $filter.page = 1;
            }
        }



        return $$countCacheData[hash];
    };
    $rootScope.$propertify = function (string) {
        var _scope = this;
        var property = $parse(string);
        var propAssign = property.assign;
        return function (newVal) {
            if (arguments.length) {
                newVal = angular.isDefined(newVal) ? newVal : '';
                propAssign(_scope, newVal);
            }
            return property(_scope);
        };
    };
    $rootScope.$isDefined = angular.isDefined;
    $rootScope.$isUndefined = angular.isUndefined;
    $rootScope.$isArray = angular.isArray;
    $rootScope.$includesAny = function (a1, a2) {
        var result = false;

        angular.forEach(a1, function (item) {
            if (a2.includes(item)) {
                result = true;
            }
        });

        return result;
    };

});