"use strict";

angular.module('raz')

    .component('bookPopout', {
        templateUrl: '/js/angular/book-grid/book-popout.html',
        controller: 'BookPopout',
        bindings: {
            fromSearchResults : '@'
        }
    })
    .controller('BookPopout',
        ['$scope', 'bookTipInfoService', 'fileCabinetRibbonService', '$sce', '$q', '$element', '$document',
            'MessageBox', 'folderService', 'assignTargetedResource', 'FeatureCheck', 'messageHandler',
            'folderListItemAmbassador', 'ResourcePopout','folders',
            function BookPopoutCtrl($scope, bookTipInfoService, fileCabinetRibbonService, $sce, $q, $element, $document,
                                    MessageBox, folderService, assignTargetedResource, FeatureCheck, messageHandler,
                                    folderListItemAmbassador, ResourcePopout, folders) {
            var ctrl = this;
            var selectedFolder = null;
            ctrl.lastSavedFolderID = 0;
            ctrl.createNestedFolderEnabled = FeatureCheck.isFeatureEnabled("CREATE_NESTED_FOLDER_IN_POPOUT");
            ctrl.bookTipInfo = {};
            ctrl.bookPopoutTargetSelector = '.bookPopout';
            ctrl.mouseLeaveTargetSelector = (ctrl.fromSearchResults) ? 'div.photo' : ctrl.bookPopoutTargetSelector;
            ctrl.digitalResourcesAssignable = true;
            ctrl.currentResourceAdded = false;

            ctrl.showAssignButton = showAssignButton;
            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.mouseLeaveTargetSelector, ctrl.getDisplayInfo, ctrl.closePopout, $element, ctrl.fromSearchResults, 'book-popout');
                $j(document).off('bookGridUpdate', 'book-popout');
                $j(document).on('bookGridUpdate', 'book-popout', function(){
                    ctrl.resourcePopout.enableEventTriggers();
                    ctrl.resourcePopout.overrideLinkClickForTouch();
                    ctrl.resourcePopout.closeIfClickedOutsidePopout();
                   return false;
                });
                if(typeof popUpTagName !== 'undefined')
                    popUpTagName = 'book-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.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() {
                var currentPopoutTarget = ctrl.resourcePopout.currentPopoutTarget;
                if (fileCabinetRibbonService.ribbonActive()) {
                    ctrl.currentResourceAdded = fileCabinetRibbonService.bookAddedToFileCabinetRibbon(currentPopoutTarget.dataQueryMap.id);
                }
                return bookTipInfoService.fetchBookTipInfo(currentPopoutTarget.dataQueryString).then(function success(response) {
                    ctrl.bookTipInfo = response.data;
                    ctrl.touchDeviceLinks = response.data.touchDeviceLinks;
                    ctrl.digitalResourcesAssignable = !!response.data.digitalResourcesAssignable;
                    ctrl.bookTipInfo.languageId = ctrl.resourcePopout.currentPopoutTarget.dataQueryMap.language_id || 1;
                    ctrl.bookTipInfo.summary = $sce.trustAsHtml(ctrl.bookTipInfo.summary+'');
                    return true;
                });
            };

            ctrl.getResourceType = function() {
                var resourceType = [];
                if (ctrl.bookTipInfo.categoryDisplayName) {
                    resourceType.push(ctrl.bookTipInfo.categoryDisplayName);
                }
                return $sce.trustAsHtml(resourceType.join());
            };

            ctrl.getResourceLevel = function() {
                var resourceLevel = [];
                if (ctrl.bookTipInfo.levelIndicatorMsg) {
                    resourceLevel.push(ctrl.bookTipInfo.levelIndicatorMsg);
                }
                if (ctrl.bookTipInfo.multilevelBookMsg) {
                    resourceLevel.push(ctrl.bookTipInfo.multilevelBookMsg);
                }
                if (ctrl.bookTipInfo.languageId == "1" && ctrl.bookTipInfo.lexile != null) {
                    resourceLevel.push('Lexile ' + ctrl.bookTipInfo.lexile);
                }
                return $sce.trustAsHtml(resourceLevel.join('<span class="resourcePopover_pipe">|</span>'));
            }

            ctrl.getMetadataString = function () {
                var stringElements = [];
                if (ctrl.bookTipInfo.bookTypeInfo) {
                    stringElements.push(ctrl.bookTipInfo.bookTypeInfo);
                }
                return $sce.trustAsHtml(stringElements.join());
            };

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

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

            // deprecated
            ctrl.populateFolderInfo = function () {
                return fileCabinetRibbonService.getFileCabinetFolderList()
                    .then(function success(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.addResourceButtonEnabled = function () {
                if (ctrl.createNestedFolderEnabled) {
                    return !!selectedFolder && selectedFolder.isChecked;
                } else if (ctrl.addToNewFolder()) {
                    return !!ctrl.newFolderName;
                } else { // add to Existing Folder
                    return !!ctrl.existingFolderId;
                }
            };

            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(),
                            isRkBook: ctrl.bookTipInfo['rkBookId'] !== undefined,
                            bookId: ctrl.bookTipInfo['bookId'] || ctrl.bookTipInfo['rkBookId'],
                            languageId: ctrl.bookTipInfo.languageId
                        };
                        fileCabinetRibbonService.addToFileCabinet(resourceToAdd, folderService.getResourceTypes().LANDINGPAGE)
                            .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: ctrl.bookTipInfo['rkBookId'] !== undefined,
                    bookId: ctrl.bookTipInfo['bookId'] || ctrl.bookTipInfo['rkBookId'],
                    languageId: ctrl.bookTipInfo.languageId
                };
                fileCabinetRibbonService.addToFileCabinet(resourceToAdd, folderService.getResourceTypes().LANDINGPAGE)
                    .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) {
                        console.log(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.resourcePopout.currentPopoutTarget.dataQueryMap.id);
            };

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

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

            // 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 onSelectedFolderListItemChanged() {
                var selectedFolderListItem = folderListItemAmbassador.getSelectedFolderListItem();
                selectedFolder = selectedFolderListItem && !selectedFolderListItem.locked ? selectedFolderListItem : null;
            }

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

            function assign() {
                assignTargetedResource.show(ctrl.bookTipInfo.bookAssignInfo.assignAction,
                    ctrl.bookTipInfo.bookAssignInfo.kids_book_id, ctrl.bookTipInfo.bookAssignInfo.languageId,
                    ctrl.bookTipInfo.bookAssignInfo.bookroomCollectionId, ctrl.bookTipInfo.title)
            }
        }]);