(function () {
    'use strict';

    angular
        .module('app')
        .controller('BaseTransactionController', BaseTransactionController);

    BaseTransactionController.$inject = ['$translate', '$scope', '$filter', '$http', '$q', '$timeout', '$uibModal', '$location', 'uiGridConstants', 'TransactionService', 'MemoryStorageService', 'SettingService', 'Notification', 'UtilService', 'CustomerService'];
    function BaseTransactionController($translate, $scope, $filter, $http, $q, $timeout, $uibModal, $location, uiGridConstants, transactionService, MemoryStorageService, settingService, Notification, UtilService, CustomerService) {
        var vm = this;
        var filter = vm.filter = {};
        var selectedRows = vm.selectedRows = {};
        var responsesOfTransactions = [];

        var filterStartDateUTC = null;
        var filterEndDateUTC = null;

        var filterPromise;
        var filterCanceller;
        // The default waiting time before starting search
        var defaultTimeout = 1500;

        selectedRows.data = [];
        vm.currencies = [];
        vm.statusList = $filter('status')('transactions');
        vm.filter.statusesUI = UtilService.listOfStatus();
        vm.datePicker = {};
        vm.datePicker.date = {startDate: null, endDate: null};
        vm.processSinglePartialTransaction = processSinglePartialTransaction;
        vm.processSelectedTransactions = processSelectedTransactions;
        vm.processSingleTransaction = processSingleTransaction;
        vm.openConfirmationOverlay = openConfirmationOverlay;
        vm.entriesChanged = entriesChanged;
        vm.isSelectable = isSelectable;
        vm.filterSearch = filterSearch;
        vm.pageChanged = pageChanged;
        vm.selectRow = selectRow;
        vm.clearFilters = clearFilters;
        vm.isOrderIdEnabled = isOrderIdEnabled;
        vm.isAmountBtwRequired = isAmountBtwRequired;
        vm.pageSize = 10;
        vm.totalItems = 0; //Total number of items in all pages.
        vm.maxSize = 5; //Limit number for pagination size.
        vm.currentPage = 1;
        vm.options = {
            sizes: [10, 25, 50, 100]
        };
        vm.txType = "";
        vm.showSpinner = false;
        vm.silentLoading = false;
        vm.disableWhenIsMultiSelect = false;
        vm.filter.amountValues = [];
        vm.sorting = {};
        vm.createRequest = createRequest;
        vm.noResults = noResults;

        // Cancel the last request when leaving controller
        $scope.$on('$destroy', function () {
            if(angular.isDefined(filterCanceller)) {
                filterCanceller.resolve();
            }
        });

        function noResults() {
            noResults.self = noResults;

            noResults.text = function () {
                return $translate.instant('select2.noResults.message');
            };

            return noResults;
        }
        $scope.isDollar = function (currency) {
            return currency === 'USD';
        }

        $scope.cardTypeMapper = function(cardType, paysolId, cardTokenizerProviderId) {
            return UtilService.cardTypeMapper(cardType, paysolId, cardTokenizerProviderId);
        }

        function isQuickSaleEnabled() {
            return CustomerService.isQuickSaleEnabled()
        }

        function isExpiredStatusEnabled() {
            return settingService.isExpiredStatusEnabled();
        }

        function isUnlinkedRefundsEnabled() {
            return CustomerService.isUnlinkedRefundsEnabled()
        }

        /**
         * DatePicker display configuration
         */
        vm.datePicker.toggle = function () {
            vm.datePicker.opened = !vm.datePicker.opened;
        };

        /**
         * DatePicker configuration
         */
        vm.format = MemoryStorageService.getUserSettings().dateFormatMomentJs;

        vm.datePicker.options = {
            locale:{
                format: vm.format
            },
            eventHandlers: {
                'hide.daterangepicker': function (ev, picker) {
                    vm.datePicker.opened = false;
                }
            },
            showDropdowns: true
        };

        function clearFilters() {
            vm.datePicker.date = {startDate: null, endDate: null};
            vm.filter.amountValues = [];
            vm.filter.orderId = undefined;
            vm.filter.customerName = undefined;
            vm.filter.customerId = undefined;
            vm.currency = undefined;
            vm.filter.listOfStatusCodes = undefined;
            MemoryStorageService.setSearchFields({});
            vm.filterSearch();
            filterStartDateUTC = null;
            filterEndDateUTC = null;
        }

        function isOrderIdEnabled() {
            return !(vm.filter.customerId || vm.filter.mobileNumber || vm.datePicker.date.startDate !== null || vm.filter.customerName || vm.checkAmountValues() || vm.checkCurrency() || vm.checkStatus());
        }

        function isAmountBtwRequired(amountIndex) {
            var edited = amountIndex;
            var another = amountIndex == 0 ? 1 : 0;
            return (vm.filter.amountValues[edited] == null || vm.filter.amountValues[edited] == '' || vm.filter.amountValues[another] < vm.filter.amountValues[edited]) && vm.checkType('btw') && !UtilService.isEmpty(vm.filter.amountValues[another]);
        }

        vm.checkStatus = checkStatus;
        function checkStatus() {
            return hasItems(vm.filter.listOfStatusCodes);
        }

        vm.checkAmountValues = checkAmountValues;
        function checkAmountValues() {
            return hasItems(vm.filter.amountValues) && !vm.filter.amountValues.every(hasNoValue);
        }

        vm.checkCurrency = checkCurrency;
        function checkCurrency() {
            return hasItems(vm.currency);
        }

        function hasItems(array) {
            return !(
                typeof array === 'undefined' ||
                array === null ||
                array.length === 0
                );
        }

        function hasNoValue(item, index, array) {
            return item === null || item === "";
        }

        function getCellClass(grid, row, col, rowRenderIndex, colRenderIndex) {
            return !vm.isRowActionable(row.entity) ? 'non-actionable' : '';
        }

        function isSelectable(row) {
            return !!vm.isRowActionable(row.entity);
        }

        function selectRow() {
            selectedRows.data.push(vm.gridApi.selection.getSelectedRows());
        }

        var formattedDate = MemoryStorageService.getUserSettings().dateTimeFormat;
        var splitFormattedDate = formattedDate != null && formattedDate != "null" ? formattedDate.split(" ") : ["yyyy-MM-dd", "HH:mm:ss"];
        var dateWithTime = splitFormattedDate[0] + " " + splitFormattedDate[1];

        vm.gridOptions = {
            enablePaginationControls: false,
            enableSorting: true,
            useExternalSorting: true,
            showGridFooter: false,
            enableRowSelection: false,
            enableSelectAll: true,
            enableColumnResizing: true,
            enableVerticalScrollbar: 1,
            enableHorizontalScrollbar: 0,
            selectionRowHeaderWidth: 35,
            rowHeight: 40,
            enableFullRowSelection: true,
            isRowSelectable: isSelectable,
            enableGridMenu: true,
            gridMenuTitleFilter: function(title) {
                return $translate.instant(title);
            },
            columnDefs: [
                {
                    name: 'ACTION',
                    displayName: 'grid.header.action',
                    headerCellFilter: 'translate',
                    cellClass: getCellClass,
                    enableSorting: false,
                    width: 85,
                    cellTemplate: '<div class="ui-grid-vcenter"><button ' +
                        'ng-attr-id="{{ \'b-grid-action-\' + rowRenderIndex }}"  ng-class="vm.disableWhenIsMultiSelect ? btn : disabled" ' +
                        'ng-disabled="(row.isSelected && grid.appScope.vm.selectedRowsCount() > 1) || !grid.appScope.vm.isRowActionable(row.entity)" ' +
                        'ng-click="grid.appScope.vm.trxClickHandler(row.entity)" ' +
                        'type="button" ' +
                        'class="btn btn-xs btn-success">{{grid.appScope.vm.getActionButtonText(row.entity)[0]}}' +
                        '</button></div>'
                },
                {
                    name: 'ACTION2',
                    displayName: 'grid.header.action',
                    headerCellFilter: 'translate',
                    cellClass: getCellClass,
                    enableSorting: false,
                    width: 85,
                    cellTemplate: '<div class="ui-grid-vcenter"><button ' +
                        'ng-attr-id="{{ \'b-grid-action2-\' + rowRenderIndex }}" ng-class="vm.disableWhenIsMultiSelect ? btn : disabled" ' +
                        'ng-disabled="(row.isSelected && grid.appScope.vm.selectedRowsCount() > 1) || !grid.appScope.vm.isRowActionable(row.entity, true)" ' +
                        'ng-click="grid.appScope.vm.partialTrxClickHandler(row.entity)" ' +
                        'type="button" ' +
                        'class="btn-primary btn btn-xs">{{grid.appScope.vm.getActionButtonText(row.entity)[1]}}' +
                        '</button></div>'
                },
                {name: 'TRX_CREATED_TIMESTAMP', displayName: "grid.header.authAttempt", headerCellFilter: 'translate', cellClass: 'auth-date ' + getCellClass, cellFilter: 'momentFormatDateTime', minWidth: 130},
                {name: 'CUSTOMER_ID', displayName: 'grid.header.customerId', headerCellFilter: 'translate', cellClass: getCellClass, minWidth: 150},
                {name: 'TRX_ID_BY_MERCHANT', displayName: 'grid.header.orderId', headerCellFilter: 'translate', cellClass: 'order-id ' + getCellClass, minWidth: 150},
                {name: 'CUSTOMER_NAME', displayName: 'grid.header.customerName', headerCellFilter: 'translate', cellClass: 'customer-name ' + getCellClass, minWidth: 150,
                    cellTemplate:
                        '<div class="ui-grid-cell-contents"><customer-name name="row.entity[col.field]"></customer-name></div>'
                },
                {name: 'CUSTOMER_EMAIL', displayName: 'grid.header.customerEmail', headerCellFilter: 'translate', cellClass: 'customer-email ' + getCellClass, minWidth: 145, enableSorting: true},
                {
                    name: 'CARD_TYPE', displayName: 'grid.header.cardType', headerCellFilter: 'translate', cellClass: 'card-type ' + getCellClass, width: 85, enableSorting: true,
                    cellTemplate:
                            '<div class="ui-grid-vcenter" uib-tooltip="{{row.entity[\'CTP_SOLUTION_NAME\'] || row.entity[col.field] || row.entity.PAYMENT_SOLUTION_DISPLAY}}" tooltip-placement="bottom">' +
                            '<i class="{{grid.appScope.cardTypeMapper(row.entity[col.field], row.entity[\'PAYMENT_SOLUTION_ID\'], row.entity[\'CTP_ID\'])}}"></i>' +
                            '</div>'
                },
                {name: 'PAN_TOKEN', displayName: 'grid.header.accPan', headerCellFilter: 'translate', cellClass: getCellClass, minWidth: 110},
                {
                    name: 'AMOUNT', displayName: 'grid.header.amount', headerCellFilter: 'translate', cellClass: getCellClass, type: 'number', width: 90,
                    cellTemplate: '<div class="ui-grid-vright"><span ng-if="grid.appScope.isDollar(row.entity.TRX_CURRENCY)"><currency-symbol iso="row.entity.TRX_CURRENCY"></currency-symbol>&nbsp;</span><span class="amount">{{row.entity[col.field] | number: 2}}</span>&nbsp;<span ng-if="!grid.appScope.isDollar(row.entity.TRX_CURRENCY)"><currency-symbol iso="row.entity.TRX_CURRENCY"></currency-symbol></span></div>'
                },
                {
                    name: 'CONVERTED_AMOUNT', displayName: 'grid.header.convertedAmount', headerCellFilter: 'translate', cellClass: getCellClass, type: 'number', width: 135,
                    cellTemplate: '<div class="ui-grid-vright"><span ng-if="grid.appScope.isDollar(row.entity.CONVERTED_CURRENCY)"><currency-symbol iso="row.entity.CONVERTED_CURRENCY"></currency-symbol>&nbsp;</span><span class="amount">{{row.entity[col.field] | number: 2}}</span>&nbsp;<span ng-if="!grid.appScope.isDollar(row.entity.CONVERTED_CURRENCY)"><currency-symbol iso="row.entity.CONVERTED_CURRENCY"></currency-symbol></span></div>'
                },
                {
                    name: 'CONVERSION_RATE', displayName: 'grid.header.conversionRate', headerCellFilter: 'translate', cellClass: getCellClass, type: 'number', width: 120,
                    cellTemplate: '<div class="ui-grid-vright"><span class="amount">{{row.entity[col.field] | number: 5 }}</span></div>'
                },
                {
                    name: 'AMOUNT_REFUNDABLE', displayName: 'grid.header.refundable', headerCellFilter: 'translate', cellClass: 'amount-refundable ' + getCellClass, type: 'number', width: 120,
                    cellTemplate: '<div class="ui-grid-vright"><currency-symbol iso="row.entity.TRX_CURRENCY"></currency-symbol>&nbsp;{{row.entity[col.field] | number: 2}}</div>'
                },
                {
                    name: 'IS_3DS', displayName: 'grid.header.threeDSec', headerCellFilter: 'translate', cellClass: getCellClass, width: 60, enableSorting: true,
                    cellTemplate:
                        '<div class="ui-grid-vcenter" uib-tooltip="{{row.entity | threeDSecureStyle : \'label\' | translate}}" tooltip-placement="bottom">' +
                            '<i class="{{row.entity | threeDSecureStyle : \'iconClass\'}}" style="color: {{row.entity | threeDSecureStyle : \'color\'}}"></i>' +
                        '</div>'
                },
                {name: 'TRX_TYPE_DISPLAY', displayName: 'grid.header.transactionType', headerCellFilter: 'translate', cellClass: 'trx-type' + getCellClass, minWidth: 100, enableSorting: false},
                {name: 'ORIGINAL_OPERATION_TYPE_DISPLAY', displayName: 'grid.header.originalOperationType', headerCellFilter: 'translate', cellClass: 'original-operation-type' + getCellClass, minWidth: 100, enableSorting: false},
                {name: 'TRX_STATUS_DISPLAY', displayName: 'grid.header.status', headerCellFilter: 'translate', cellClass: 'status ' + getCellClass, minWidth: 100, enableSorting: false},
                {name: 'EXPIRED_STATUS', displayName: 'grid.header.expiredStatus', headerCellFilter: 'translate', cellClass: 'expired-status ' + getCellClass, minWidth: 100, enableSorting: true, visible: isExpiredStatusEnabled()},
                {name: 'QUICK_SALE', displayName: 'grid.header.quickSale', headerCellFilter: 'translate', cellClass: getCellClass, minWidth: 100, enableSorting: false, visible: isQuickSaleEnabled() },
                {
                    name: 'UNLINKED_REFUND', displayName: 'grid.header.unlinkedRefund', headerCellFilter: 'translate', cellClass: getCellClass, type: 'number', width: 145,
                    cellTemplate: '<div class="ui-grid-cell-contents"><unlinked-refund row="row.entity"></unlinked-refund></div>', visible: isUnlinkedRefundsEnabled()
                }
            ]
        };

        vm.onSortChanged = function (grid, sortColumns) {
            vm.silentLoading = true;
            checkSelectedRows(function () {
                console.log("callback");
                vm.sorting.direction = 'DESC';
                vm.sorting.columnName = 'TRX_CREATED_TIMESTAMP';
                if (sortColumns.length > 0 && sortColumns[0].field !== 'UNDEFINIED') {
                    console.log("lenght " + sortColumns.length);
                    console.log("field " + sortColumns[0].field);
                    vm.sorting.direction = sortColumns[0].sort.direction;
                    vm.sorting.columnName = sortColumns[0].field;
                }
                vm.currentPage = 1;
                fetchAllData();
            });
        };

        function checkSelectedRows(callback) {
            if (vm.txType === "VOID" && vm.gridApi.selection.getSelectedRows().length != 0) {
                openProcessTransactionsOverlay();
            } else {
                if (UtilService.isNotNull(callback)) {
                    console.log("calling callback");
                    callback();
                } else {
                    fetchAllData();
                }
            }
        }

        vm.gridOptions.onRegisterApi = function (gridApi) {
            vm.gridApi = gridApi;
            onResize();
            vm.gridApi.core.on.sortChanged($scope, vm.onSortChanged);
        };

        vm.gridOptions.setColumnsVisibility = function (names, visible) {
            vm.gridOptions.columnDefs.forEach(function (col) {
                names.forEach(function (name) {
                    if (col.name === name) col.visible = visible;
                });
            });
        };

        $(window).resize(function () {
            this.resizeTO && clearTimeout(this.resizeTO),
                this.resizeTO = setTimeout(function () {
                    onResize();
                }, 200);
        });

        function onResize() {
            var element = $(".grid");
            var value = "200px";
            if ($(window).height() > 500) {
                value = ($(window).height() - 350) + "px";
            }
            element.css("height", value);
        }

        vm.searchIconClass = getSearchIconClass(false);
        vm.searching = false;
        function getSearchIconClass(searching) {
            var searchIconClass;
            if (searching) {
                searchIconClass = "fa fa-spinner fa-pulse";
                vm.searching = true;
            } else {
                searchIconClass = "fa fa-search";
                vm.searching = false;
            }
            return searchIconClass;
        }

        vm.delaySearch = delaySearch;
        var filterTextTimeout;

        function delaySearch(newValue, type, timeout) {
            if(angular.isDefined(timeout)) {
                defaultTimeout = timeout;
            }
            if (typeof newValue !== 'undefined' && newValue !== null && (type === 'list' || newValue.length > 3)) {
                if (filterTextTimeout) {
                    $timeout.cancel(filterTextTimeout);
                }
                filterTextTimeout = $timeout(function () {
                    vm.filterSearch();
                }, defaultTimeout);
            }
        }

        function createRequest() {

	          filterStartDateUTC = vm.datePicker.options.minDate ? moment.utc(vm.datePicker.options.minDate).toISOString() : null;

            if(vm.datePicker.date.startDate) {
                filterStartDateUTC = moment.utc(vm.datePicker.date.startDate).toISOString();
            }

            if(vm.datePicker.date.endDate) {
                filterEndDateUTC = moment.utc(vm.datePicker.date.endDate).toISOString();
            }

            var request = {};
            request.txId = UtilService.replaceAll(filter.orderId, ' ', '');
            request.customerId = UtilService.replaceAll(filter.customerId, ' ', '');
            request.customerName = UtilService.trim(filter.customerName);
            request.listOfStatusCodes = undefined;

            if (typeof filter.listOfStatusCodes !== 'undefined' && filter.listOfStatusCodes.length != 0) {
                request.listOfStatusCodes = filter.listOfStatusCodes;
            } else if (vm.txType != "") {
                request.listOfStatusCodes = [];
                var listOfStatus = $filter('status')(vm.txType.toLowerCase());
                for (var i in listOfStatus) {
                    request.listOfStatusCodes.push(listOfStatus[i].key);
                }
            }

            var sourceTzName = JSON.parse(localStorage.getItem('timestampSourceTimeZoneName')) || 'Europe/London';  // server (DB) tz, so here it is our target

            if (filterStartDateUTC) {

                var m = moment(filterStartDateUTC);
                if (m.clone().tz(sourceTzName).isDST()) {
                    filterStartDateUTC = m.add(1, 'hours').toISOString(); // workaround (compensate for server), backward
                }

                request.dateFrom = filterStartDateUTC;
            }

            if (filterEndDateUTC) {

                var m = moment(filterEndDateUTC);
                if (m.clone().tz(sourceTzName).isDST()) {
                    filterEndDateUTC = m.add(1, 'hours').toISOString(); // workaround (compensate for server), backward
                }

                request.dateTo = filterEndDateUTC;
            }

            if (vm.filter.amountValues.length > 0) {
                if (vm.filter.amountValues.length === 1 && !UtilService.isEmpty(vm.filter.amountValues[0])) {
                    request.amountType = vm.currentType.param;
                    request.amountValues = vm.filter.amountValues;
                }
                if (vm.filter.amountValues.length === 2 && !UtilService.isEmpty(vm.filter.amountValues[0]) && !UtilService.isEmpty(vm.filter.amountValues[1])) {
                    request.amountType = vm.currentType.param;
                    request.amountValues = vm.filter.amountValues;
                }
            }
            var startR = (vm.pageSize * (vm.currentPage - 1));
            request.startRow = startR;
            request.maxRows = vm.pageSize;
            //request.currencies = replaceAll(filter.currency, ' ', '');
            //Later it will array (currency)
            if ((typeof vm.currency != 'undefined' && vm.currency != null && vm.currency.length > 0)) {
                request.currencies = vm.currency;
            }
            if (vm.filter.recurringPaymentsPlanId) {
                request.recurringPaymentsPlanId = vm.filter.recurringPaymentsPlanId;
            }

            if (!UtilService.isEmpty(vm.sorting.direction)) {
                request.sortDirection = vm.sorting.direction.toUpperCase();
                request.sortColumnName = vm.sorting.columnName;
            } else {
                request.sortDirection = 'DESC';
                request.sortColumnName = 'TRX_CREATED_TIMESTAMP';
            }

            MemoryStorageService.setSearchFields(request);
            return request;
        }

        function fetchAllData() {
            // Cancel previous requests if there is any
            if(angular.isDefined(filterCanceller)) {
                filterCanceller.resolve();
            }
            vm.searchIconClass = getSearchIconClass(true);
            if (isSearchFieldsContainsWhitespace()) {
                if(vm.gridApi) {
                    vm.gridApi.selection.clearSelectedRows();
                    if (vm.gridOptions.data instanceof Array) {
                        vm.gridOptions.data.length = 0;
                    }
                }
            }

            // Promise canceller
            filterCanceller = $q.defer();

            filterPromise = $http({
                method: 'POST',
                url: '/transactions/search',
                data: angular.toJson(createRequest()),
                timeout: filterCanceller.promise
            });

            filterPromise.then(function successCallback(successResponse) {
                vm.gridApi.selection.clearSelectedRows();
                if (vm.gridOptions.data instanceof Array) {
                    vm.gridOptions.data.length = 0;
                }
                if (successResponse && successResponse.data.data instanceof Array) {
                    vm.totalItems = successResponse.data.rowsCount;
                    vm.preProcessTransactions(successResponse.data.data, openInvalidTrxNoticeOverlay);
                    var data = successResponse.data.data;
                    setTrxTransactionType(data);
                    setTrxOriginalOperationType(data);
                    setTrxStatus(data);
                    setTrxExpiredStatus(data);
                    setTrxPaymentSolution(data);
                    setQuickSaleValue(data);
                    formatAmounts(data, ['AMOUNT', 'AMOUNT_REFUNDABLE', 'CONVERTED_AMOUNT']);
                    decodeUri(data, ['CUSTOMER_ID', 'CUSTOMER_NAME']);
                    vm.gridOptions.data = data;
                }
                else if(successResponse && successResponse.data.errors instanceof Array) {
                    Notification.error({message: $translate.instant('notification.error.search')});
                    console.log('Error: ', encodeURIComponent(successResponse.data.errors));
                    vm.gridOptions.data = [];
                }
                else {
                    vm.gridOptions.data = [];
                }
                vm.gridApi.core.notifyDataChange(uiGridConstants.dataChange.ALL);
                vm.silentLoading = false;
                vm.searchIconClass = getSearchIconClass(false);
            }, function errorCallback(errorResponse) {
                // status -> 408 The token expired... redirect to Login page
                if (errorResponse.status === 408) {
                    MemoryStorageService.addExceptionMsg(errorResponse.data.message);
                    $location.path('#/login');
                }
                else {
                    // Stop the spinner only when the response is a true error (not because of request canceller)
                    if(angular.isDefined(errorResponse) && errorResponse.status !== -1) {
                        vm.searchIconClass = getSearchIconClass(false);
                        Notification.error({message: $translate.instant('notification.error.search')});
                    }
                }
            });
        }


        vm.currency = null;

        vm.amountTypes = [
            {type: 'btw', msg: $translate.instant('filter.amount.dropDown.between'), param: 'between'},
            {type: 'eq', msg: $translate.instant('filter.amount.dropDown.equalTo'), param: 'equal-to'},
            {type: 'neq', msg: $translate.instant('filter.amount.dropDown.notEqualTo'), param: 'not-equal-to'},
            {type: 'grt', msg: $translate.instant('filter.amount.dropDown.greaterThan'), param: 'greater-than'},
            {type: 'lss', msg: $translate.instant('filter.amount.dropDown.lessThan'), param: 'less-than'}
        ];
        vm.currentType = vm.amountTypes[0];

        vm.checkType = checkType;
        function checkType(type) {
            if (vm.currentType.type === type) return true;
            else return false;
        }

        vm.changeByType = changeByIndex;
        function changeByIndex(index) {
            vm.currentType = vm.amountTypes[index];
        }

        /**
         * Change page number in pagination
         */
        function pageChanged() {
            checkSelectedRows();
        }

        /**
         * Change entries in total items
         */
        function entriesChanged() {
            vm.currentPage = 1;
            fetchAllData();
        }

        function filterSearch() {
            vm.currentPage = 1;
            fetchAllData();
        }

        //function escapeRegExp(str) {
        //    return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
        //}

        function replaceAll(str, find, replace) {
            if (str && str.length > 0) {
                return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
            }
        }

        // Moved to UtilService
        //function replaceAll(str, find, replace) {
        //    if (str && str.length > 0) return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
        //}

        function setTrxTransactionType(transactions) {
            transactions.forEach(function (tx, index, array) {
                tx.TRX_TYPE_DISPLAY = UtilService.listOfTypes()[tx.TRX_TYPE];
                if(!tx.TRX_TYPE_DISPLAY){
                    tx.TRX_TYPE_DISPLAY = tx.TRX_TYPE;
                }
            });
        }

        function setTrxOriginalOperationType(transactions) {
            transactions.forEach(function (tx, index, array) {
                tx.ORIGINAL_OPERATION_TYPE_DISPLAY = UtilService.listOfOriginalOperationTypes()[tx.ORIGINAL_OPERATION_TYPE];
                if(!tx.ORIGINAL_OPERATION_TYPE_DISPLAY){
                   tx.ORIGINAL_OPERATION_TYPE_DISPLAY = tx.ORIGINAL_OPERATION_TYPE;
                }
            });
        }

        function setTrxStatus(transactions) {
            transactions.forEach(function (tx, index, array) {
                tx.TRX_STATUS_DISPLAY = UtilService.listOfStatus()[tx.STATUS];
            });
        }

        function setTrxExpiredStatus(transactions){
            transactions.forEach(function (tx, index, array) {
                if(tx.EXPIRED_STATUS != undefined){
                    tx.EXPIRED_STATUS = UtilService.translateBoolToYesNo(tx['EXPIRED_STATUS'] == '1');
                }

            });
        }
        
        function setTrxPaymentSolution(transactions) {
            transactions.forEach(function (tx, index, array) {
                tx.PAYMENT_SOLUTION_DISPLAY = UtilService.listOfBankTransfers()[tx.PAYMENT_SOLUTION_ID];
                if(!tx.PAYMENT_SOLUTION_DISPLAY){
                    tx.PAYMENT_SOLUTION_DISPLAY = tx.PAYMENT_SOLUTION;
                }
             });
        }

        function setQuickSaleValue(transactions) {
            transactions.forEach(function (tx, index, array) {
            	tx['QUICK_SALE'] = UtilService.translateBoolToYesNo(tx['QUICK_SALE'] == '1')
            });
        }

        function formatAmounts(transactions, columns) {
            transactions.forEach(function (tx, index, array) {
                columns.forEach(function (column) {
                    tx[column] = parseFloat(tx[column]).toFixed(2);
                });
            });
        }

        function decodeUri(transactions, columns) {
            transactions.forEach(function (tx, index, array) {
                columns.forEach(function (column) {
                    tx[column] = decodeURIComponent(tx[column]);
                });
            });
        }

        function isSearchFieldsContainsWhitespace() {
            return UtilService.isContainsWhiteSpace(filter.orderId) || UtilService.isContainsWhiteSpace(filter.customerId);
        }

        function processSelectedTransactions() {
            openConfirmationOverlay(vm.gridApi.selection.getSelectedRows());
        }

        function processSingleTransaction(row) {
            openConfirmationOverlay(row);
        }

        function processSinglePartialTransaction(selectedTransactions) {
            var modalInstance = $uibModal.open({
                animation: true,
                templateUrl: 'partialAmountTransaction.html',
                controller: 'PartialModalInstanceCtrl',
                size: 'lg',
                resolve: {
                    selectedTrx: function () {
                        return selectedTransactions;
                    },
                    message: function () {
                        return vm.getPageType();
                    }
                }
            });
            modalInstance.result.then(function (result) {
                processTransactionsFinal(result);
            });
        }

        vm.isAnyRowSelected = function () {
            if (vm.gridApi.selection.getSelectedRows().length > 0) {
                vm.disableWhenIsMultiSelect = true;
            }
            vm.allSelectedRows = vm.gridApi.selection.getSelectedRows().length;
            return vm.gridApi.selection.getSelectedRows().length > 0;

        };

        vm.isMinimumRowsSelected = function () {
            if (vm.gridApi.selection.getSelectedRows().length > 0) {
                vm.disableWhenIsMultiSelect = true;
            }
            vm.allSelectedRows = vm.gridApi.selection.getSelectedRows().length;
            return vm.gridApi.selection.getSelectedRows().length > 1;

        };

        function openConfirmationOverlay(selectedTransactions, size) {
            if (size === undefined) {
                size = 'lg';
            }
            var modalInstance = $uibModal.open({
                animation: true,
                templateUrl: 'confirmationOverlay.html',
                controller: 'ModalInstanceCtrl',
                size: size,
                resolve: {
                    selectedTrx: function () {
                        return selectedTransactions;
                    }
                }
            });

            modalInstance.result.then(function (selectedItems) {
                processTransactionsFinal(selectedItems);
            });
        }

        function openProcessTransactionsOverlay(size) {
            if (size === undefined) {
                size = 'lg';
            }
            var modalInstance = $uibModal.open({
                animation: true,
                templateUrl: 'processTransactionsOverlay.html',
                controller: 'ProcessTransactionModalController',
                size: size
            });

            return modalInstance;
        }

        function openConfirmationPrompt(result) {
            $uibModal.open({
                animation: true,
                templateUrl: 'resultPrompt.html',
                controller: 'ConfirmationModalInstanceCtrl',
                size: 'lg',
                resolve: {
                    result: function () {
                        return result;
                    }
                }
            });
        }

        function openInvalidTrxNoticeOverlay(selectedTransactions, size) {
            if (size === undefined) {
                size = 'lg';
            }
            var modalInstance = $uibModal.open({
                animation: true,
                templateUrl: 'invalidTrxNoticeOverlay.html',
                controller: 'ModalInstanceCtrl',
                size: size,
                resolve: {
                    selectedTrx: function () {
                        return selectedTransactions;
                    }
                }
            });

            modalInstance.result.then(function (selectedItems) {
                processTransactionsFinal(selectedItems);
            });
        }

        vm.localSelectedItems = [];

        var processTransactionsFinal = function (selectedItems) {
            if (selectedItems) {
                selectedRows.data.push(selectedItems);
                selectedRows.data = [];
                responsesOfTransactions = [];
                vm.showSpinner = true;
                vm.localSelectedItems = selectedItems;
                executeAction(selectedItems[0]);
            }
        };

        var executeAction = function (value) {
            var request = {};
            request.originalMerchantTxId = value.TRX_ID_BY_MERCHANT;
            request.amount = value.AMOUNT;
            request.amountRefundable = value.AMOUNT_REFUNDABLE;
            request.partialAmount = value.PARTIAL_AMOUNT;
            request.partialRefundComment = value.PARTIAL_REFUND_COMMENT;

            request.allowOriginUrl = $location.protocol() + "://" + $location.host();
            transactionService.executeTransaction(vm.txType, request).then(function (data) {
                if (typeof data.success === 'undefined') {
                    vm.localSelectedItems.shift();
                    responsesOfTransactions.push(data);
                    if (vm.localSelectedItems.length !== 0) {
                        executeAction(vm.localSelectedItems[0]);
                    } else {
                        var result = {};
                        result.successCount = 0;
                        result.failedCount = 0;
                        if (data.action.slice(-1) === "E") {
                            result.status = data.action + "D";
                        } else {
                            result.status = data.action + "ED";
                        }
                        result.status = ($translate.instant($filter('translateTrxLabels')(result.status.toLowerCase()))).toUpperCase();
                        result.action = data.action;
                        angular.forEach(responsesOfTransactions, function (element) {
                            if (element.result === "failure") {
                                result.failedCount++;
                            } else {
                                result.successCount++;
                            }
                        });
                        openConfirmationPrompt(result);
                        fetchAllData();
                    }
                    vm.showSpinner = false;
                } else {
                    vm.showSpinner = false;
                    MemoryStorageService.addExceptionMsg(data.error);
                    $location.path('/login');
                }
            });
        };

        (function init() {
            if (MemoryStorageService.readFromMemory()) {
                var storedFields = MemoryStorageService.getSearchFields();
                if (UtilService.isNotNull(storedFields.dateFrom) && UtilService.isNotNull(storedFields.dateTo)) {
                    vm.datePicker.date = {
                        startDate: storedFields.dateFrom,
                        endDate: storedFields.dateTo
                    };
                }
                if (UtilService.isNotNull(storedFields.txId)) {
                    filter.orderId = storedFields.txId;
                    return;
                }
                if (UtilService.isNotNull(storedFields.customerId)) {
                    filter.customerId = storedFields.customerId;
                }
                if (UtilService.isNotNull(storedFields.customerName)) {
                    filter.customerName = storedFields.customerName;
                }
                if (UtilService.isNotNull(storedFields.txType)) {
                    filter.txType = storedFields.txType;
                }
                if (UtilService.isNotNull(storedFields.currencies)) {
                    vm.currency = storedFields.currencies;
                }
                if (UtilService.isNotNull(storedFields.amountType)) {
                    var selectedType = null;
                    for (var key in vm.amountTypes) {
                        if (storedFields.amountType === vm.amountTypes[key].param) {
                            selectedType = vm.amountTypes[key];
                            break;
                        }
                    }
                    if (UtilService.isNotNull(selectedType)) {
                        vm.currentType = selectedType;
                    }
                }
                if (UtilService.isNotNull(storedFields.amountValues)) {
                    filter.amountValues = storedFields.amountValues;
                }

                if (UtilService.isNotNull(storedFields.listOfStatusCodes)) {
                    filter.listOfStatusCodes = storedFields.listOfStatusCodes;
                }

                MemoryStorageService.readFromMemory(false);
                MemoryStorageService.setSearchFields({});
            }

            // Get merchant currencies
            settingService.getMerchantCurrencies().then(
                function (response) {
                    if(response.result === 'success') {
                        var merchantCurr = response.data;
                        // Get currency keys
                        angular.forEach(merchantCurr, function (currency) {
                            vm.currencies.push(currency.ISO);
                        });
                    }
                }
            );

        })();

    }
})();