(function() {
    "use strict";

    angular
        .module('shared')
        .component('fileCabinetRibbon', {
            templateUrl: '/shared/js/angular/file-cabinet-ribbon/file-cabinet-ribbon.html',
            controller: 'FileCabinetRibbon',
            bindings: {
                clearOnInit : '@'
            }
        })
        .controller('FileCabinetRibbon',
            ['$scope', 'fileCabinetRibbonService', '$q', 'resourceList', 'AssignResources', 'MessageBox', 'folders', 'subjects', 'loggedInInfo',
                function FileCabinetRibbonCtrl($scope, fileCabinetRibbonService, $q, resourceList, AssignResources, MessageBox, folders, subjects, loggedInInfo) {
                    var self = this;

                    self.$onInit = function () {
                        $scope.$on('fileCabinetRibbon.update', function (event, resourceToAddInfo) {
                            //console.log('received signal to updateFileCabinetRibbon from book-popout: %o', resourceToAddInfo);
                            self.updateFileCabinetRibbon(resourceToAddInfo);
                        });
                        $scope.$on('fileCabinetRibbon.activate', function (event, folderObj) {
                            //console.log('received signal to activateRibbonForFolder : %o', folderObj);
                            self.activateRibbonForFolder(folderObj);
                        });
                        self.clearOnInit === 'true' ? self.closeRibbon() : self.activateRibbonIfPreviouslyOpen();
                        fileCabinetRibbonService.registerFileCabinetRibbonScope($scope);
                    };

                    self.getViewInFileCabinetLink = function() {
                        switch (folders.getSubjectName()) {
                            case subjects.SCIENCE_SUBJECT_NAME:
                                return '/main/FileCabinet/?id=';
                            case subjects.READING_SUBJECT_NAME:
                            default:
                                return '/file-cabinet/?id=';
                        }
                    };

                    self.userLoggedIn = function () {
                        return Object.keys(loggedInInfo).length > 0;
                    };

                    self.activateRibbonIfPreviouslyOpen = function () {
                        if (self.userLoggedIn()) {
                            var sessionFolderObj = self.sessionFolderUtil.getFolder();
                            if (sessionFolderObj) {
                                //console.log('ribbon was open, reopening using folder %o', sessionFolderObj);
                                self.activateRibbonForFolder(sessionFolderObj);
                            }
                        } else {
                            self.sessionFolderUtil.clearFolder();
                        }
                    };

                    self.canAddToRibbonFromCurrentPage = function () {
                        if (jQuery('book-popout, file-cabinet-nonbook-popout, add-to-button').length) {
                            return true;
                        } else {
                            //console.log('cannot add resources to the ribbon from this page');
                            return false;
                        }
                    };

                    self.sessionFolderUtil = {
                        setFolder: function (folderObj) {
                            if (folderObj) {
                                sessionStorage.fileCabinetRibbonFolder = JSON.stringify(folderObj);
                            }
                        },
                        getFolder: function () {
                            if (sessionStorage.fileCabinetRibbonFolder) {
                                return JSON.parse(sessionStorage.fileCabinetRibbonFolder);
                            } else {
                                return null;
                            }
                        },
                        clearFolder: function () {
                            sessionStorage.fileCabinetRibbonFolder = '';
                        }
                    };

                    self.fileCabinetRibbonService = fileCabinetRibbonService;

                    self.folderModel = {
                        folderObj: null,
                        resourceList: []
                    };

                    self.currentFolderAssignable = function () {
                        if (folders.getIsLiteracyEditor()) {
                            return false;
                        }
                        try {
                            self.folderModel.resourceList.forEach(function (resource) {
                                if (resource.assignable) {
                                    throw 'foundAssignable';
                                }
                            });
                        } catch (foundAssignable) {
                            return true;
                        }
                        return false;
                    };

                    self.getHasRazPlus = function() {
                        return folders.getHasRazPlus();
                    };

                    self.getHasSaz = function() {
                        return folders.getHasSaz();
                    };

                    self.updateFileCabinetRibbon = function (resourceToAddInfo) {
                        if (folders.isScienceSubject()) {
                            self.activateRibbonForFolder(resourceToAddInfo.folderObj);
                        } else if (fileCabinetRibbonService.ribbonActive() && !fileCabinetRibbonService.getFromLandingPage()) {
                            self.addResourceToCurrentFolder(resourceToAddInfo);
                        } else {
                            self.activateRibbonForFolder(resourceToAddInfo.folderObj);
                        }
                    };

                    self.activateRibbonForFolder = function (folderObj) {
                        // folderObj should NEVER be undefined OR null
                        self.folderModel.folderObj = folderObj;
                        fileCabinetRibbonService.ribbonActive(true);
                        self.populateCurrentFolderResources()
                            .then(function success() {
                                self.sessionFolderUtil.setFolder(folderObj);
                            }).catch(function failure() {
                                fileCabinetRibbonService.ribbonActive(false);
                                console.error("Could not open/update the file cabinet ribbon");
                            });
                    };

                    self.populateCurrentFolderResources = function () {
                        //console.log('Getting resources for folder %o', self.folderModel.folderObj);
                        return fileCabinetRibbonService.getFileCabinetFolderResources(self.folderModel.folderObj.id)
                            .then(function success(currentFolderResources) {
                                //console.log("received resources in current folder: %o", currentFolderResources);
                                var newResources = [];
                                currentFolderResources.forEach(function (resource) {
                                    var processedRibbonResource = {
                                        bookId: resource.book_id,
                                        nonbookId: resource.non_book_id,
                                        packId: resource.pack_id,
                                        materialId : resource.material_id,
                                        folderObj: self.folderModel.folderObj,
                                        thumbnailInfo: {
                                            src: resource.imgSrc,
                                            alt: resource.titleText,
                                            orientation: resource.imageOrientation
                                        },
                                        groupId: resource.group_id,
                                        typeId: resource.rtype,
                                        links: resource.links,
                                        id: resource.id,
                                        languageId: resource.book_language_id || resource.non_book_language_id || resource.material_language_id,
                                        assignable: resource.assignable,
                                        resourceIDs: resource.resourceIDs
                                    };
                                    newResources.push(processedRibbonResource);
                                });
                                self.folderModel.resourceList = newResources;
                                return null;
                            }).catch(function failure() {
                                console.error("Could not get resource list from the folder specified");
                                return $q.reject();
                            });
                    };

                    self.addResourceToCurrentFolder = function (resourceToAddInfo) {
                        self.folderModel.resourceList.unshift(resourceToAddInfo);
                    };

                    self.removeResourceFromCurrentFolder = function (resource) {
                        //console.log('attempting to remove resource %o', resource);
                        var removeResourceId = 'removeResource';
                        MessageBox.show({
                            message: 'Are you sure you want to remove this resource?',
                            responses: [
                                {
                                    subtle: true,
                                    label: 'Cancel'
                                },
                                {
                                    id: removeResourceId,
                                    confirm: true,
                                    label: 'Remove Resource'
                                }

                            ]
                        }).then(function (response) {
                            if (response.id == removeResourceId) {
                                fileCabinetRibbonService.removeFromFileCabinet(resource).then(function () {
                                    //console.log('removing %o from current folder', resource);
                                    var removalIdx = self.folderModel.resourceList.reduce(function (prev, curr, idx) {
                                        return (curr.id == resource.id)? idx : prev;
                                    }, null);
                                    self.folderModel.resourceList.splice(removalIdx, 1);
                                });
                            }
                        });
                    };

                    self.displayResourceList = true;
                    self.toggleDisplayResourceList = function () {
                        self.displayResourceList = !self.displayResourceList;
                    };

                    self.saveAndAssignResources = function () {
                        //console.log("saving and assigning resources");
                        var currentFolderId = self.folderModel.folderObj.id;
                        var currentFolderName = self.folderModel.folderObj.name;
                        fileCabinetRibbonService.getFileCabinetAssignableFolderResources(currentFolderId)
                            .then(function (assignableResourceList) {
                                //console.log("assignable resources in current folder: %o", assignableResourceList);
                                resourceList.setResources(assignableResourceList);
                                resourceList.setAssignmentTitle(currentFolderName);
                                AssignResources.show();
                            }).catch(function (reason) {
                            console.error("couldn't open the \"Save and Assign\" lightwindow");
                        });
                    };

                    self.closeRibbon = function () {
                        self.clearFileCabinetRibbon();
                        fileCabinetRibbonService.ribbonActive(false);
                        self.sessionFolderUtil.clearFolder();
                    };

                    self.clearFileCabinetRibbon = function () {
                        self.folderModel = {
                            folderObj: null,
                            resourceList: []
                        };
                    };

                }])
}());