(function() {
    "use strict";

    angular
        .module('shared')
        .component('selectedFolder', {
            templateUrl: '/shared/js/angular/file-cabinet/selected-folder.html',
            controller: 'SelectedFolder'
        })
        .controller('SelectedFolder',
            ['folders', 'currentSubFolders', 'folderService', 'MessageBox', '$timeout', 'messageHandler',
                'fileCabinetDragAndDropService', '$scope', '$sce',
                function SelectedFolderCtrl(folders, currentSubFolders, folderService, MessageBox, $timeout,
                                            messageHandler, fileCabinetDragAndDropService, $scope, $sce) {
                    var ctrl = this;
                    var newFolder = null;
                    var showProgress = false;
                    var timerRunning = false;
                    var currentLocation = fileCabinetDragAndDropService.source.selectedFolder;

                    var keyboardKeys = {
                        tab: 9,
                        enter: 13,
                        space: 32
                    };

                    ctrl.$onInit = function () {
                        ctrl.models = {listName: "MyFiles", items: [], selected: null, dragging: false};
                        ctrl.folders = folders.getMyFolders();
                        currentSubFolders.registerOnCurrentFolderChanged($scope, onCurrentFolderChanged);
                        onCurrentFolderChanged();
                    };

                    ctrl.showNotReadyForProd = function(data) {
                        return currentSubFolders.getAreFoldersForEveryone() &&
                            folders.getIsLiteracyEditor() &&
                            data['ready_for_prod'] &&
                            data['ready_for_prod'] == 'n';
                    };


                    var onCurrentFolderChanged = function() {
                        ctrl.currentSubFolders = [];
                        $timeout(function() {
                            ctrl.currentSubFolders = currentSubFolders.getCurrentSubFolders();
                        });
                    };

                    ctrl.keyDown = function(event,folder) {
                        if (event.target != null) {
                            var element = $j(event.target);
                            if (element.hasClass('js-skip-folder-select')) {
                                return;
                            }
                        }
                        if (event.keyCode != keyboardKeys.enter && event.keyCode != keyboardKeys.space) {
                            return;
                        }
                        event.preventDefault();
                        ctrl.selectFolder(folder);
                    };

                    ctrl.newFolderKeyDown = function(event) {
                        event.stopPropagation();
                        return;
                    };

                    ctrl.sharingMessage = function (folder) {
                        var shareWord = folder.shared_with;
                        if (shareWord == 'teachers') {
                            shareWord = 'selected teachers';
                        }
                        return shareWord;
                    };

                    ctrl.getReadingResources = function () {
                        var ret = folderService.getReadingResources();
                        if (!ret) {
                            timerRunning = false;
                            showProgress = false;
                        }
                        else {
                            if (!timerRunning) {
                                timerRunning = true;
                                var timer = $timeout(function () {
                                    showProgress = true;
                                    timerRunning = false;
                                }, 400);
                            }
                        }
                        return ret;
                    };

                    ctrl.getShowProgress = function () {
                        return showProgress;
                    };

                    ctrl.isNew = function (folder) {
                        return folder.id === null || folder.id < 0;
                    };

                    ctrl.getFolderClassName = function (folder) {
                        var ret = folder.is_lesson_plan == 'y' ? 'FC_lessonPlan' : '';
                        if (folder.locked) {
                            ret = ret + ' ' + 'is-assigned';
                        }
                        return ret;
                    };

                    ctrl.anyFolders = function () {
                        return ctrl.currentSubFolders != null && ctrl.currentSubFolders.length > 0;
                    };

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

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

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

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

                    ctrl.getSelectedFolderID = function () {
                        return folderService.getCurrentFolderID();
                    };

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

                    ctrl.saveNewFolder = function (folder) {
                        var parentID = 0;
                        if (folder.parent_resource_collection_id && folder.parent_resource_collection_id > 0) {
                            parentID = folder.parent_resource_collection_id;
                        }
                        //var shared = folder.is_shared == 'y' ? 1 : 0;
                        var data = {
                            parent_id: parentID,
                            folderName: folder.name,
                            shared_with: folder.shared_with,
                            isEveryone: currentSubFolders.getAreFoldersForEveryone(),
                            literacyTypeId: folders.getLiteracyTypeId()
                        };
                        var url = "/api/filecabinet/folder";
                        newFolder = folder;
                        folderService.saveNewFolder(data).then(
                            function (response) {
                                var result = response.data;
                                if (result === "0") {
                                    messageHandler.publishError('Could not save new folder name.');
                                }
                                else if (newFolder != null) {
                                    newFolder.id = result; // result is primary key
                                }
                            },
                            function (reason) {
                                messageHandler.publishError('Could not save new folder name.');
                            }
                        );
                    };

                    // This folder is not yet in the database.
                    ctrl.deleteNewFolder = function () {
                        var ar = currentSubFolders.getCurrentSubFolders();
                        var parent = currentSubFolders.getCurrentFolder();
                        if (parent != null) {
                            ar = parent.children;
                        }
                        var idx = 0;
                        for (idx = 0; idx < ar.length; idx++) {
                            if (ar[idx].id < 0) {
                                break;
                            }
                        }
                        ar.splice(idx, 1);
                    };

                    ctrl.editFolderNameBlur = function (folder) {
                        if (folder.name == null || folder.name.trim().length < 1 || folder.originalName == folder.name) {
                            ctrl.cancelEditedFolderName(folder);
                            return;
                        }
                        ctrl.saveEditedFolderName(folder);
                    };

                    ctrl.editFolderNameFormSubmit = function (folder) {
                        if (folder.name == null || folder.name.trim().length < 1) {
                            return;
                        }
                        if (folder.originalName == folder.name) {
                            ctrl.cancelEditedFolderName(folder);
                            return;
                        }
                        ctrl.saveEditedFolderName(folder);
                    };

                    ctrl.saveEditedFolderName = function (folder) {
                        folder.name = folderService.ansiOnly(folder.name);
                        if (folder.name == null || folder.name.trim().length < 1) {
                            ctrl.cancelEditedFolderName(folder);
                            return;
                        }
                        var rf = folder.name.replace(/[^\x00-\xFF]/g, "");
                        folder.name = rf;
                        var duplicateName = false;
                        var cf = currentSubFolders.getCurrentSubFolders();
                        for (var counter = 0; counter < cf.length; counter++) {
                            if (folder.id == cf[counter].id) {
                                continue;
                            }
                            if (folder.name.trim().toUpperCase() == cf[counter].name.trim().toUpperCase()) {
                                duplicateName = true;
                                break;
                            }
                        }
                        if (duplicateName && !ctrl.messageBoxOpen) {
                            ctrl.messageBoxOpen = true;
                            MessageBox.show({
                                message: 'Another folder named "' + folder.name +
                                    '" already exists in this location.  Do you wish to continue?',
                                responses: [
                                    {
                                        subtle: true,
                                        id: 'cancelRename',
                                        label: 'Cancel'
                                    },
                                    {
                                        id: 'continueRename',
                                        confirm: true,
                                        label: 'Continue'
                                    }
                                ]
                            }).then(function (response) {
                                ctrl.messageBoxOpen = false;
                                if (response.id == 'continueRename') {
                                    ctrl.completeSaveEditedFolderName(folder);
                                }
                                else {
                                    ctrl.cancelEditedFolderName(folder);
                                }
                            });
                        }
                        else if (!ctrl.messageBoxOpen) {
                            ctrl.completeSaveEditedFolderName(folder);
                        }
                    };

                    ctrl.completeSaveEditedFolderName = function (folder) {
                        if (folder.id < 0) {
                            ctrl.saveNewFolder(folder);
                        }
                        else {
                            var data = {
                                folder_id: folder.id,
                                folderName: folder.name,
                                isEveryone: currentSubFolders.getAreFoldersForEveryone()
                            };
                            folderService.completeSaveEditedFolderName(data).then(
                                function (response) {
                                    var result = response.data;
                                    if (result === "0") {
                                        messageHandler.publishError('Could not save folder name.');
                                    }
                                    else if (newFolder != null) {
                                        newFolder.id = result; // result is primary key
                                    }
                                },
                                function (reason) {
                                    messageHandler.publishError('Could not save folder name.');
                                }
                            );
                        }
                        folder.originalName = null;
                        folder.editMode = false;
                    };

                    ctrl.cancelEditedFolderName = function (folder) {
                        folder.editMode = false;
                        if (folder.originalName != null) {
                            folder.name = folder.originalName;
                            folder.originalName = null;
                        }
                        if (folder.id < 0) {
                            ctrl.deleteNewFolder(folder);
                        }
                    };

                    // Clicking inside edit box would trigger folder selection
                    ctrl.clickedInsideFolderEdit = function () {
                        currentSubFolders.setSkipSelect(true);
                    };

                    ctrl.selectFolder = function (folder) {
                        if (!currentSubFolders.getSkipSelect() && !currentSubFolders.getMovePopoverOpen()) {
                            var pp = '';

                            if (currentSubFolders.getAreFoldersForEveryone()) {
                                pp = 'everyone';
                            } else if (currentSubFolders.getAreFoldersPublic()) {
                                pp = 'public';
                            } else {
                                pp = 'private';
                            }

                            currentSubFolders.setLastFolderID(folder);
                            currentSubFolders.setCurrentSubFolders(folder, pp);
                        }
                        else {
                            currentSubFolders.setSkipSelect(false);
                        }
                    };

                    ctrl.trustAsHtml = function(html) {
                        return $sce.trustAsHtml(html);
                    };

                    /*********************************************************************************
                     * 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) {
                        var moveToIndex = fileCabinetDragAndDropService.getMoveToIndex();

                        if (fileCabinetDragAndDropService.isInsert()) {
                            var targetFolderId = fileCabinetDragAndDropService.getTargetFolderId();
                            if (draggingFolder.id !== targetFolderId) {
                                folders.moveFolder(draggingFolder.id, targetFolderId, moveToIndex, false, false, currentSubFolders.getAreFoldersForEveryone(), null,currentSubFolders.getAreFoldersForEveryone());
                            }
                        }
                        else if (fileCabinetDragAndDropService.isRootInsert()) {
                            if (draggingFolder.parent_resource_collection_id) {
                                folders.moveFolder(draggingFolder.id, -1, moveToIndex, false, false, currentSubFolders.getAreFoldersForEveryone(), null,currentSubFolders.getAreFoldersForEveryone());
                            }
                        }
                        else {
                            var folderId = fileCabinetDragAndDropService.isRootSort() ? -1 : fileCabinetDragAndDropService.getTargetFolderParentId();
                            var position = index < moveToIndex ? moveToIndex - 1 : moveToIndex;
                            folders.moveFolder(draggingFolder.id, folderId, position, false, false, currentSubFolders.getAreFoldersForEveryone(), null,currentSubFolders.getAreFoldersForEveryone());
                        }
                        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);
                    };

                    // Functions for dnd-list

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

                        if(!(fileCabinetDragAndDropService.isDraggingFrom(currentLocation) ||
                            fileCabinetDragAndDropService.isResourceDragging())) {
                            return false
                        }
                        if (!fileCabinetDragAndDropService.isDropAllowed(targetFolder)) {
                            return false;
                        }

                        return true;
                    };

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

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

                        return true;
                    };

                    ctrl.onDropInsert = function(targetFolder) {
                        fileCabinetDragAndDropService.setDropDetails(currentLocation, 0, fileCabinetDragAndDropService.move.insert, targetFolder);
                        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;
                    };

                    var removePlaceholder = function() {
                        var placeholder = angular.element(document.getElementsByClassName('dndPlaceholder'));
                        placeholder.remove();
                    };
                }]);
}());