/* interceptor.js (angularjs 1.2.x version) */
angular.module('security.interceptor', ['security.retryQueue'])
.factory('securityInterceptor', ['$injector', 'securityRetryQueue', '$cookieStore', function ($injector, queue, $cookieStore) {
    return {
        response: function(originalResponse)
        {
            return originalResponse;
        },
        responseError: function (originalResponse) {
            var exception;
            if (originalResponse.headers){
                exception = originalResponse.headers('x-eva-api-exception');
            }
            if (originalResponse.status === 401 && (exception === 'token_not_found' || exception === 'token_expired')){
                queue.pushRetryFn(exception, function retryRequest() {
                    return $injector.get('$http')(originalResponse.config);
                });
            }
            return originalResponse;
        }
    };
}])
.config(['$httpProvider', function($httpProvider) {
    $httpProvider.interceptors.push('securityInterceptor');
}]);


/* interceptor.js (angularjs 1.0.8 version) */

angular.module('security.interceptor', ['security.retryQueue'])
.factory('securityInterceptor', ['$injector', 'securityRetryQueue', function($injector, queue) {
    return function(promise) {
        return promise.then(null, function(originalResponse) {
            var exception;
            if(originalResponse.headers) {
                exception = originalResponse.headers('x-eva-api-exception');
            }
            if(originalResponse.status === 401 && (exception === 'token_not_found' || exception === 'token_expired')) {
                promise = queue.pushRetryFn(exception, function retryRequest() {
                    return $injector.get('$http')(originalResponse.config);
                });
            }
            return promise;
        });
    };
}])
.config(['$httpProvider', function($httpProvider) {
    $httpProvider.responseInterceptors.push('securityInterceptor');
}])

/* retryQueue.js */
angular.module('security.retryQueue', [])
.factory('securityRetryQueue', ['$q', '$log', function($q, $log) {
    var retryQueue = [];
    var service = {
        // The security service puts its own handler in here!
        onItemAddedCallbacks: [],
        hasMore: function() {
            console.log('retryQueue.js -> hasMore: ' + retryQueue.length);
            return retryQueue.length > 0;
        },
        push: function(retryItem) {
            retryQueue.push(retryItem);
            // Call all the onItemAdded callbacks
            angular.forEach(service.onItemAddedCallbacks, function(cb) {
                try {
                    console.log('retryQueue.js -> push: ' + retryItem.reason);
                    cb(retryItem);
                } catch(e) {
                    $log.error('securityRetryQueue.push(retryItem): callback threw an error' + e);
                }
            });
        },
        pushRetryFn: function(reason, retryFn) {
            console.log('retryQueue.js -> pushRetryFn called');
            console.log('retryQueue.js -> pushRetryFn reason: ' + reason);
            console.log('retryQueue.js -> pushRetryFn retryFn: ' + retryFn);
            // The reason parameter is optional
            console.log('retryQueue.js -> arguments: ' + arguments);
            console.log('retryQueue.js -> arguments: ' + arguments.length);
            if ( arguments.length === 1) {
                console.log('retryQueue.js -> reason in pushRetryFn: ' + reason);
                retryFn = reason;
                reason = undefined;
            }

            // The deferred object that will be resolved or rejected by calling retry or cancel
            var deferred = $q.defer();
            var retryItem = {
                reason: reason,
                retry: function() {
                    console.log('retryQueue.js -> pushRetryFn with reason ' + reason);
                    // Wrap the result of the retryFn into a promise if it is not already
                    $q.when(retryFn()).then(function(value) {
                        console.log('retryQueue.js -> resolve pushRetryFn with retry and value: ' + value);
                        // If it was successful then resolve our deferred
                        deferred.resolve(value);
                    }, function(value) {
                        // Othewise reject it
                        console.log('retryQueue.js -> reject pushRetryFn with reject and value: ' + value);
                        deferred.reject(value);
                    });
                },
                cancel: function() {
                    // Give up on retrying and reject our deferred
                    deferred.reject();
                }
            };
            console.log('retryQueue.js -> pushRetryFn push retryItem: ' + retryItem.reason);
            service.push(retryItem);
            return deferred.promise;
        },
        retryReason: function() {
            return service.hasMore() && retryQueue[0].reason;
        },
        cancelAll: function() {
            while(service.hasMore()) {
                retryQueue.shift().cancel();
            }
        },
        retryAll: function() {
            while(service.hasMore()) {
                retryQueue.shift().retry();
            }
        }
    };
    return service;
}]);


