"use strict";

angular.module('raz')
    .component('packTipPopout', {
        templateUrl: '/js/angular/book-grid/pack-tip-popout.html',
        controller: 'PackTipPopout',
        bindings: {
            packPath: '@'
        }
    })
    .controller('PackTipPopout',
        ['$scope', '$element', '$document', '$q', 'packTip', 'packTipProvider', 'fileCabinetRibbonService',
            'folderService', 'MessageBox', 'siteInfoProvider', 'loggedInProvider', 'onEllPageProvider', 'hasEllProvider',
            'assignTargetedResource', 'FeatureCheck', 'folderListItemAmbassador', 'ResourcePopout',
            function PackTipPopout($scope, $element, $document, $q, packTip, packTipProvider, fileCabinetRibbonService,
                                   folderService, MessageBox, siteInfoProvider, loggedInProvider, onEllPageProvider,
                                   hasEllProvider, assignTargetedResource, FeatureCheck, folderListItemAmbassador, ResourcePopout) {
            var ctrl = this;
            var selectedFolder = null;
            ctrl.isLoggedIn = loggedInProvider.isLoggedIn;
            ctrl.isRazPlus  = siteInfoProvider.isRazPlus;
            ctrl.onEllPage = onEllPageProvider.onEllPage;
            ctrl.hasEll = hasEllProvider.hasEll;
            ctrl.packTip = packTip;
            ctrl.showForTouch = false;
            ctrl.currentResourceAdded = false;
            ctrl.lastSavedFolderID = 0;
            ctrl.createNestedFolderEnabled = FeatureCheck.isFeatureEnabled("CREATE_NESTED_FOLDER_IN_POPOUT");
            ctrl.bookPopoutTargetSelector = '.pack-popout';
            ctrl.digitalResourcesAssignable = true;

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

            /* Lifecycle Hooks */

            ctrl.$onInit = function() {
                if (!ctrl.createNestedFolderEnabled) {
                    ctrl.existingFolderId = null;
                }
                ctrl.$bookGridContainer = $j('#bookGridApp').parent().parent();
                ctrl.resourcePopout = new ResourcePopout(ctrl.$bookGridContainer, ctrl.bookPopoutTargetSelector ,
                    ctrl.bookPopoutTargetSelector, ctrl.getDisplayInfo, ctrl.closePopout, $element, false, 'pack-tip-popout');
                $j(document).off('bookGridUpdate', 'pack-tip-popout');
                $j(document).on('bookGridUpdate', 'pack-tip-popout', function(){
                    ctrl.resourcePopout.enableEventTriggers();
                    ctrl.resourcePopout.overrideLinkClickForTouch();
                    ctrl.resourcePopout.closeIfClickedOutsidePopout();
                });
                if(typeof popUpTagName !== 'undefined')
                    popUpTagName = 'pack-tip-popout';

                if (fileCabinetRibbonService.ribbonActive()) {
                    var currentFolderObj = fileCabinetRibbonService.currentFolder();
                    ctrl.addToExistingFolder(true);
                    if (!ctrl.createNestedFolderEnabled) {
                        ctrl.updateExistingFolderId(currentFolderObj.id);
                    }
                    else {
                        selectedFolder = currentFolderObj;
                    }
                }
                $element.hide();
                ctrl.packTip.setPackData(packTipProvider);
                if (ctrl.createNestedFolderEnabled) {
                    folderListItemAmbassador.registerOnSelectedFolderListItemChanged($scope, onSelectedFolderListItemChanged);
                }
            };

            ctrl.$postLink = function() {
                ctrl.resourcePopout.enableEventTriggers();
                ctrl.resourcePopout.overrideLinkClickForTouch();
                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() {
                ctrl.tipId = ctrl.resourcePopout.currentPopoutTarget.dataQueryMap.id;
                if (fileCabinetRibbonService.ribbonActive()) {
                    ctrl.currentResourceAdded = fileCabinetRibbonService.bookAddedToFileCabinetRibbon(ctrl.tipId);
                }
                return $q.resolve(true);
            };

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

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

            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);
                    }
                );
            }

            var _showAddToSection = false;
            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;
            };

            ctrl.folderList = [];
            ctrl.folderNameToFolderObjMap = {};
            ctrl.folderIdToFolderObjMap = {};
            // 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);
                    }
                });
                //console.log("folderNameToFolderObjMap: %o", ctrl.folderNameToFolderObjMap);
                //console.log("folderIdToFolderObjMap: %o", ctrl.folderIdToFolderObjMap);
            }

            // 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();
                    });
            };

            var _addToExistingFolder = false;
            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;
                }
            };

            ctrl.newFolderName = "";
            ctrl.existingFolderName = "";
            // 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.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) {
                        // console.log("adding to file cabinet folder %s", addToFolderName);
                        var resourceToAdd = {
                            folderName: addToFolderName,
                            folderObj: ctrl.getCurrentFolderObj(),
                            isRkBook: 'false',
                            bookId: ctrl.tipId,
                            languageId: 1
                        };
                        // console.log("attempting to following resource %o to folder %s", resourceToAdd, addToFolderName);
                        fileCabinetRibbonService.addToFileCabinet(resourceToAdd, folderService.getResourceTypes().ELL_VOCABULARY_POWER_PACK)
                            .then(function success(response) {
                                var folderObj = response.folder;
                                var addedResource = response.resource;
                                if (ctrl.addToNewFolder()) { // 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);
                            }).catch(function failure(reason) {
                            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.closePopout();
                    }
                });
            };

            ctrl.sendAddResourceRequestNew = function() {
                var resourceToAdd = {
                    folderName: null,
                    folderObj: selectedFolder,
                    isRkBook: 'false',
                    bookId: ctrl.tipId,
                    languageId: 1
                };
                fileCabinetRibbonService.addToFileCabinet(resourceToAdd, folderService.getResourceTypes().ELL_VOCABULARY_POWER_PACK)
                    .then(function success(response) {
                        var folderObj = response.folder;
                        var addedResource = response.resource;
                        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);
                    }).catch(function failure(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.closePopout();
            };

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

            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);
                    }
                });

            }

            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 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 checkAuthorizedForEll() {
                if (ctrl.onEllPage) {
                    return ctrl.hasEll;
                }

                return true;
            }

            function showAssignButton() {
                return ctrl.isRazPlus && ctrl.isLoggedIn && checkAuthorizedForEll();
            }

            function assign() {
                assignTargetedResource.show("getVppIds", ctrl.tipId, 1, 27, ctrl.packTip.getName(ctrl.tipId))
            }

            function showFileCabinetAddToButton() {
                return ctrl.isLoggedIn && checkAuthorizedForEll();
            }

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