(function () {
    'use strict';
    var app = angular.module('mybadges');
    var templatePath = modulesSharedResourcesUrl + 'Modules/MyBadges/Views/';

    //a directive show all the templates available to complete for the user
    app.directive('discover', ['myBadgesDataContext', 'common', '$modal', '$location', 'datacontext',
        function (myBadgesDataContext, common, $modal, $location, datacontext) {
            return {
                restrict: 'E',
                scope: {
                },
                templateUrl: templatePath + 'discover.html',
                link: link
            };

            function link($scope, elem, attrs) {
                var getLogFn = common.logger.getLogFn;
                var log = getLogFn('branding');
                var logSuccess = getLogFn('branding', "success");
                var logError = getLogFn("branding", "warning");
                $scope.badges = [];
                $scope.searchQueryText = '';
                $scope.error = '';
                $scope.orderByAttr = '-datePublished';
                getDiscovery();
                activate();

                // Set the initail filter values
                function activate() {
                    NProgress.done();
                    log('Activated Discovery View');
                }
                function getDiscovery() {
                    myBadgesDataContext.getDiscoveryForUser().then(function (data) {
                        $scope.badges = data;
                        $scope.discoveryLoaded = true;
                    });
                }

                $scope.claimBadge = function (badge) {
                    if (badge.claimDetails.length === 0) {
                        $location.path('claim/badge/' + badge.id);
                    } else {
                        $modal.open({
                            templateUrl: templatePath + 'claimcode.html',
                            controller: claimCodeController,
                            size: 'sm',
                            backdrop: 'static',
                            resolve: {
                                badgeId: function () {
                                    return badge.id;
                                }
                            }
                        });
                    }
                };

                var claimCodeController = function ($scope, $modalInstance, badgeId) {
                    // close the modal
                    $scope.claimCode = '';

                    $scope.cancel = function () {
                        $modalInstance.dismiss('cancel');
                    };

                    $scope.submitClaim = function () {
                        myBadgesDataContext.validateClaim($scope.claimCode, badgeId).then(function (data) {
                            if (data === null) {
                                $scope.error = 'Invalid Code. Please try again.';
                            } else {
                                $modalInstance.dismiss('cancel');
                                $location.path('claim/code/' + $scope.claimCode);
                            }
                        });
                    };
                };
            }
        }]);

    //a directive show all the templates available to complete for the user
    app.directive('claimBadge', ['myBadgesDataContext', 'myBadgesAdminDataContext', 'common', '$location', '$window', 'datacontext',
        function (myBadgesDataContext, myBadgesAdminDataContext, common, $location, $window, datacontext) {
            return {
                restrict: 'E',
                scope: {
                    claimId: '=',
                    claimCode: '=',
                    badgeId: '='
                },
                templateUrl: templatePath + 'claimbadge.html',
                link: link
            };

            function link($scope, elem, attrs) {
                var getLogFn = common.logger.getLogFn;
                var log = getLogFn('branding');
                var logSuccess = getLogFn('branding', "success");
                var logError = getLogFn("branding", "warning");
                $scope.loadedClaim = false;
                $scope.showEvidenceForm = false;
                $scope.newEvidence =
                    {
                        name: "",
                        description: "", resourceId: null
                    };
                $scope.claim = {};
                if ($scope.claimId) {                  
                    myBadgesDataContext.getClaimById($scope.claimId).then(function (claim) {
                        $scope.claim = claim;
                        myBadgesDataContext.getClaimBadge(claim.claimCode).then(function (data) {
                            $scope.latestClaim = claim;

                            getIntegrations(data.claimOrganisation);
                            myBadgesDataContext.getClaimBadge(claim.claimCode).then(function (data) {
                                $scope.badge = data;
                                $scope.loadedClaim = true;
                            });
                        });
                    });
                } else if ($scope.claimCode) {
                    myBadgesDataContext.validateClaim($scope.claimCode, '00000000-0000-0000-0000-000000000000').then(function (claim) {
                        $scope.claim = claim;
                        myBadgesDataContext.getClaimBadge($scope.claimCode).then(function (data) {
                            $scope.badge = data;
                            getIntegrations(data.claimOrganisation);
                            myBadgesDataContext.getClaimBadgeUser($scope.claimCode, "code").then(function (data) {
                                if (data && data.status !== 2) {
                                    $scope.latestClaim = data;
                                    $scope.latestClaim.developerKey = $scope.developerKey;
                                    $scope.latestClaim.authToken = $scope.authToken;
                                }
                                else {
                                    $scope.latestClaim = {
                                        id: null,
                                        status: null,
                                        claimCodeId: claim.id,
                                        claimMessages: [],
                                        claimEvidence: [],
                                        claimType: "code"
                                    };
                                }
                                $scope.loadedClaim = true;
                            });
                        }).catch(function (error) {
                            $scope.mainError = 'You are not allowed to claim this badge.';
                        });
                    });
                } else {
                    myBadgesDataContext.getClaimBadgeByBadge($scope.badgeId).then(function (data) {
                        $scope.badge = data;
                        getIntegrations(data.claimOrganisation);
                        myBadgesDataContext.getClaimBadgeUser($scope.badgeId, "badge").then(function (data) {
                            if (data && data.status !== 2) {
                                $scope.latestClaim = data;
                            }
                            else {
                                $scope.latestClaim = {
                                    id: $scope.badge.id,
                                    status: null,
                                    claimCodeId: null,
                                    claimMessages: [],
                                    claimEvidence: [],
                                    claimType: "badge"
                                };
                            }
                            $scope.loadedClaim = true;
                        });
                    }).catch(function (error) {
                        $scope.mainError = 'You are not allowed to claim this badge.';
                    });
                }

                $scope.submitClaim = function () {
                    $scope.createClaim($scope.claimCode);
                };

                $scope.removeEvidence = function ($index) {
                    $scope.latestClaim.claimEvidence.splice($index, 1);
                    logSuccess('Evidence removed successfully');
                };

                $scope.onFileSelect = function (files) {
                    $scope.file = files[0]; // we're not interested in multiple file uploads here
                    // check if the user has selected an below our maximum file size of 20MB
                    if ($scope.file && $scope.file.size < 50000000) {
                        $scope.imageAdded = true;
                        var reader = new FileReader();
                        // Generate base 64 image for preview
                        reader.readAsDataURL($scope.file);
                    } else {
                        $scope.errorMessage = 'File is too large!';
                        return;
                    }
                    if ($scope.file.type === "") {
                        $scope.errorMessage = 'File type is not valid';
                        return;
                    }
                    $scope.fileName = $scope.file.name;
                    files.originalImageFileName = $scope.file.name;
                    files.imageFileSize = $scope.file.size;
                    files.imageFileType = $scope.file.type;
                    $scope.files = files;
                };

                $scope.discardEvidence = function (form) {
                    $scope.newEvidence =
                        {
                            name: "",
                            description: "", resourceId: null
                        };
                    $scope.showEvidenceForm = false;
                    if (form) {
                        form.$setPristine();
                    }
                }

                $scope.addEvidenceModel = function (evidenceModel, form) {
                    if ($scope.files) {
                        uploadEvidence($scope.files, evidenceModel);
                    }
                    else {
                        var ev = {
                            name: evidenceModel.name,
                            description: evidenceModel.description,
                            public: evidenceModel.public,
                            resourceId: evidenceModel.resourceId
                        };
                        $scope.latestClaim.claimEvidence.push(ev);
                    }
                    logSuccess('Evidence added successfully');
                    $scope.newEvidence = {
                        name: "",
                        description: "", resourceId: null
                    };
                    $scope.showEvidenceForm = false;
                    if (form) {
                        form.$setPristine();
                    }
                };

                $scope.addMessageModel = function (messageModel, form) {
                    var ev =
                    {
                        message: messageModel.message, id: null
                    };
                    $scope.latestClaim.claimMessages.push(ev);
                    $scope.latestClaim.apiKey = $scope.developerKey;
                    $scope.latestClaim.authToken = $scope.authToken;
                    $scope.latestClaim.claimType = "code";
                    myBadgesDataContext.saveUserClaim($scope.latestClaim).then(function (data) {
                        logSuccess('Message added successfully');
                        myBadgesDataContext.getClaimById($scope.latestClaim.id).then(function (claim) {
                            $scope.latestClaim = claim;
                        });
                        $scope.newMessage =
                            {
                                message: ''
                            };
                        if (form) {
                            form.$setPristine();
                        }
                    });
                };

                function uploadEvidence(files, evidenceModel) {
                    if (files.length === 0) return;

                    UploadProgress(1);

                    //images are uploaded to resource server
                    myBadgesAdminDataContext.uploadEvidence(files, $scope.fileName, $scope.file.type, UploadProgress).then(function (data) {
                        var ev =
                        {
                            name: evidenceModel.name,
                            description: evidenceModel.description,
                            resourceId: data.data.id,
                            evidenceId: data.data.resourceId,
                            fileType: $scope.file.type
                        };
                        $scope.latestClaim.claimEvidence.push(ev);
                        $scope.progress = null;
                        $scope.newEvidence.resourceId = null;
                        $scope.fileName = '';
                        $scope.files = null;
                    });
                }

                $scope.viewEvidenceFile = function (id) {
                    myBadgesAdminDataContext.getEvidence(id).then(function (data) {
                        if (data.fileUri) {
                            $window.open(data.fileUri);
                        }
                    });
                };

                $scope.submitClaim = function () {
                    $scope.latestClaim.status = 1;
                    $scope.latestClaim.apiKey = $scope.developerKey;
                    $scope.latestClaim.authToken = $scope.authToken;
                    myBadgesDataContext.saveUserClaim($scope.latestClaim).then(function (data) {
                        logSuccess('Claim successfully submitted.');
                        if ($scope.latestClaim.claimType === "code")
                            $location.path('myclaims');
                        else
                            $location.path('discover');
                    });
                };

                function getAuthenticationToken(dkey, orgid) {
                    datacontext.getAuthenticationToken(dkey, orgid).then(function (data) {
                        // generate pop up
                        $scope.authToken = data;
                    });
                }

                function randomPKey(length, addUpper, addSymbols, addNums) {
                    var lower = "abcdefghijklmnopqrstuvwxyz";
                    var upper = addUpper ? lower.toUpperCase() : "";
                    var nums = addNums ? "0123456789" : "";
                    var symbols = addSymbols ? "!#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~" : "";

                    var all = lower + upper + nums + symbols;
                    while (true) {
                        var pass = "";
                        for (var i = 0; i < length; i++) {
                            pass += all[Math.random() * all.length | 0];
                        }
                        // criteria:
                        if (!/[a-z]/.test(pass)) continue; // lowercase is a must
                        if (addUpper && !/[A-Z]/.test(pass)) continue; // check uppercase
                        if (addSymbols && !/\W/.test(pass)) continue; // check symbols
                        if (addNums && !/\d/.test(pass)) continue; // check nums

                        return pass; // all good
                    }
                }

                function getIntegrations(orgId) {

                    datacontext.getIntegrations(orgId, 8).then(function (data) {
                        if (data && data.length > 0) {
                            $scope.developerKey = data[0].secondaryKey;
                            if (!$scope.developerKey || $scope.developerKey.length == 0) {
                                var k = randomPKey(60, true, false, true);
                                var integration = {
                                    organisationId: orgId,
                                    connectionType: 8,
                                    connectionCode: orgId,
                                    connectionName: "DeveloperKey",
                                    primaryKey: "",
                                    secondaryKey: k,
                                };

                                datacontext.createIntegration(integration).then(function (data) {
                                    $scope.developerKey = data.secondaryKey;

                                });
                            }
                            getAuthenticationToken($scope.developerKey, orgId);
                        } else {
                            var k = randomPKey(60, true, false, true);
                            var integration = {
                                organisationId: orgId,
                                connectionType: 8,
                                connectionCode: orgId,
                                connectionName: "DeveloperKey",
                                primaryKey: "",
                                secondaryKey: k,
                            };

                            datacontext.createIntegration(integration).then(function (data) {
                                $scope.developerKey = data.secondaryKey;
                                getAuthenticationToken(data.secondaryKey, data.organisationId);
                            });
                        }


                    });
                }

                $scope.saveClaim = function () {
                    $scope.latestClaim.status = 0;
                    $scope.latestClaim.apiKey = $scope.developerKey;
                    $scope.latestClaim.authToken = $scope.authToken;
                    myBadgesDataContext.saveUserClaim($scope.latestClaim).then(function (data) {
                        logSuccess('Claim successfully saved.');
                        if ($scope.latestClaim.claimType === "code")
                            $location.path('myclaims');
                        else
                            $location.path('discover');
                    });
                };

                $scope.removeClaim = function () {
                    if ($scope.latestClaim.claimType === "code") {
                        myBadgesDataContext.removeUserClaim($scope.latestClaim).then(function (data) {
                            logSuccess('Claim successfully removed.');
                            $location.path('myclaims');
                        });
                    }
                    else if ($scope.latestClaim.claimType === "badge") {
                        myBadgesDataContext.removeUserBadge($scope.latestClaim).then(function (data) {
                            logSuccess('Successfully removed.');
                            $location.path('discover');
                        });
                    }
                };

                $scope.cancel = function () {
                    if ($scope.latestClaim.claimType === "code")
                        $location.path('myclaims');
                    else
                        $location.path('discover');
                };

                // Generate the image upload process percentage
                function UploadProgress(percentComplete) {
                    $scope.progress = percentComplete;
                    $scope.uploadStatus = "Uploading... " + percentComplete + "%";
                }
            }
        }]);

    app.directive('myClaims', ['myBadgesDataContext', 'common', '$location', '$modal',
        function (myBadgesDataContext, common, $location, $modal) {
            return {
                restrict: 'E',
                scope: {
                    claim: '='
                },
                templateUrl: templatePath + 'myclaims.html',
                link: link
            };

            function link($scope, elem, attrs) {
                var getLogFn = common.logger.getLogFn;
                var log = getLogFn('branding');
                var logSuccess = getLogFn('branding', "success");
                var logError = getLogFn("branding", "warning");
                $scope.claims = [];
                $scope.searchQueryText = '';
                $scope.claimsLoaded = false;
                $scope.orderByPredicate = '-dateCreated';
                $scope.filters = [
                    { name: 'In progress', value: 0 },
                    { name: 'In review', value: 1 },
                    { name: 'Issued', value: 2 },
                    { name: 'Returned', value: 3 }
                ];

                // Set the initail filter values
                $scope.filterValues = [0, 1, 2, 3];

                // Apply the status filters
                $scope.applyStatusFilter = function (value, index) {
                    return $scope.filterValues.indexOf(value.status) !== -1;
                };

                activate();

                // Set the initail filter values
                function activate() {
                    NProgress.done();
                    getClaims();
                    log('Activated Discovery View');
                }

                function getClaims() {
                    myBadgesDataContext.getClaims().then(function (data) {
                        $scope.claims = data;
                        $scope.claimsLoaded = true;
                    });
                }

                $scope.manageClaim = function (claim) {
                    $location.path('claim/id/' + claim.id);
                };

                $scope.onChange = function (newValue, oldValue) {
                    $scope.filteredBadges = [];
                    if (newValue) {
                        for (i in $scope.badges) {
                            if ($scope.badges[i].totalClaimUsage === 0) {
                                $scope.filteredBadges.push($scope.badges[i]);
                            }
                        }
                        $scope.badges = $scope.filteredBadges;
                    }
                    else {
                        getDiscovery();
                    }
                };

                $scope.claimBadge = function () {
                    $modal.open({
                        templateUrl: templatePath + 'claimcode.html',
                        controller: claimCodeController,
                        size: 'sm',
                        backdrop: 'static',
                        resolve: {
                            badgeId: function () {
                                return '00000000-0000-0000-0000-000000000000';
                            }
                        }
                    });
                };

                var claimCodeController = function ($scope, $modalInstance, badgeId) {
                    // close the modal
                    $scope.claimCode = '';

                    $scope.cancel = function () {
                        $modalInstance.dismiss('cancel');
                    };

                    $scope.submitClaim = function () {
                        myBadgesDataContext.validateClaim($scope.claimCode, badgeId).then(function (data) {
                            if (data === null) {
                                $scope.error = 'Invalid Code. Please try again.';
                            } else {
                                $modalInstance.dismiss('cancel');
                                $location.path('claim/code/' + $scope.claimCode);
                            }
                        });
                    };
                };

                if ($scope.claim) {
                    $scope.claimBadge();
                    $location.path('myclaims');
                }
            }
        }]);

})();