stateManager

(function() {
    'use strict';

    /**
     * Service manager statement loading
     */

    var stateManager = function($rootScope, $timeout, advancedLog) {
        advancedLog = advancedLog.getInstance('stateManager');

        var stateManager   = {
                'init' : {},
                'error': {},
                'load' : {}
            },
            loadContainers = { /* Контейнер с сервисами */
                init: {}
            };

        $rootScope.loader = {
            init: {
                active: true,
                current: {}
            }
        };

        stateManager.init.add = function(service) {
            var addService = function(object, name) {
                    loadContainers.init[name] = object;
                    advancedLog.info('Добавлен сервис: %s', {func: 'add'}, name);
                },

                check = function(data) {
                    if (!_.isEmpty(data) && angular.isObject(data)) {
                        if (_.has(service[index], 'async')) {
                            return (!data.async) ? _.has(data, 'order') : true;
                        }
                    }
                };

            if (angular.isObject(service)) {
                for (var index in service) {
                    if (check(service[index])) {

                        if (_.isEmpty($rootScope.loader.init.current)) {
                            this.setCurrent().force(service[index], index);
                        }

                        addService(service[index], index);
                    } else {
                        advancedLog.info('Отсуствует указание типа очередности событий или один из ключей не является объектом - %s', {func: 'add'}, index);
                    }
                }
            } else {
                advancedLog.info('Добавленный список сервисов не является объектом %s', {func: 'add'}, service);
            }
        };

        stateManager.init.remove =  function(name) {
            var service = this.getByName(name);

            if (service) {
                var container = loadContainers.init;

                delete container[name];

                if (!service.async) {
                    if (!_.isEmpty($rootScope.loader.init.current) && $rootScope.loader.init.current.name == name) {
                        this.setCurrent().next();
                    }
                }


                advancedLog.info('Удален сервис: %s. Осталось: %d, список: %s', {func: 'remove'}, name, _.size(container), JSON.stringify(Object.keys(container)));

                if (_.isEmpty(container)) {
                    this.clear();
                    advancedLog.info('Менеджер состояний пустой', {func: 'add'});
                }
            } else {
                advancedLog.info('Сервис не найден', {func: 'add'});
            }
        };

        stateManager.init.setCurrent =  function() {

            var setCurrent = {};

            function set(service, name) {
                $rootScope.loader.init.current = service;
                $rootScope.loader.init.current.name = (service.name) ? service.name : name;
            }

            setCurrent.force = function(service, name) {
                if (!_.isEmpty(service) && !_.isEmpty(name)) {
                    if (!_.isEmpty($rootScope.loader.init.current)) {
                        set(service, name);
                    } else {
                        if (service.order === 1) {
                            set(service, name);
                        }
                    }
                }
            };

            setCurrent.next = function() {
                if (!_.isEmpty(loadContainers.init)) {
                    for (var index in loadContainers.init) {
                        if (!loadContainers.init[index].async && loadContainers.init[index].order == $rootScope.loader.init.current.order + 1) {
                            set(loadContainers.init[index], index);

                            break;
                        }
                    }
                }
            };

            return setCurrent;
        };

        stateManager.init.getByName =  function(name) {
            var service = loadContainers.init;

            advancedLog.info((service) ? 'Сервис %s найден' : 'Сервис %s не найден', {func: 'getByName'}, name);
            return service;
        };

        stateManager.init.clear =  function() {
            loadContainers.init = {};

            $timeout(function() {
                $rootScope.loader.init = {
                    active: false,
                    current: null
                };

                advancedLog.info('Менеджер состояний инициализации очищен', {func: 'clear'});
            }, 300);
        };

        return stateManager;
    };

    stateManager.$inject = ['$rootScope', '$timeout', 'advancedLog'];

    angular.module('appServices').factory('stateManager',  stateManager);
})();


initService

(function() {
    'use strict';

    /**
     * INITIALIZATION service
     */

    function init($q, $injector, advancedLog) {
        advancedLog = advancedLog.getInstance('init');

        var init     = {},
            services = {},        /* Контейнер с внедряемыми сервисами */
            initData = {
                'status': 'wait-start',
                'defer' : $q.defer(),

                'services': {
                    'vkInit': {
                        async: false,
                        order: 1
                    },
                    'socketInit': {
                        async: false,
                        order: 2
                    },
                    'loadDataInit': {
                        async: false,
                        order: 3
                    }
                }
            },
            injected = {
                'finish'  : false,
                'services': ['vk', 'socket', 'stateManager', 'getData']
            };

        init.start = function start() {
            injectService().then(function() {

                if (init.check('wait-start')) {
                    advancedLog.info('Запущена инициализация приложения', {func: 'start'});
                    services.stateManager.init.add(initData.services);
                    initData.status = 'start';

                    services.vk.init().then(function() {
                            services.stateManager.init.remove('vkInit');

                            services.socket.manager.connect().then(function(socketOBJ) {
                                services.stateManager.init.remove('socketInit');

                                services.getData.user.init(services.socket).then(function() {
                                    services.socket.manager.executeCB();

                                    services.stateManager.init.remove('loadDataInit');

                                    initData.status = 'finish';
                                    initData.defer.resolve();

                                    advancedLog.info('Инициализация завершена', {func: 'start'});
                                });
                            });
                        }
                    );
                } else {
                    advancedLog.info('Инициализация уже происходит или завершена', {func: 'start'});
                }
            });

            return initData.defer;
        };

        init.after = function after() {
            var defer = $q.defer();

            initData.defer.promise.then(function() {
                defer.resolve();
            });

            return defer.promise;
        };

        init.check = function check(status) {
            return initData.status === status;
        };



        function injectService() {
            var defer = $q.defer();

            if (!injected.finish) {
                for (var index in injected.services) {
                    if ($injector.has(injected.services[index])) {
                        services[injected.services[index]] = $injector.get(injected.services[index]);

                        if (_.last(injected.services) === injected.services[index]) {
                            injected.finish = true;
                            defer.resolve();
                        }
                    } else {
                        defer.reject();
                        advancedLog.error('Сервис %s не найден!', {func: 'injectService'}, injected.services[index]);
                    }
                }
            } else {
                advancedLog.info('Внедрение сервисов уже произведено!', {func: 'injectService'});

                defer.resolve();
            }

            return defer.promise;
        }

        return init;
    }

    init.$inject = ['$q', '$injector', 'advancedLog'];
    angular.module('appServices').factory('init', init);

})();