angular.module('fbMocks')
    .factory('commonService', ['$q', function (
        $q: ng.IQService
        ): fb.IMockCommonService {
        var ignoredKeys: string[] = ['root', '$promise', '$resolved', '$rootName', '$dirty', '$lastModification', 'isArray',
        '$tempPK', '$$hashKey', 'exceptionFromAPI', 'ignoredKeys', 'invalidField', 'mergeConflicts', 'enqueueable'];
        
        var mockBase = new fb.MockBase($q);

        var mockBase: fb.MockBase = new fb.MockBase($q);
        var resolve = function (type: fb.RequestType, identifier: string, returnValue: any): void {
            mockBase.resolve(mockBase.requestIdentifier(type, identifier), returnValue);
        };
        var reject = function (type: fb.RequestType, identifier: string, returnValue: any): void {
            mockBase.reject(mockBase.requestIdentifier(type, identifier), returnValue);
        };
        var getPendingRequests = function (): string[] {
            return mockBase.getPendingRequests();
        };
        var setDPI = function (pixels: number) {
            return DPI;
        }
       var getDPI = function (): number {
            return DPI;
        }
        var DPI = 92;
        var dimensions = {
            inToPt: function (inches: number): number
            { return inches * 72; },
            ptToIn: function (pt: number): number
            { return pt / 72; },
            inToPx: function (inches: number): number
            { return inches * DPI; },
            ptToPx: function (pt: number): number
            { return (pt / 72) * DPI },
            pxToIn: function (pixels: number): number
            { return pixels / DPI; },
            pxToPt: function (pixels: number): number
            { return (pixels / DPI) * 72 },
            pxToMm: function (pixels: number): number
            { return dimensions.pxToIn(pixels) * 25.4; },
            mmToPx: function (millimeters: number): number
            { return dimensions.inToPx(millimeters / 25.4) }
        };
        var absolutePositioning = {
            offsetTop: function (element: ng.IAugmentedJQuery): number {
                return 0;
            },
            offsetLeft: function (element: ng.IAugmentedJQuery): number {
                return 0;
            }
        }
        var angularFunctions = {
            safeApply: function (scope: ng.IScope, fn: any) { fn(); }
        }
        var security = {
            splitNonSecureTags: function (str: string, allowedTagsRegexStrings: string[]): { content: string; secure: boolean; }[] {
                return [
                    { "content": "", "secure": false },
                    { "content": "<fb-dokument-field ng-model=\"ngModel\" page-split=\"pageSplit\" style-object=\"styleObject\" granska=\"granska\"statiskt-vaerde=\"att fastigheten på tillträdesdagen är intecknad till: \" dokument-vaerde=\"dokumentVaerden.pgInteckningStatusEditerbar1\"></fb-dokument-field>", "secure": true },
                    { "content": "", "secure": false },
                    { "content": "<fb-dokument-field ng-model=\"ngModel\" page-split=\"pageSplit\" style-object=\"styleObject\" granska=\"granska\"dokument-vaerde=\"dokumentVaerden.pgInteckningsStatus\"></fb-dokument-field>", "secure": true },
                    { "content": "", "secure": false },
                    { "content": "<fb-dokument-field ng-model=\"ngModel\" page-split=\"pageSplit\" style-object=\"styleObject\" granska=\"granska\"statiskt-vaerde=\" kronor\" dokument-vaerde=\"dokumentVaerden.pgInteckningStatusEditerbar2\"></fb-dokument-field>", "secure": true }
                ];
            }
        }
        var changeTrack = {
            isChangeTrackObject: function (obj: any) {return true },

            createChangeTrackObject: function (objectData: any, rootObject?: any, rootName?: string): any {
                var returnObject;

                var getRootObject = function () {
                    if (rootObject) {
                        return rootObject;
                    } else {
                        return returnObject;
                    }
                };
                var getRootName = function (): string {
                    if (rootName) {
                        return rootName;
                    } else {
                        return '';
                    }
                };

                var recurse = function (obj, data, propertyString: string) {
                    // vill ha kvar undefined-checken för säkerhets skull, men borde inte gå att nå
                    /* istanbul ignore if */
                    if (typeof data === 'undefined' || data === null) {
                        return;
                    } else if (data instanceof Array) {
                        // data är en array
                        for (var k: number = 0; k < data.length; k++) {
                            if (typeof data[k] === 'object') {
                                var tmpObject;
                                if (data[k] instanceof Array) {
                                    tmpObject = [];
                                } else {
                                    tmpObject = {};
                                }
                                recurse(tmpObject, data[k], propertyString + '[]');
                                obj[k] = tmpObject;
                            }
                            else {
                                obj[k] = new fb.ChangeTrack(data[k], getRootObject(), propertyString + '[]');
                            }
                        }
                        return returnObject;
                    }
                    // data är ett objekt

                    var keys = Object.keys(data);
                    for (var i: number = 0; i < keys.length; i++) {
                        if (keys[i] === 'root') {
                            continue;
                        }
                        if (typeof data[keys[i]] === 'object') {
                            // propertien var klassad som object
                            if (data[keys[i]] instanceof Array) {
                                // Propertien är en lista, kör rekursivt över alla objekt i listan
                                obj[keys[i]] = [];
                                recurse(obj[keys[i]], data[keys[i]], propertyString + '.' + keys[i]);
                            } else if (data[keys[i]] === null) {
                                // propertien var satt till null
                                obj[keys[i]] = new fb.ChangeTrack(data[keys[i]], getRootObject(), propertyString + '.' + keys[i]);
                            } else {
                                // propertien är ett icke null objekt
                                obj[keys[i]] = {};
                                recurse(obj[keys[i]], data[keys[i]], propertyString + '.' + keys[i]);
                            }
                        } else if (typeof data[keys[i]] === 'function') {
                            // Gör ingenting om propertyn är en funktion
                        } else if (typeof data[keys[i]] === 'undefined') {
                            obj[keys[i]] = undefined;
                        } else {
                            // propertien var inte ett objekt utan innehöll ett datavärde
                            obj[keys[i]] = new fb.ChangeTrack(data[keys[i]], getRootObject(), propertyString + '.' + keys[i]);
                        }
                    }
                }; // END Recurse


                if (typeof objectData === 'undefined') {
                    return objectData;
                } else if (objectData === null) {
                    returnObject = new fb.ChangeTrack(objectData, getRootObject(), getRootName());
                } else if (objectData instanceof Array) {
                    returnObject = [];
                    recurse(returnObject, objectData, getRootName());
                } else {
                    returnObject = {};
                    recurse(returnObject, objectData, getRootName());
                }
                return returnObject;
            },
            fromChangeTrackObject: function (data: any, isArray: boolean) {
                return {};
            }
        };

        var screenDimensions: fb.ICommonServiceScreenDimensions = {
            window: {
                innerWidth: 1920,
                innerHeight: 1080
            },
            topNav: {
                width: 1920,
                height: 50
            },
            leftNav: {
                width: 150,
                height: 1030
            },
            mainContent: {
                actual: {
                    width: 1770,
                    height: 1030
                },
                noScroll: {
                    width: 1770,
                    height: 1030
                }
            }
        };
        var getScreenDimensions = function (): fb.ICommonServiceScreenDimensions {
            return screenDimensions;
        }
        var getResizingCounter = function (): number {
            return 1;
        }
        var deepFind = function deepFind(obj: any, path: string, putValue?: any) {
            var paths = path.split('.');
            var current = obj;
            var i;

            for (i = 0; i < paths.length; ++i && i < 10) {
                if (typeof current[paths[i]] === 'undefined') {
                    return undefined;
                } else {
                    current = current[paths[i]];
                }
            }
            if (angular.isDefined(putValue)) {
                current = putValue;
            }
            return current;
        }

        var naturalSort = function (a: string, b: string) {
            for (var x = 0, aa, bb; (aa = a[x]) && (bb = b[x]); x++) {
                if (aa !== bb) {
                    var c = Number(aa), d = Number(bb);
                    if (c && d) {
                        var cc = Number(a.substring(x).match(/\d+/));
                        var dd = Number(b.substring(x).match(/\d+/));
                        return cc - dd;
                    }
                    return aa > bb ? 1 : -1;
                }
            }
            return a.length - b.length;
        }

        // Funktion för att hitta största gemensamma delaren för 2 tal
        var gcdHelper = function (a: number, b: number) {
            if (!angular.isNumber(a) || !angular.isNumber(b)
                || !isFinite(a) || !isFinite(b)) {
                return null;
            }
            if (a === 0) {
                return b;
            }
            if (b === 0) {
                return a;
            }
            var r = a % b;
            return gcdHelper(b, r);
        };

        var sumFrac = function (numbers: { taeljare: number; naemnare: number }[]): { taeljare: number; naemnare: number } {
            if (!numbers || !numbers.length) { return null; }
            var naemnare = numbers[0].naemnare;
            var sumTaljare = numbers[0].taeljare;
            for (var i = 1; i < numbers.length; i++) {
                var gcd = gcdHelper(numbers[i].naemnare, naemnare);
                sumTaljare = numbers[i].taeljare * naemnare / gcd + sumTaljare * numbers[i].naemnare / gcd;
                naemnare = naemnare * numbers[i].naemnare / gcd;
            }
            return { taeljare: sumTaljare, naemnare: naemnare };
        };
    

        var strings = {
            capitalizeFirstLetter: function (val: string): string {
                return 'CapatilizeFirstLetter';
            }
        }

        var date = {
            validDate: function (date: string): boolean {
                return false;

            },
            validTime: function (time: string): boolean {
                return false;
            },
            compareDateStrings: function (dateA: string, dateB: string): number {
                return 123
            },
            splitDate: function (date: string): { year: number; month: number; day: number; hour: number; minute: number; second: number } {
                return {
                    year: 2014,
                    month: 3,
                    day: 20,
                    hour: 20,
                    minute: 30,
                    second: 25,
                };
            },
            datePart: function (dateTimeString: string): string {
                var tIndex = dateTimeString.indexOf('T');

                return tIndex >= 0
                    ? dateTimeString.substring(0, tIndex)
                    : dateTimeString;
            },
            timePart: function (dateTimeString: string): string {
                var tIndex = dateTimeString.indexOf('T');

                if (tIndex === -1 &&
                    (moment(dateTimeString, 'HH:mm:ss', true).isValid() ||
                    moment(dateTimeString, 'HH:mm:ss.00', true).isValid())) {

                    return dateTimeString;
                }

                return tIndex >= 0
                    ? dateTimeString.substring(tIndex + 1)
                    : '';
            },
            clearTime: function (dateTimeString: string): string {
                var tIndex = dateTimeString.indexOf('T');

                if (tIndex !== 1) {
                    return dateTimeString.substring(0, tIndex + 1) + '00:00:00.00'; // WebAPI def. av ingen tidsangivelse
                }

                return dateTimeString;
            },
            setDatePart: function (dateTimeString: string, datePartString: string): string {
                var hasDateAndTime = moment(dateTimeString, 'YYYY-MM-DDTHH:mm:ss', true).isValid();
                var hasDateAndNoTime = moment(dateTimeString, 'YYYY-MM-DDTHH:mm:ss.00', true).isValid();
                var hasTimeOnly = moment(dateTimeString, 'HH:mm:ss', true).isValid();
                var hasNoTimeOnly = moment(dateTimeString, 'HH:mm:ss.00', true).isValid();

                datePartString = date.datePart(datePartString);

                if (hasDateAndTime || hasDateAndNoTime) {
                    return (datePartString !== '' ? (datePartString + 'T') : '') + date.timePart(dateTimeString);
                }
                else if (hasTimeOnly || hasNoTimeOnly) {
                    return (datePartString !== '' ? (datePartString + 'T') : '') + dateTimeString;
                }

                return datePartString + 'T00:00:00.00'; // Ingen giltig tid, skriv över allt med datum-delen, appenda med c# notime
            },
            setTimePart: function (dateTimeString: string, timePartString: string): string {
                if (timePartString === '') {
                    timePartString = '00:00:00.00';
                }

                var hasDateAndTime = moment(dateTimeString, 'YYYY-MM-DDTHH:mm:ss', true).isValid();
                var hasDateAndNoTime = moment(dateTimeString, 'YYYY-MM-DDTHH:mm:ss.00', true).isValid();
                var hasDateOnly = moment(dateTimeString, 'YYYY-MM-DD', true).isValid();

                if (hasDateAndTime || hasDateAndNoTime) {
                    return date.datePart(dateTimeString) + 'T' + timePartString;
                }
                else if (hasDateOnly) {
                    return dateTimeString + 'T' + timePartString;
                }

                return timePartString; // Inget giltigt datum, skriv över allt med tids-delen
            }
        };
        var merge = function (a, b, c, d) { return a; };

        var maeklarObjektTyper = {
            aerSmaahus: function (ObjektTypId: number): boolean {
                return true;
            },
            aerBostadsraett: function (ObjektTypId: number): boolean {
                return true;
            },
            aerByggnadArrenderadMark: function (ObjektTypId: number): boolean {
                return true;
            },
            aerHyresraett: function (ObjektTypId: number): boolean {
                return true;
            },
            aerKomersiellt: function (ObjektTypId: number): boolean {
                return true;
            },
            aerLokal: function (ObjektTypId: number): boolean {
                return true;
            },
            aerProjekt: function (ObjektTypId: number): boolean {
                return true;
            },
            aerBestaand: function (ObjektTypId: number): boolean {
                return true;
            },
            aerGaard: function (ObjektTypId: number): boolean {
                return true;
            },
            aerAegarlgh: function (ObjektTypId: number): boolean {
                return true;
            },
            aerOevrigt: function (ObjektTypId: number): boolean {
                return true;
            },
            aerUtland: function (ObjektTypId: number): boolean { 
                return true;
            }
        };
        var debounce = function(func:any, wait:number, immediate?:boolean){
            return function(){
                func();
            };
        }
        var throttle = function(func:any, wait:number, context?:any){
            return function(){
                func();
            };
        }
    
        var getPageRange = function (totalNumberOfPages: number, currentPage: number, gap: number) {
            var returnArray = [];          
            return returnArray;
        }

        var filterMedarbetareList = function (medarbetareArray: fb.List<fb.Medarbetare>, rollArray: number[]) {
            var returnArray = [];
            return returnArray;
        };
    
        var getKontaktTypStr = function (jurPersonTyp: number, fysPersonTyp: number, aerAvliden: boolean) :string {
            return '';
        };

        var getDeferred = function () {
            var deferred = $q.defer();
            return {
                $promise: deferred.promise,
                $resolved: false
            };
        };
        var getPropValue = function (propString: string, option: Object): any {
            var properties = propString.split('.');
            var value = option;

            for (var i = 0; i < properties.length; ++i) {
                if (_.isUndefined(value)) {
                    return;
                }
                value = value[properties[i]];
            }

            return value;
        }
        var getKontorsValutaSuffix = function () {
            return 'kr';
        };
        
        var getKontorsValutaLong = function (singular?: boolean) {
            return 'kronor';
        };

        var valideraSidval = function (sidVal: string) {
            return false;
        };
        var juridiskPerson = {
            getJuridiskIcon : function (jurPersonTyp: number) {
                return null;
            },
            getJuridiskInitials : function (jurPersonTyp: number, text: string) {
                return '';
            }
        }
        var kundKategori = {
            getKundKategoriAltText: function (kundKategori: number): string {
                return "";
            }
        }
        var resourceEvents = {
            onMergeCompleted: function (scope: ng.IScope, id: string, fun: () => void) {
                return;
            },
            mergeCompleted: function (id: string) {
                return;
            }
        };
        return {
            ignoredKeys: ignoredKeys,
            resolve: resolve,
            reject: reject,
            util: {
                deepFind: deepFind,
                naturalSort: naturalSort
            },
            math: {
                sumFrac: sumFrac
            },
            getPendingRequests: getPendingRequests,
            setDPI: setDPI,
            getDPI: getDPI,
            dimensions: dimensions,
            absolutePositioning: absolutePositioning,
            angularFunctions: angularFunctions,
            security: security,
            changeTrack: changeTrack,
            getScreenDimensions: getScreenDimensions,
            getResizingCounter: getResizingCounter,
            date: date,
            merge: merge,
            maeklarObjektTyper: maeklarObjektTyper,
            debounce: debounce,
            throttle: throttle,
            filterMedarbetareList: filterMedarbetareList,
            getKontaktTypStr: getKontaktTypStr,
            getPageRange: getPageRange,
            strings: strings,
            getDeferred: getDeferred,
            getPropValue: getPropValue,
            getKontorsValutaSuffix: getKontorsValutaSuffix,
            getKontorsValutaLong: getKontorsValutaLong,
            valideraSidval: valideraSidval,
            JuridiskPerson: juridiskPerson,
            KundKategori: {
                getKundKategoriAltText : kundKategori.getKundKategoriAltText
            },
            Events: {
                Resources: resourceEvents
            },
            gcdHelper: gcdHelper,
        }
    }]);