(function() {
    "use strict";

    angular
        .module('shared')
        .component('everyoneFolders', {
            templateUrl: '/shared/js/angular/file-cabinet/everyone-folders.html',
            controller: 'EveryoneFolders'
        })
        .controller('EveryoneFolders', ['folders', 'currentSubFolders', 'folderService','folderTreeViewService','messageHandler','fileCabinetDragAndDropService',
            function EveryoneFoldersController(folders, currentSubFolders, folderService, folderTreeViewService,messageHandler,fileCabinetDragAndDropService) {
                var ctrl = this;
                ctrl.initialRead = false;
                ctrl.models = {listName: "EveryoneFiles", items: [], selected: null, dragging: false};
                var currentLocation = fileCabinetDragAndDropService.source.myFolders;

                ctrl.$onInit = function() {
                    if (folders.getIsLiteracyEditor() || folders.getLoadLiteracyCurriculumMapFirst()) {
                        ctrl.clickedEveryoneFiles();
                    }
                };

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

                ctrl.getTitle = function() {
                    return folders.getLiteracyTypeName();
                };

                ctrl.getIsLC = function () {
                    return folders.getIsLC();
                };

                ctrl.getFolderClassName = function (folder) {
                    var cf = currentSubFolders.getCurrentFolder();
                    if (cf == null || folder == null) {
                        return '';
                    }
                    if (folder.id != cf.id) {
                        return '';
                    }
                    return 'is-selected';
                };

                ctrl.getFolderClassName = function(folder) {
                    return 'js-everyone-' + folder.id;
                };

                ctrl.keyDown = function(event,folder) {
                    folderTreeViewService.keyDown(event,folder);
                };

                ctrl.getAriaExpanded = function(folder) {
                    return folder.folderOpen == true ? 'true' : 'false';
                };

                ctrl.getAriaSelected = function(folder) {
                    if (folder.selected == undefined || !folder.selected) {
                        return undefined;
                    }
                    return 'true';
                };

                ctrl.toggleOpen = function(folder) {
                    folder.folderOpen = !folder.folderOpen;
                };

                ctrl.getReadingFolders = function() {
                    return folderService.getReadingFolders();
                };

                ctrl.getStyle = function (folder) {
                    var tot = 1;
                    if (folder != null && folder.folderOpen) {
                        tot += currentSubFolders.countOpenSubfolders(folder.children);
                    }
                    var h = (tot * 40) + 'px';
                    var l = ((folder.depth - 1) * 15 + 10) + 'px';
                    var styleObj = {maxHeight: h, overflow: "auto", paddingLeft: l};
                    return styleObj;
                };

                ctrl.getFolders = function () {
                    if (!ctrl.initialRead) {
                        ctrl.initialRead = true;
                        //initialClickEveryoneFiles();
                    }
                    return folders.getEveryoneFolders();
                };

                ctrl.getAreFoldersPublic = function () {
                    return currentSubFolders.getAreFoldersPublic();
                };

                ctrl.getAreFoldersForEveryone = function () {
                    return currentSubFolders.getAreFoldersForEveryone();
                };

                ctrl.clickedEveryoneFiles = function() {
                    folderService.setReadingFolders(true);
                    folders.getEveryoneFoldersPromise().then(
                        function (response) {
                            currentSubFolders.setAreFoldersMine(false);
                            currentSubFolders.setAreFoldersPublic(false);
                            currentSubFolders.setAreFoldersForEveryone(true);
                            currentSubFolders.setLastFolderID(null);
                            currentSubFolders.setCurrentSubFolders(null, "everyone");
                            ctrl.localFolders = null;
                            folderService.setReadingFolders(false);
                        },
                        function (reason) {
                            folderService.setReadingFolders(false);
                            messageHandler.publishError('Could not read folders');
                        }
                    );
                };

                ctrl.setCurrentSubFolders = function (folder, type) {
                    currentSubFolders.setCurrentSubFolders(folder, 'everyone');
                    currentSubFolders.setAreFoldersMine(false);
                    currentSubFolders.setAreFoldersPublic(false);
                    currentSubFolders.setAreFoldersForEveryone(true);
                    currentSubFolders.setLastFolderID(folder);
                };

                ctrl.hasBottomSeparator = function(folder, last) {
                    return last && !(folder.folderOpen && folder.children && folder.children.length > 0);
                };

                ctrl.hasLastSeparator = function(folder, index) {
                    return isLastRootFolder(folder, index) && folder.children && folder.children.length > 0 && folder.folderOpen;
                };

                /*********************************************************************************
                 * The following functions are for the Drag and Drop Re-arrange List functionality
                 * dnd library callbacks in shared
                 ***********************************************************************************/

                // Functions for dnd-draggable

                ctrl.onDragOrderList = function(draggingFolder, index) {
                    // Only allowing drag ordering for same type list items
                    if (fileCabinetDragAndDropService.isDraggingFrom(currentLocation)){
                        var moveToIndex = fileCabinetDragAndDropService.getMoveToIndex();

                        if (fileCabinetDragAndDropService.isInsert()) {
                            var targetFolderId = fileCabinetDragAndDropService.getTargetFolderId();
                            if (draggingFolder.id !== targetFolderId && draggingFolder.parent_resource_collection_id !== targetFolderId) {
                                folders.moveFolder(draggingFolder.id, targetFolderId, moveToIndex, false, false, true, null,true).then(function() {
                                    currentSubFolders.setCurrentSubFolders(fileCabinetDragAndDropService.getTargetFolder(), "everyone");
                                });
                            }
                        }
                        else if (fileCabinetDragAndDropService.isRootInsert()) {
                            if (draggingFolder.parent_resource_collection_id) {
                                folders.moveFolder(draggingFolder.id, -1, moveToIndex, false, false, true, null,true);
                            }
                        }
                        else {
                            var folderId = fileCabinetDragAndDropService.isRootSort() ? -1 : fileCabinetDragAndDropService.getTargetFolderParentId();
                            var position = moveToIndex;
                            if (index < moveToIndex && !isDraggingFromDifferentParent(draggingFolder, folderId)) {
                                position = moveToIndex - 1;
                            }
                            folders.moveFolder(draggingFolder.id, folderId, position, false, false, true, null,true);
                        }
                    }
                    fileCabinetDragAndDropService.resetDraggingItem();
                };

                ctrl.onSelected = function(draggingFolder) {
                    ctrl.models.selected = draggingFolder;
                };

                ctrl.onCanceled = function() {
                    fileCabinetDragAndDropService.resetDraggingItem();
                };

                ctrl.onDragStart = function(draggingFolder) {
                    fileCabinetDragAndDropService.setSourceLocation(currentLocation);
                    fileCabinetDragAndDropService.setDraggingFolder(draggingFolder);
                };

                var isDraggingFromDifferentParent = function(draggingFolder, targetFolderId) {
                    return !draggingFolder.parent_resource_collection_id && targetFolderId !== -1 ||
                        (draggingFolder.parent_resource_collection_id && (draggingFolder.parent_resource_collection_id !== targetFolderId));
                };

                // Functions for dnd-list

                ctrl.onDragOverSeparator = function(event) {
                    fileCabinetDragAndDropService.setDropLocation(currentLocation);
                    fileCabinetDragAndDropService.cancelTimeout();
                    var dragoverElement = angular.element(event.target).closest('.dndDragover');
                    fileCabinetDragAndDropService.resetDragover(dragoverElement);

                    if (!fileCabinetDragAndDropService.isDraggingFrom(currentLocation)) {
                        return false;
                    }
                    return true;
                };

                var isLastRootFolder = function(folder, index) {
                    if (ctrl.folderList == undefined) {
                        return false;
                    }
                    if (!folder.parent_resource_collection_id) {
                        return (index + 1) == ctrl.folderList.length;
                    }
                    return false;
                };

                ctrl.onDragOverFolder = function(targetFolder, event) {
                    fileCabinetDragAndDropService.setDropLocation(currentLocation);
                    fileCabinetDragAndDropService.onDragOverFolder(targetFolder);
                    var dragoverElement = angular.element(event.target).closest('.dndDragover');
                    fileCabinetDragAndDropService.resetDragover(dragoverElement);

                    if (!targetFolder.folderOpen && targetFolder.children && targetFolder.children.length > 0) {
                        fileCabinetDragAndDropService.setToggleOpenFolderPromise(targetFolder);
                    }

                    if (!fileCabinetDragAndDropService.isDropAllowed(targetFolder)) {
                        return false;
                    }
                    return true;
                };

                ctrl.onDragOverMyFiles = function(event) {
                    fileCabinetDragAndDropService.setDropLocation(currentLocation);
                    var dragoverElement = angular.element(event.target).closest('.dndDragover');
                    fileCabinetDragAndDropService.resetDragover(dragoverElement);

                    if (fileCabinetDragAndDropService.isResourceDragging()){
                        return false;
                    }

                    return true;
                };

                ctrl.onDropSort = function(targetFolder, index) {
                    var targetInsertFolder = null;
                    var targetInsertMoveType = fileCabinetDragAndDropService.move.rootSort;
                    if (targetFolder.parent_resource_collection_id) {
                        targetInsertFolder = targetFolder;
                        targetInsertMoveType = fileCabinetDragAndDropService.move.parentSort;
                    }

                    fileCabinetDragAndDropService.setDropDetails(currentLocation, index, targetInsertMoveType, targetInsertFolder);
                    return true;
                };

                ctrl.onDropInsert = function(targetFolder) {
                    fileCabinetDragAndDropService.setDropDetails(currentLocation, 0, fileCabinetDragAndDropService.move.insert, targetFolder);
                    return true;
                };

                ctrl.onDropRootInsert = function() {
                    fileCabinetDragAndDropService.setDropDetails(currentLocation, 0, fileCabinetDragAndDropService.move.rootInsert, null);
                    return true;
                };


            }]);
}());