(function () {
    //'use strict'; allow default mode here, to be able to capture more detail

    angular.module('mgApp')
        .config(ExceptionHandlerDecorator);

    ExceptionHandlerDecorator.$inject = ['$provide'];
    function ExceptionHandlerDecorator($provide) {
        // gör det här snyggare...
        $provide.decorator(
        '$exceptionHandler', ['$delegate', '$injector', function ($delegate, $injector) {
            var apiUrl = '/api/logerror';
            return function (exception, cause) {
                // original implementation
                $delegate(exception, cause);

                // avoid sending a bunch of the same error
                var cache = {};
                var out = FormatMsg(exception);
                if (cache.hasOwnProperty(out) == false) {
                    try {
                        // service locator pattern...
                        var $http = $injector.get('$http');
                        $http.post(
                            apiUrl,
                            {
                                message: out
                            });
                    } catch (e) {
                    }

                    cache[out] = true;
                }
            };
        }]);

        function FormatMsg(ex, stack) {
            if (ex == null) return '';
            var url = ex.fileName != null ? ex.fileName : document.location;
            if (stack == null && ex.stack != null) stack = ex.stack;

            // format output
            var out = ex.message != null ? ex.name + ": " + ex.message : ex;
            out += ": at document path '" + url + "'.";
            if (stack != null) {
                try {
                    // not sure about the stack property, best be careful...
                    out += "\n  at " + stack;
                } catch (e) {
                }
            }

            return out;
        }
    }
})();

(function () {
    'use strict';

    angular.module('mgApp')
        .factory('httpRequestInterceptor', HttpRequestInterceptor);

    HttpRequestInterceptor.$inject = ['$q', 'Toaster'];
    function HttpRequestInterceptor($q, toaster) {
        return {
            responseError: function (response) {
                if (response.status === 500) {
                    // internal server error
                    toaster.error(response.statusText);
                } else {
                    // validation error
                    var error = ErrorParser(response);
                    var html;
                    if (error.modelState && error.modelState.length) {
                        html = ModelStateErrors(error.modelState);
                    } else if (error.exceptionMessage) {
                        html = ModelStateErrors('Exception: ' + error.exceptionMessage);
                    } else if (error.message) {
                        html = ModelStateErrors('Error: ' + error.message);
                    } else if (response && response.status) {
                        html = ModelStateErrors('Internal Server Error: ' + response.status);
                    } else {
                        html = ModelStateErrors('Unknown error occurred');
                    }

                    toaster.warning('Warning', html);
                }

                return $q.reject(response);
            }
        };
    }

    angular.module('mgApp')
        .config(Config);

    Config.$inject = ['$httpProvider'];
    function Config($httpProvider) {
        // enable when the rest is working...
        //$httpProvider.interceptors.push('httpRequestInterceptor');
    }

    function ErrorParser(response) {
        var data = {
            modelState: [],
            message: (response || {}).message
        };

        if (!response) return data;

        if (response.data) {
            angular.extend(data, {
                exceptionMessage: response.data.exceptionMessage,
                exceptionType: response.data.exceptionType,
                stackTrace: response.data.stackTrace,
                message: response.data.message
            });
        }

        // convert model state into something usable
        if (response.modelState || (response.data && (response.modelState = response.data.modelState))) {
            var modelState = response.modelState;
            for (var s in modelState) {
                var state = {
                    field: s.replace('criteria.', ''),
                    reasons: modelState[s].join(', ')
                };
                data.modelState.push(state);
            }
        }

        return data;
    }

    function ModelStateErrors(modelState) {
        var dl = '<dl>';
        for (var k in modelState) {
            dl += '<dt>' + modelState[k].field + '</dt>';
            dl += '<dd>' + modelState[k].reasons + '</dd>';
        }

        return dl;
    }
})();

(function () {
    'use strict';

    angular.module('mgApp')
        .factory('Toaster', ToasterProvider);

    ToasterProvider.$inject = ['toaster'];
    function ToasterProvider(toaster) {
        return {
            success: function (title, body) {
                toaster.pop('success', title, body);
            },
            warning: function (title, body) {
                toaster.pop('warning', title, body, 10000, 'trustedHtml');
            },
            error: function (title, body) {
                // sticky
                toaster.pop('error', title, body, 0);
            },
            clear: function () {
                toaster.clear();
            }
        };
    }
})();