/* security.js  */
angular.module('security.service', ['session.service', 'security.signin', 'security.retryQueue', 'security.tokens', 'ngCookies'])
.factory('security', ['$location', 'securityRetryQueue', '$q', 'TokenHandler', '$cookieStore', 'Session', 'i18nNotifications', 'User', function($location, queue, $q, TokenHandler, $cookieStore, Session, i18nNotifications, User) {
    function redirect(url) {
        url = url || '/';
        $location.path(url);
    }

    var skipRequests = false;

    // Register a handler for when an item is added to the retry queue
    queue.onItemAddedCallbacks.push(function(retryItem) {
        if ( queue.hasMore() ) {
            if(skipRequests) {return;}
            // make sure only one token is created by skiping subsequant authentication requests
            console.log('security.js -> set skipRequests to true');
            skipRequests = true;
            if(retryItem.reason === 'token_expired') {
                service.refreshToken().then(function(result) {
                    if(result) {
                        var currentToken = TokenHandler.get();
                        console.log('security.js -> currentToken before queue.retryAll() call:' + currentToken);
                        console.log('security.js ->  result before queue.retryAll() call:' + currentToken);
                        queue.retryAll();
                    }
                    // user has to authorize with credentials
                    else
                    {
                        service.signout();
                    }
                    skipRequests = false;
                    console.log('security.js -> set skipRequests to false');
                });
            } else {
                // user has to authorize with credentials
                skipRequests = false;
                console.log('security.js -> set skipRequests to false before signout');
                service.signout();
            }
        }
    });

    var service = {
        // get a new valid token using the refresh token
        refreshToken: function() {
            console.log('security.js -> refreshToken called, d created');
            var d = $q.defer();
            var token = TokenHandler.getRefreshToken();
            // cannot refresh token if not found on the client
            if(!token) {
                console.log('security.js -> token not found on a client');
                d.resolve(false);
            }

            console.log('security.js -> token found on a client: ' + token);
            var session = new Session({
                refreshToken: token
            });

            console.log('security.js -> calling session.tokenRefresh');
            session.tokenRefresh(function(result) {
                if(result) {
                    console.log('security.js -> result OK, d.resolve(true), setting token with a accessToken: ' + result.accessToken + ' and refresh token: ' + result.refreshToken);
                    d.resolve(true);
                    TokenHandler.set(result);
                } else {
                    console.log('security.js -> result NOT ok, d.resolve(false)');
                    d.resolve(false);
                }
            });

            console.log('security.js -> returning d.promise');
            return d.promise;
        }
    };

    return service;
}]);

/* httpHeaders.js */
angular.module('services.httpHeaders', [])
.factory('HttpHeaders', ['$injector', function($injector) {
    var http = $injector.get('$http');
    var service = {
        initHeaders: function() {
        },
        // set session token used to authorize the user against the api
        setAuthorizationToken: function(token) {
            console.log('httpHeaders.js -> setting authorization token: ' + token);
            http.defaults.headers.common['Authorization'] = 'Bearer ' + token;
        },

        clearAuthorizationHeader: function()  {
            http.defaults.headers.common['Authorization'] = null;
        }
    };
    return service;
}]);

/* tokenHandler.js */
angular.module('security.tokens', ['ngResource'])
.factory('TokenHandler', ['HttpHeaders', '$cookieStore', function(HttpHeaders, $cookieStore) {
    var token = null;

    function initToken() {
        if(!token) {
            token = $cookieStore.get('authorization-token');
        }
    }

    var service = {
        // set a new token and save to cookies
        set: function(newToken) {
            token = newToken;
            $cookieStore.put('authorization-token', token);
            HttpHeaders.setAuthorizationToken(token.accessToken);
        },

        // try to init the token from cookies
        init: function() {
            initToken();
            if(!token) {return;}
            HttpHeaders.setAuthorizationToken(token.accessToken);
        },

        // clear token and remove it from cookies
        clear: function() {
            $cookieStore.remove('authorization-token');
            token = {};
            HttpHeaders.clearAuthorizationHeader();
        },

        // return currently active token
        get: function() {
            initToken();
            if(token) {return token.accessToken;}
            else {return null;}
        },

        // return the refresth token
        getRefreshToken: function() {
            initToken();
            if(token) {
                console.log('tokenHandler.js -> getRefreshToken: ' + token);
                return token.refreshToken;
            }
            else {
                console.log('token was not found, returning null');
                return null;
            }
        }
    };
    service.init();
    return service;
}]);