describe('Module: oc.lazyLoad', function() {
    'use strict';

    var $ocLazyLoad,
        $rootScope,
        $controller,
        $injector,
        $filter,
        $compile,
        $httpBackend,
        $log,
        element,
        lazyLoadUrl = '/base/tests/unit/lazyLoad/',
        triggerDigests = function() {
            return setInterval(function() {
                $rootScope.$digest();
            }, 10)
        };

    describe('with app1', function() {

        beforeEach(function() {
            module('app1');

            // get the $httpBackend from E2E tests (because the one for unit tests sucks)
            module('ngMockE2E');
            module(function($provide) {
                //retrieve the $httpBackend from module ng and override $delegate from ngMockE2E
                angular.injector(['ng'])
                    .invoke(function($httpBackend) {
                        $provide.value('$delegate', $httpBackend);
                    });

                //retrieve the $httpBackend from module ng and override $delegate from ngMockE2E
                angular.injector(['ngMockE2E'])
                    .invoke(['$httpBackend', function(_$httpBackend_) {
                        $httpBackend = _$httpBackend_;
                    }]);

                $provide.value('$httpBackend', $httpBackend);
            });

            // get the services for all tests
            inject(function(_$ocLazyLoad_, _$rootScope_, _$controller_, _$injector_, _$filter_, _$compile_, _$log_) {
                $ocLazyLoad = _$ocLazyLoad_;
                $rootScope = _$rootScope_;
                $controller = _$controller_;
                $injector = _$injector_;
                $filter = _$filter_;
                $compile = _$compile_;
                $log = _$log_;
            });

            // allow requests for lazy loaded files
            $httpBackend.when('GET', new RegExp(lazyLoadUrl)).passThrough();
        });

        it('service should be defined', function() {
            expect($ocLazyLoad).toBeDefined();
        });

        it('getModules should be working', function() {
            expect($ocLazyLoad.getModules).toBeDefined();
            expect(angular.isArray($ocLazyLoad.getModules())).toBe(true);
        });

        it('loadedModules should be working', function() {
            expect($ocLazyLoad.getModules()).toEqual(['ng', 'oc.lazyLoad']);
        });

        it('angular.bootstrap should add the module to the loaded list', function() {
            angular.bootstrap(document, ['app1']);
            expect($ocLazyLoad.getModules()).toEqual(['ng', 'oc.lazyLoad', 'app1']);
        });

        it('isLoaded should be working', function() {
            expect($ocLazyLoad.isLoaded).toBeDefined();
            expect($ocLazyLoad.isLoaded).toThrowError('You need to define the module(s) name(s)');
            expect($ocLazyLoad.isLoaded('app1')).toBe(true); // string arg
            expect($ocLazyLoad.isLoaded(['ng', 'app1'])).toBe(true); // array arg
            expect($ocLazyLoad.isLoaded('noModule')).toBe(false);
            expect($ocLazyLoad.isLoaded(['ng', 'noModule'])).toBe(false);
        });

        it('getModuleConfig should be working', function() {
            expect($ocLazyLoad.getModuleConfig).toBeDefined();
            expect($ocLazyLoad.getModuleConfig).toThrowError('You need to give the name of the module to get');
            expect($ocLazyLoad.getModuleConfig('noModule')).toBe(null);
            expect($ocLazyLoad.getModuleConfig('test')).toEqual({name: 'test', files: []});
        });

        it('setModuleConfig should be working', function() {
            expect($ocLazyLoad.setModuleConfig).toBeDefined();
            expect($ocLazyLoad.setModuleConfig).toThrowError('You need to give the module config object to set');
            expect($ocLazyLoad.setModuleConfig({name: 'test2'})).toEqual({name: 'test2'});
            expect($ocLazyLoad.getModuleConfig('test2')).toEqual({name: 'test2'}); // check if set worked
        });

        it('should be able to lazy load a module', function(done) {
            var interval = triggerDigests(),
                templateUrl = lazyLoadUrl + 'test.html',
                testModule = [
                    lazyLoadUrl + 'testModule.js',
                    lazyLoadUrl + 'test.css',
                    templateUrl
                ];

            // create spies for the following tests
            window.spy = jasmine.createSpyObj('spy', ['config', 'run', 'ctrl', 'service', 'filter', 'directive', 'decorator']);

            $ocLazyLoad.load(testModule).then(function success(res) {
                window.clearInterval(interval);

                // Test the module loading
                expect(function() {
                    angular.module('testModule')
                }).not.toThrow();
                expect(angular.module('testModule')).toBeDefined();

                // execute controller
                expect(function() {
                    $controller('TestCtrl', {$scope: $rootScope.$new()});
                }).not.toThrow();

                // instantiate service
                expect(function() {
                    $injector.get('testService');
                }).not.toThrow();

                // execute filter
                expect(function() {
                    $filter('testFilter');
                }).not.toThrow();

                // Compile a piece of HTML containing the directive
                element = $compile("<test></test>")($rootScope.$new());

                // Test the template loading
                var $templateCache;
                expect(function() {
                    $templateCache = $injector.get('$templateCache');
                }).not.toThrow();
                expect($templateCache.get('/partials/test.html')).toEqual('Test partial content');

                // Test the css loading
                var links = document.getElementsByTagName('link');
                expect(links.length).toBeGreaterThan(0);
                expect(function() {
                    links[links.length - 1].sheet.cssRules;
                }).not.toThrow(); // this only works if a stylesheet has been loaded
                expect(links[links.length - 1].sheet.cssRules).toBeDefined();

                // because debug is set to false, we shouldn't have any log
                $log.assertEmpty();

                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should be able to execute config blocks', function() {
            expect(window.spy.config).toHaveBeenCalledWith('config1');
            expect(window.spy.config).toHaveBeenCalledWith('config2');
            expect(window.spy.config.calls.count()).toEqual(2);
        });

        it('should be able to execute run blocks', function() {
            expect(window.spy.run).toHaveBeenCalledWith('run1');
            expect(window.spy.run).toHaveBeenCalledWith('run2');
            expect(window.spy.run.calls.count()).toEqual(2);
        });

        it('should be able to define controllers', function() {
            expect(window.spy.ctrl).toHaveBeenCalledWith('ctrl');
            expect(window.spy.ctrl.calls.count()).toEqual(1);
        });

        it('should be able to define services', function() {
            expect(window.spy.service).toHaveBeenCalledWith('service');
            expect(window.spy.service.calls.count()).toEqual(1);
        });

        it('should be able to define filters', function() {
            expect(window.spy.filter).toHaveBeenCalledWith('filter');
            expect(window.spy.filter.calls.count()).toEqual(1);
        });

        it('should be able to define directives', function() {
            expect(window.spy.directive).toHaveBeenCalledWith('directive');
            expect(window.spy.directive.calls.count()).toEqual(1);
            expect(element.html()).toContain("Test template");
        });

        if(angular.version.minor > 3) { // only in angular 1.4+
            it('should be able to define decorators', function() {
                expect(window.spy.decorator).toHaveBeenCalledWith('decorator');
                expect(window.spy.service.calls.count()).toEqual(1);
            });
        }

        it('should be able to resolve a file name with url parameters', function(done) {
            var interval = triggerDigests(),
                testModule = [
                    lazyLoadUrl + 'test.html?v=xy12'
                ];

            $ocLazyLoad.load(testModule).then(function success(res) {
                window.clearInterval(interval);

                var $templateCache = $injector.get('$templateCache');
                expect($templateCache.get('/partials/test.html')).toEqual('Test partial content');

                // because debug is set to false, we shouldn't have any log
                $log.assertEmpty();

                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should be able to lazy load a module when specifying a file type', function(done) {
            var interval = triggerDigests(),
                testModuleNoExt = [
                    {type: 'js', path: lazyLoadUrl + 'testModule.fakejs'},
                    lazyLoadUrl + 'test.css',
                    'html!' + lazyLoadUrl + 'test.html'
                ];

            $ocLazyLoad.load(testModuleNoExt).then(function success(res) {
                window.clearInterval(interval);

                // Test the module loading
                expect(angular.module('testModuleNoExt')).toBeDefined();

                // execute controller
                $controller('TestCtrlNoExt', {$scope: $rootScope.$new()});

                // instantiate service
                $injector.get('testServiceNoExt');

                // execute filter
                $filter('testFilterNoExt');

                // Compile a piece of HTML containing the directive
                element = $compile("<test-no-ext></test-no-ext>")($rootScope.$new());

                // Test the template loading
                var $templateCache = $injector.get('$templateCache');
                expect($templateCache.get('/partials/test.html')).toEqual('Test partial content');

                // Test the css loading
                var links = document.getElementsByTagName('link');
                expect(links.length).toBeGreaterThan(0);
                expect(function() {
                    links[links.length - 1].sheet.cssRules;
                }).not.toThrow(); // this only works if a stylesheet has been loaded
                expect(links[links.length - 1].sheet.cssRules).toBeDefined();

                // because debug is set to false, we shouldn't have any log
                $log.assertEmpty();

                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should be able to lazy load a module when the url ends with a hash', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load(lazyLoadUrl + 'testModule4.js#hash').then(function success(res) {
                window.clearInterval(interval);

                // Test the module loading
                expect(angular.module('testModule4')).toBeDefined();

                // Test the module loading
                expect(res).toBeDefined();

                // because debug is set to false, we shouldn't have any log
                $log.assertEmpty();

                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should reject the promise when the jsLoader is unable to load a file', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load(lazyLoadUrl + 'noFile.js').then(function success(res) {
                window.clearInterval(interval);
                throw(new Error('failed!'));
            }, function error(err) {
                expect(err.message).toEqual('Unable to load ' + lazyLoadUrl + 'noFile.js');
                window.clearInterval(interval);
                done();
            });
        });

        // test 17
        it('should reject the promise when the cssLoader is unable to load a file', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load(lazyLoadUrl + 'noFile.css').then(function success(res) {
                window.clearInterval(interval);
                throw(new Error('failed!'));
            }, function error(err) {
                expect(err.message).toEqual('Unable to load ' + lazyLoadUrl + 'noFile.css');
                window.clearInterval(interval);
                done();
            });
        });

        it('should reject the promise when the templateLoader is unable to load a file', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load(lazyLoadUrl + 'noFile.html').then(function success(res) {
                window.clearInterval(interval);
                throw(new Error('failed!'));
            }, function error(err) {
                expect(err.message).toEqual('Unable to load template file "' + lazyLoadUrl + 'noFile.html": NOT FOUND');
                window.clearInterval(interval);
                done();
            });
        });

        it('should throw if you try to load a module with missing dependencies', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load([lazyLoadUrl + 'testModule3.js']).then(function success(res) {
                window.clearInterval(interval);
                throw(new Error('failed!'));
            }, function error(err) {
                expect(err).toBeDefined();
                window.clearInterval(interval);
                done();
            });
        });

        it('should be able to load a module with dependencies', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load([lazyLoadUrl + 'testModule2.js', lazyLoadUrl + 'testModule3.js']).then(function success(res) {
                expect(function() {
                    angular.module('testModule2');
                    angular.module('testModule3');
                }).not.toThrow();
                window.clearInterval(interval);
                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should be able to load a module with params', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load({files: [lazyLoadUrl + 'testModule2.js'], cache: false}).then(function success(res) {
                expect(function() {
                    angular.module('testModule2');
                }).not.toThrow();
                window.clearInterval(interval);
                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should be able to load a component defined as an object', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load(lazyLoadUrl + 'testModule5.js').then(function success(res) {
                expect(function() {
                    angular.module('testModule5');
                }).not.toThrow();

                // execute controller
                expect(function() {
                    $controller('testModule5Ctrl', {$scope: $rootScope.$new()});
                }).not.toThrow();

                window.clearInterval(interval);
                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should be able to load a module with insertBefore', function(done) {
            var interval = triggerDigests();

            $ocLazyLoad.load({files: [lazyLoadUrl + 'testModule6.js'], insertBefore: "title"}).then(function success(res) {
                expect(function() {
                    angular.module('testModule6');
                }).not.toThrow();
                window.clearInterval(interval);
                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should be able to load files with the param serie set to true', function(done) {
            var interval = triggerDigests(),
                params = {files: [lazyLoadUrl + 'testModule5.js', lazyLoadUrl + 'testModule6.js'], serie: true};

            $ocLazyLoad.load(params).then(function success(res) {
                expect(function() {
                    angular.module('testModule5');
                    angular.module('testModule6');
                }).not.toThrow();

               expect(params.files.length).toEqual(2); // it should not change the original params

                window.clearInterval(interval);
                done();
            }, function error(err) {
                window.clearInterval(interval);
                throw err;
            });
        });

        it('should attach and then compile an element', function(done) {
            var fileToLoad = lazyLoadUrl + 'myContainer.js';
            var scope = $rootScope.$new();
            var interval;

            $ocLazyLoad.load(fileToLoad).then(function success(res) {
              scope.fileToLoad = fileToLoad;
                var element = $compile('<div oc-lazy-load="fileToLoad"><my-container></my-container></div>')(scope);
                setTimeout(function() {
                    // Should be able to save an element during compilation and reference
                    // it after the element has been attached to the parent DOM.
                    // IE throws "Invalid calling object" if the element is compiled and then attached.
                    expect(scope.vm.highlanders.length).toBe(1);

                    window.clearInterval(interval);
                    done();
                }, interval * 2);
            });

            interval = triggerDigests();
        });
    });
});