(function() {
    "use strict";

    angular
        .module('shared')
        .factory('EditStandards', ['LazModalService', 'standardsService', 'folderService', 'messageHandler', 'FeatureCheck','currentSubFolders','folders',
            function (LazModalService, standardsService, folderService, messageHandler, FeatureCheck, currentSubFolders, folders) {

                function EditStandards() {
                    var self = this;

                    function EditStandardsCtrl(close) {
                        var ctrl = this;
                        ctrl.tabs = {
                            ADD_STANDARDS: "add",
                            SELECTED_STANDARDS: "select",
                            CUSTOM_STANDARDS: "custom"
                        };
                        var TEXAS = '52';
                        var COMMON_CORE = '51';
                        var FLORIDA = '9';
                        ctrl.isCustomStandardEnabled = FeatureCheck.isFeatureEnabled('FILE_CABINET_CUSTOM_STANDARDS');
                        ctrl.showCustomStandardTab = ctrl.isCustomStandardEnabled && !currentSubFolders.getAreFoldersForEveryone();
                        console.log(ctrl.showCustomStandardTab);
                        ctrl.saveButtonEnabled = true;
                        ctrl.selectedStandardLimit = standardsService.standardLimits.SELECTED_STANDARD_LIMIT;

                        function init() {
                            ctrl.folder = self.folder;
                            ctrl.grades = [
                                {name: 'Kindergarten', code: 'K'},
                                {name: 'Grade 1', code: '1'},
                                {name: 'Grade 2', code: '2'},
                                {name: 'Grade 3', code: '3'},
                                {name: 'Grade 4', code: '4'},
                                {name: 'Grade 5', code: '5'},
                                {name: 'Grade 6', code: '6'}
                            ];

                            if (ctrl.isCustomStandardEnabled) {
                                ctrl.selectedCustomStandards = standardsService.getSelectedCustomStandards();
                            }
                            ctrl.selectedStandards = standardsService.getSelectedStandards();
                            ctrl.activeTab = standardsService.hasSelectedStandards() ? ctrl.tabs.SELECTED_STANDARDS : ctrl.tabs.ADD_STANDARDS;
                            ctrl.lastStrand = standardsService.getLastStrand();

                            getStates();
                            ctrl.activeGrade = ctrl.grades[0].code;
                            ctrl.selectedState = 0;
                            resetStrands();

                            if (ctrl.lastStrand) {
                                ctrl.activeGrade = ctrl.lastStrand.strand_grade;
                                ctrl.selectedState = ctrl.lastStrand.state_standard_state_id;
                                ctrl.selectedStrand = ctrl.lastStrand.state_standard_strand_id;
                                getStrands().then(function() {
                                    setStrandCode();
                                });
                                getStandards();
                            }
                            if (folders.getIsLiteracyEditor()) {
                                if (folders.getLiteracyTypeId() == 2) {
                                    ctrl.selectedState = COMMON_CORE;
                                    setStrands();
                                } else if (folders.getLiteracyTypeId() == 3) {
                                    ctrl.selectedState = TEXAS;
                                    setStrands();
                                } else if (folders.getLiteracyTypeId() == 4) {
                                    ctrl.selectedState = FLORIDA;
                                    setStrands();
                                }
                            }
                        }

                        init();

                        ctrl.isLiteracyEditor = function() {
                            return folders.getIsLiteracyEditor();
                        };

                        ctrl.mainLinkClassName = function() {
                            return 'js-hamburger-menu-' + ctrl.folder.id;
                        };

                        ctrl.setActiveTab = function(tab) {
                            ctrl.activeTab = tab;
                            if (tab === ctrl.tabs.SELECTED_STANDARDS) {
                                ctrl.selectedStandards = standardsService.getSelectedStandards();
                                if (ctrl.isCustomStandardEnabled) {
                                    ctrl.selectedCustomStandards = standardsService.getSelectedCustomStandards();
                                }
                            }
                        };

                        ctrl.isActiveTab = function(tab) {
                            return ctrl.activeTab === tab;
                        };

                        ctrl.saveStandards = function() {
                            addStandardsToFolder();
                            removeStandardsFromFolder();
                            if (ctrl.isCustomStandardEnabled) {
                                addCustomStandardsToFolder();
                                removeCustomStandardsFromFolder();
                            }
                            close();
                        };

                        ctrl.selectStandard = function(standard) {
                            standard.strand_code = ctrl.selectedStrandCode;
                            standard.selected ? standardsService.selectStandard(standard) : standardsService.deselectStandard(standard);
                        };

                        ctrl.removeStandard = function(standard) {
                            standardsService.deselectStandard(standard);
                            if (ctrl.standards != undefined) {
                                deselectStandard(standard, ctrl.standards);
                            }
                            ctrl.selectedStandards = standardsService.getSelectedStandards();
                        };

                        ctrl.removeCustomStandard = function(customStandard) {
                            standardsService.deselectCustomStandard(customStandard);
                            standardsService.emitSelectedStandardsUpdate();
                            ctrl.selectedCustomStandards = standardsService.getSelectedCustomStandards();
                        };

                        ctrl.folderHasStandards = function() {
                            return standardsService.hasSelectedStandards();
                        };

                        ctrl.isLeafAndHasCode = function(standard) {
                            return standard.standard_code;
                        };

                        ctrl.getGradeClass = function(grade) {
                            var gradeClass = '';
                            if (grade.code === ctrl.activeGrade) {
                                gradeClass = 'activeGrade ';
                            }
                            if (ctrl.areOptionsDisabled()) {
                                gradeClass += 'disabled';
                            }
                            return gradeClass;

                        };

                        ctrl.getCheckboxClass = function(standard) {
                            return ctrl.isCheckboxDisabled(standard) ? 'tooltip tooltip-top' : '';
                        };

                        ctrl.isCheckboxDisabled = function(standard) {
                            return standard.selected ? false : standardsService.hasReachedStandardsLimit();
                        };

                        ctrl.areOptionsDisabled = function() {
                            return ctrl.activeTab !== ctrl.tabs.ADD_STANDARDS;
                        };

                        ctrl.cancel = function() {
                            standardsService.resetSelectedStandards();
                            standardsService.resetSelectedCustomStandards();
                            close();
                        };

                        ctrl.stateChanged = function() {
                            setStrands();
                        };

                        ctrl.gradeChanged = function(gradeCode) {
                            if (!ctrl.areOptionsDisabled()){
                                ctrl.activeGrade = gradeCode;
                                setStrands();
                            }
                        };

                        ctrl.strandChanged = function() {
                            ctrl.selectedStrand !== 0 ? getStandards() : ctrl.standards = [];
                            setStrandCode();
                        };

                        function getStates() {
                            standardsService.getStateStandardsStates().then(
                                function(response) {
                                    var selectStateOption = {state_standard_state_id: 0, name: ' -- Select a state to begin -- '};
                                    ctrl.stateOptions = response;
                                    ctrl.stateOptions.unshift(selectStateOption);
                                },
                                function(reason) {
                                    console.debug(reason);
                                    messageHandler.publishError("There was a problem processing your request.");
                                }
                            )
                        }

                        function getStrands() {
                            return standardsService.getStateStandardsStrands(ctrl.selectedState, ctrl.activeGrade).then (
                                function(response) {
                                    var strandOption = {state_standard_strand_id: 0, strand_code: 0, strand_description: ' -- Select a category -- '};
                                    ctrl.strands = response;
                                    ctrl.strands.unshift(strandOption);
                                    return response;
                                },
                                function(reason) {
                                    console.debug(reason);
                                    messageHandler.publishError("There was a problem processing your request.");
                                    return 0;
                                }
                            );
                        }

                        function getStandards() {
                            standardsService.getStateStandards(ctrl.selectedStrand).then(
                                function(response) {
                                    ctrl.standards = response;
                                },
                                function(reason) {
                                    console.debug(reason);
                                    messageHandler.publishError("There was a problem processing your request.");
                                }
                            );
                        }

                        function setStrands() {
                            if (ctrl.selectedState !== 0) {
                                getStrands().then(
                                    function (response) {
                                        ctrl.selectedStrand = response[1].state_standard_strand_id;
                                        setStrandCode();
                                        getStandards();
                                    },
                                    function (reason) {
                                        console.debug(reason);
                                        ctrl.standards = [];
                                    }
                                );
                            } else {
                                resetStrands();
                                ctrl.standards = [];
                            }
                        }

                        function setStrandCode() {
                            ctrl.strands.forEach(function(strand) {
                                if (strand.state_standard_strand_id === ctrl.selectedStrand) {
                                    ctrl.selectedStrandCode = strand.strand_code;
                                }
                            })
                        }

                        function resetStrands() {
                            ctrl.strands = [{state_standard_strand_id: 0, strand_code: 0, strand_description: ' -- Select a category to begin -- '}];
                            ctrl.selectedStrand = 0;
                            ctrl.selectedStrandCode = '';
                        }

                        function deselectStandard(currentStandard, standards) {
                            standards.forEach(function(standard) {
                                if (standard.state_standard_id === currentStandard.state_standard_id) {
                                    standard.selected = false;
                                }
                                if (standard.children) {
                                    deselectStandard(currentStandard, standard.children);
                                }
                            })
                        }

                        function addStandardsToFolder() {
                            var standardIdsToAdd = standardsService.getStandardIdsToAdd();
                            var hasStandardsToAdd = standardIdsToAdd.length > 0;
                            if (hasStandardsToAdd) {
                                var data = {
                                    folder_id: ctrl.folder.id,
                                    selectedStandardsStr: JSON.stringify(standardIdsToAdd),
                                    everyone_folder: currentSubFolders.getAreFoldersForEveryone()
                                };
                                folderService.addStandardsToFolder(data)
                                    .then(onRepos, onError);
                            }
                        }

                        function removeStandardsFromFolder() {
                            var standardIdsToRemove = standardsService.getStandardIdsToRemove();
                            var hasStandardsToRemove = standardIdsToRemove.length > 0;
                            if (hasStandardsToRemove) {
                                var stateStandards = standardIdsToRemove.join(',');
                                folderService.removeStandardsFromFolder(ctrl.folder.id, stateStandards,currentSubFolders.getAreFoldersForEveryone())
                                    .then(onRepos, onError);
                            }
                        }

                        function addCustomStandardsToFolder() {
                            var customStandardIdsToAdd = standardsService.getCustomStandardIdsToAdd();
                            var hasStandardsToAdd = customStandardIdsToAdd.length > 0;
                            if (hasStandardsToAdd) {
                                var data = {
                                    folder_id: ctrl.folder.id,
                                    customStandardsStr: JSON.stringify(customStandardIdsToAdd),
                                    everyone_folder: currentSubFolders.getAreFoldersForEveryone()
                                };
                                folderService.addCustomStandardsToFolder(data)
                                    .then(onRepos, onError);
                            }
                        }

                        function removeCustomStandardsFromFolder() {
                            var customStandardIdsToRemove = standardsService.getCustomStandardIdsToRemove();
                            var hasStandardsToRemove = customStandardIdsToRemove.length > 0;
                            if (hasStandardsToRemove) {
                                var customStandards = customStandardIdsToRemove.join(',');
                                folderService.removeCustomStandardsFromFolder(ctrl.folder.id, customStandards,currentSubFolders.getAreFoldersForEveryone())
                                    .then(onRepos, onError);
                            }
                        }

                        var onRepos = function(response) {
                            if (response.data) {
                                folderService.emitFolderUpdate();
                            }
                            else {
                                onError("There was a problem processing your request.")
                            }
                        };

                        var onError = function(reason) {
                            console.debug(reason);
                            messageHandler.publishError("There was a problem processing your request.");
                            standardsService.resetSelectedStandards();
                            if (ctrl.isCustomStandardEnabled) {
                                standardsService.resetSelectedCustomStandards();
                            }
                        };
                    }

                    self.show = function(folder) {
                        self.folder = folder;
                        LazModalService.showModal({
                            controller: ['close', EditStandardsCtrl],
                            controllerAs: '$ctrl',
                            hideCloseButton: 'true',
                            overrideClass: 'js-none',
                            onClose: '$ctrl.cancel',
                            overrideStyle: 'height: 95vh;',
                            templateUrl: '/shared/js/angular/file-cabinet/edit-standards.html'
                        });
                    }
                }
                return new EditStandards();
            }
        ]);
}());