"use strict";

angular.module('raz')
    .component('nonbookPopout', {
        templateUrl: '/js/angular/nonbook-popout/nonbook-popout.html',
        controller: 'NonbookPopoutController'
    })
    .controller('NonbookPopoutController',
        ['$scope', '$sce', '$q', '$element', '$document', 'fileCabinetRibbonService', 'folderService', 'MessageBox',
            'assignTargetedResource', 'FeatureCheck', 'folderListItemAmbassador', 'ResourcePopout',
            function NonbookPopoutController($scope, $sce, $q, $element, $document, fileCabinetRibbonService, folderService,
                                             MessageBox, assignTargetedResource, FeatureCheck, folderListItemAmbassador, ResourcePopout) {
                var ctrl = this;
                var selectedFolder = null;
                ctrl.nonbook_popout_info = {};
                ctrl.digitalResourcesAssignable = true;
                ctrl.currentResourceAdded = false;
                ctrl.folderList = [];
                ctrl.folderNameToFolderObjMap = {};
                ctrl.folderIdToFolderObjMap = {};
                ctrl.newFolderName = "";
                ctrl.existingFolderName = "";
                ctrl.nonbook_popout_target_selector = '.js-nonbook-popout';
                ctrl.lastSavedFolderID = 0;
                ctrl.isGridView = true;
                ctrl.createNestedFolderEnabled = FeatureCheck.isFeatureEnabled("CREATE_NESTED_FOLDER_IN_POPOUT");

                ctrl.showAssignButton = showAssignButton;
                ctrl.assign = assign;

                var _showAddToSection = false;
                var _addToExistingFolder = false;

                /* Lifecycle Hooks */

                ctrl.$onInit = function () {
                    if (!ctrl.createNestedFolderEnabled) {
                        ctrl.existingFolderId = null;
                    }
                    ctrl.$nonbook_grid_container = $j('body');
                    ctrl.resourcePopout = new ResourcePopout(ctrl.$nonbook_grid_container, ctrl.nonbook_popout_target_selector,
                        ctrl.nonbook_popout_target_selector, ctrl.getDisplayInfo, ctrl.closePopout, $element, false , 'nonbook-popout');
                    if (fileCabinetRibbonService.ribbonActive()) {
                        var currentFolderObj = fileCabinetRibbonService.currentFolder();
                        ctrl.addToExistingFolder(true);
                        if (!ctrl.createNestedFolderEnabled){
                            ctrl.updateExistingFolderId(currentFolderObj.id);
                        }
                        else {
                            selectedFolder = currentFolderObj;
                        }
                    }
                    $element.hide();
                    if (ctrl.createNestedFolderEnabled) {
                        folderListItemAmbassador.registerOnSelectedFolderListItemChanged($scope, onSelectedFolderListItemChanged);
                    }
                };

                ctrl.$postLink = function () {
                    ctrl.resourcePopout.enableEventTriggers();
                    ctrl.resourcePopout.closeIfClickedOutsidePopout();
                };

                /* Functions for the popout */

                ctrl.closePopout = function (fileCabinetRibbonClosing) {
                    $element.hide();
                    if (fileCabinetRibbonClosing) {
                        ctrl.addToNewFolder(true);
                    }
                    ctrl.showAddToSection(false);
                    if (!ctrl.resourcePopout.popoutState.eventsEnabled) {
                        ctrl.resourcePopout.enableEventTriggers();
                    }
                };

                ctrl.getDisplayInfo = function(){
                    var currentPopoutTarget = ctrl.resourcePopout.currentPopoutTarget;
                    if (fileCabinetRibbonService.ribbonActive()) {
                        ctrl.currentResourceAdded = fileCabinetRibbonService.nonbookAddedToFileCabinetRibbon(currentPopoutTarget.dataQueryMap.id);
                    }
                    ctrl.nonbook_popout_info = $j(currentPopoutTarget.domElement).data('nonbookPopoutInfo');
                    ctrl.digitalResourcesAssignable = ctrl.nonbook_popout_info.digitalResourcesAssignable;
                    $scope.$apply();
                    setExtraInfoVerbiage();
                    return $q.resolve(true);
                };

                function setExtraInfoVerbiage() {
                    ctrl.nonbook_popout_info.extra_info_set = [];
                    if (ctrl.nonbook_popout_info.genre) {
                        ctrl.nonbook_popout_info.extra_info_set.push(ctrl.nonbook_popout_info.genre + ' (' +
                            ctrl.nonbook_popout_info.genre_type + ')');
                    }
                    if (ctrl.nonbook_popout_info.structure && ctrl.nonbook_popout_info.genre_type === 'nonfiction') {
                        ctrl.nonbook_popout_info.extra_info_set.push(ctrl.nonbook_popout_info.structure);
                    }
                    if (ctrl.nonbook_popout_info.word_count) {
                        ctrl.nonbook_popout_info.extra_info_set.push(ctrl.nonbook_popout_info.word_count + ' words');
                    }
                    if (ctrl.nonbook_popout_info.raz_level) {
                        ctrl.nonbook_popout_info.extra_info_set.push("Level " + ctrl.nonbook_popout_info.raz_level);
                    }
                    if (ctrl.nonbook_popout_info.lexile) {
                        ctrl.nonbook_popout_info.extra_info_set.push("Lexile " + ctrl.nonbook_popout_info.lexile);
                    }
                    ctrl.nonbook_popout_info.extra_info = ctrl.nonbook_popout_info.extra_info_set.join(', ');
                    $scope.$apply();
                }

                /* Functions for the file cabinet and adding to folders */

                ctrl.initAddToSection = function () {
                    ctrl.counter = 0;
                    ctrl.resourcePopout.disableEventTriggers();
                    ctrl.showAddToSection(true);
                    if (!ctrl.createNestedFolderEnabled) {
                        ctrl.addToNewFolder(true);
                        getLastPopoutFolderId().then(function success() {
                            ctrl.populateFolderInfo()
                                .then(function success() {
                                    var lastSavedFolder = ctrl.folderIdToFolderObjMap[ctrl.lastSavedFolderID];
                                    if (lastSavedFolder && !lastSavedFolder.locked) {
                                        ctrl.updateExistingFolderId(ctrl.lastSavedFolderID);
                                        ctrl.folderIndex = lastSavedFolder.index;
                                    }
                                    else {
                                        ctrl.updateExistingFolderId(null);
                                        ctrl.folderIndex = 0;
                                    }
                                }).catch(function failure() {
                                ctrl.showAddToSection(false);
                            });
                        });
                    }
                };

                ctrl.showAddToSection = function (showSection) {
                    if (showSection !== undefined) {
                        _showAddToSection = showSection;
                    }

                    return _showAddToSection;
                };

                // deprecated
                function populateFolderObjMaps(folderList) {
                    folderList.forEach(function (folder) {
                        ctrl.folderNameToFolderObjMap[folder.name.trim()] = folder;
                        ctrl.folderIdToFolderObjMap[folder.id] = folder;
                        ctrl.folderIdToFolderObjMap[folder.id].index = ctrl.counter++;
                        if (folder.children !== null) {
                            populateFolderObjMaps(folder.children);
                        }
                    });
                }

                // deprecated
                ctrl.populateFolderInfo = function () {
                    return fileCabinetRibbonService.getFileCabinetFolderList()
                        .then(function success(folderList) {
                            console.log("folderList: %o", folderList);
                            ctrl.folderList = folderList;
                            populateFolderObjMaps(folderList);
                            return null;
                        }).catch(function failure(reason) {
                            var errMsg = 'There was a problem listing file cabinet folders. Please try again.';
                            displayAlertMsg(errMsg);
                            console.error(reason);
                            return $q.reject();
                        });
                };

                ctrl.addToExistingFolder = function (addToExistingFolder) {
                    if (addToExistingFolder !== undefined) {
                        _addToExistingFolder = addToExistingFolder;
                        if (_addToExistingFolder) {
                            ctrl.newFolderName = "";
                        }
                    } else {
                        return _addToExistingFolder;
                    }
                };

                ctrl.addToNewFolder = function (addToNewFolder) {
                    if (addToNewFolder !== undefined) {
                        _addToExistingFolder = !addToNewFolder;
                    } else {
                        return !_addToExistingFolder;
                    }
                };

                // deprecated
                ctrl.updateExistingFolderId = function (folderId) {
                    ctrl.existingFolderId = folderId;
                };

                // deprecated
                ctrl.getCurrentFolderName = function () {
                    if (fileCabinetRibbonService.ribbonActive()) {
                        return fileCabinetRibbonService.getCurrentFolderObj().name;
                    } else if (ctrl.addToNewFolder()) {
                        return folderService.ansiOnly(ctrl.newFolderName);
                    } else {
                        return ctrl.folderIdToFolderObjMap[ctrl.existingFolderId].name;
                    }
                };

                // deprecated
                ctrl.getCurrentFolderObj = function () {
                    if (fileCabinetRibbonService.ribbonActive()) {
                        return fileCabinetRibbonService.getCurrentFolderObj();
                    } else if (ctrl.addToExistingFolder()) {
                        return ctrl.folderIdToFolderObjMap[ctrl.existingFolderId];
                    } else {
                        return null;
                    }
                };

                ctrl.addResourceButtonEnabled = function () {
                    if (ctrl.createNestedFolderEnabled) {
                        return !!selectedFolder && selectedFolder.isChecked;
                    } else if (ctrl.addToNewFolder()) {
                        return !!ctrl.newFolderName;
                    } else { // add to Existing Folder
                        return !!ctrl.existingFolderId;
                    }
                };

                function setLastPopoutFolderId(folderId) {
                    var id = folderId != null && folderId != null ? folderId : -1;
                    if (id === ctrl.lastSavedFolderID) {
                        return;
                    }
                    ctrl.lastSavedFolderID = id;
                    folderService.setLastPopoutFolderID({folder_id:id}).then(
                        function (response) {
                            //console.log('Save last folder id ' + id);
                        },
                        function (reason) {
                            console.log('Could not set last folder id.');
                            console.log(reason);
                        }
                    );
                }

                // deprecated
                function getLastPopoutFolderId() {
                    return folderService.getLastPopoutFolderID().then(
                        function(response) {
                            ctrl.lastSavedFolderID = parseInt(response.data.folderId);
                        },
                        function(reason) {
                            console.error(reason);
                        }
                    );
                }

                function executeSuccessfulAdditionToFileCabinet(response, resourceToAdd) {
                    var folderObj = response.folder;
                    var addedResource = response.resource;
                    if (ctrl.addToNewFolder() && !ctrl.createNestedFolderEnabled) { // if we just added a new folder, update internal list and maps
                        ctrl.folderList.push(folderObj);
                        ctrl.folderIdToFolderObjMap[folderObj.id] = folderObj;
                        ctrl.addToExistingFolder(true);
                        ctrl.updateExistingFolderId(folderObj.id);
                    }
                    resourceToAdd.thumbnailInfo = {
                        src: addedResource.imgSrc,
                        alt: addedResource.titleText,
                        orientation: addedResource.imageOrientation
                    };
                    resourceToAdd.folderObj = resourceToAdd.folderObj || folderObj;
                    resourceToAdd.groupId = addedResource.group_id;
                    resourceToAdd.typeId = addedResource.rtype;
                    resourceToAdd.id = addedResource.id;
                    resourceToAdd.languageId = addedResource.book_language_id || addedResource.non_book_language_id;
                    resourceToAdd.assignable = addedResource.assignable;
                    setLastPopoutFolderId(folderObj.id);
                    ctrl.updateFileCabinetRibbon(resourceToAdd);
                }

                function executeUnsuccessfulAdditionToFileCabinet(reason, resourceToAdd) {
                    console.error(reason);
                    var failureMsg = "There was a problem. This resource may already be in this folder.";
                    displayAlertMsg(failureMsg);
                    if (resourceToAdd.folderObj) {
                        ctrl.activateRibbonForFolder(resourceToAdd.folderObj);
                    }
                }

                ctrl.sendAddResourceRequest = function() {
                    if (ctrl.createNestedFolderEnabled) {
                        ctrl.sendAddResourceRequestNew();
                    }
                    else {
                        ctrl.sendAddResourceRequestOld();
                    }
                };

                // deprecated
                ctrl.sendAddResourceRequestOld = function () {
                    var addToFolderName = ctrl.getCurrentFolderName();
                    validateFolderNameSelection(addToFolderName).then(function (validated) {
                        if (validated) {
                            var resourceToAdd = {
                                folderName: addToFolderName,
                                folderObj: ctrl.getCurrentFolderObj(),
                                nonbookId: ctrl.nonbook_popout_info.image_id,
                                languageId: 1
                            };

                            fileCabinetRibbonService.addToFileCabinet(resourceToAdd,
                                folderService.getResourceTypes().NON_BOOK)
                                .then(function success(response) {
                                    executeSuccessfulAdditionToFileCabinet(response, resourceToAdd);
                                })
                                .catch(function failure(reason) {
                                    executeUnsuccessfulAdditionToFileCabinet(reason, resourceToAdd);
                                });

                            ctrl.closePopout();
                        }
                    });
                };

                ctrl.sendAddResourceRequestNew = function () {
                    var resourceToAdd = {
                        folderName: null,
                        folderObj: selectedFolder,
                        nonbookId: ctrl.nonbook_popout_info.image_id,
                        languageId: 1
                    };

                    fileCabinetRibbonService.addToFileCabinet(resourceToAdd,
                        folderService.getResourceTypes().NON_BOOK)
                        .then(function success(response) {
                            executeSuccessfulAdditionToFileCabinet(response, resourceToAdd);
                        })
                        .catch(function failure(reason) {
                            executeUnsuccessfulAdditionToFileCabinet(reason, resourceToAdd);
                        });

                    ctrl.closePopout();

                };

                ctrl.updateFileCabinetRibbon = function (resourceToAddInfo) {
                    ctrl.currentResourceAdded = fileCabinetRibbonService.emitEventToFileCabinetRibbonScope("fileCabinetRibbon.update",
                        resourceToAddInfo);
                    ctrl.closePopout();
                };

                ctrl.activateRibbonForFolder = function (folderObj) {
                    fileCabinetRibbonService.emitEventToFileCabinetRibbonScope("fileCabinetRibbon.activate",
                        folderObj);
                };

                // deprecated
                function validateFolderNameSelection(untrimmedFolderName) {
                    return $q(function (resolve, reject) {
                        var trimmedFolderName = untrimmedFolderName.trim();
                        if (!trimmedFolderName) {
                            displayAlertMsg("A folder name is required. Please try again.");
                            resolve(false);
                        } else if (ctrl.addToNewFolder() &&
                            ctrl.folderNameToFolderObjMap[trimmedFolderName] !== undefined) {
                            var confirmId = 'confirm';
                            var alertMsg = "A folder called \"" + trimmedFolderName +
                                "\" already exists. Are you sure you want to create a new folder with this name?";
                            MessageBox.show({
                                message: alertMsg,
                                responses: [
                                    {
                                        subtle: true,
                                        label: 'Cancel'
                                    },
                                    {

                                        id: confirmId,
                                        confirm: true,
                                        label: 'OK'
                                    }
                                ]
                            }).then(function (response) {
                                if (response.id == confirmId) {
                                    resolve(true);
                                } else {
                                    resolve(false);
                                }
                            });
                        } else {
                            resolve(true);
                        }
                    });
                }

                function displayAlertMsg(alertMsg) {
                    MessageBox.show({
                        message: alertMsg,
                        responses: [{label: 'OK'}]
                    })
                }

                ctrl.showAddButton = function () {
                    if (fileCabinetRibbonService.ribbonActive()) {
                        ctrl.showAddToSection(false);
                        return true;
                    } else {
                        return false;
                    }
                };

                ctrl.onClickAddButton = function() {
                    if (!ctrl.currentResourceAdded){
                        ctrl.sendAddResourceRequest();
                    }
                };

                function showAssignButton() {
                    return (
                        ctrl.digitalResourcesAssignable &&
                        ctrl.nonbook_popout_info &&
                        ctrl.nonbook_popout_info.authorized
                    );
                }

                function assign() {
                    assignTargetedResource.show(ctrl.nonbook_popout_info.assign_action, ctrl.nonbook_popout_info.resource_id, 1, 0, ctrl.nonbook_popout_info.title)
                }

                function onSelectedFolderListItemChanged() {
                    var selectedFolderListItem = folderListItemAmbassador.getSelectedFolderListItem();
                    selectedFolder = selectedFolderListItem && !selectedFolderListItem.locked ? selectedFolderListItem : null;
                }

                ctrl.htmlToPlaintext = function(text) {
                    return text ? String(text).replace(/<[^>]+>/gm, '') : '';
                };
            }]);