(function() {
    "use strict";

    angular.module('shared')

        .service('folders', ['$q', 'messageHandler', 'folderService', 'MessageBox', 'subjects', 'FeatureCheck',
            function ($q, messageHandler, folderService, MessageBox, subjects, FeatureCheck) {
                var moveSourceID = -1;
                var moveDestID = -1;
                var movePosition = 0;

                var isCopy = true;
                var everyonedest = false;
                var successMessage;
                var resetLastFolder = false;
                var messageBoxOpen = false;

                var myFolders = null;
                var publicFolders = null;
                var everyoneFolders = null;

                var foundInFolderList = false;
                var siteId = null;
                var site = null;
                var subjectId = null;
                var subjectName = null;
                var hasRazPlus = false;
                var hasSaz = false;
                var isLiteracyEditor = false;
                var isTexasEdition = false;
                var isLcm2FeatureOn = false;

                var literacyTypeId = 0;

                var LITERACY_EDITOR_TYPE_ID = {
                    TEMPLATE : 1,
                    CCSS     : 2,
                    TX       : 3,
                    FL       : 4
                };

                var teacherInfoRead = false;
                var isLC = false;
                var hasTeachersToShareWith = false;
                var kaz_http_server = null;
                var loadLiteracyCurriculumMapFirst = false;

                var self = this;

                self.myFoldersPromise = null;
                self.publicFoldersPromise = null;

                function init() {
                    if (typeof(authorized) != "undefined" && authorized) {
                        readTeacherInfo();
                    }
                }
                init();

                function getTeacherInfoRead() {
                    return teacherInfoRead;
                }

                function getSubjectId() {
                    return subjectId;
                }

                function getSubjectName() {
                    return subjectName;
                }

                function isReadingSubject() {
                    return subjectName === subjects.READING_SUBJECT_NAME;
                }

                function isScienceSubject() {
                    return subjectName === subjects.SCIENCE_SUBJECT_NAME;
                }

                function getHasRazPlus() {
                    return hasRazPlus;
                }

                function getHasSaz() {
                    return hasSaz;
                }

                function getIsLiteracyEditor() {
                    return isLiteracyEditor;
                }

                function getLiteracyTypeId() {
                    return literacyTypeId;
                }

                function isLiteracyEditorForEveryone() {
                    return isLiteracyEditor && parseInt(literacyTypeId) === LITERACY_EDITOR_TYPE_ID.TEMPLATE;
                }

                function getMyFoldersTypeName() {
                    return 'My Files';
                }

                function getLiteracyTypeName() {
                    return "Literacy Curriculum Map";
                }

                function getIsLC() {
                    return isLC;
                }

                function getKaz_http_server() {
                    return kaz_http_server;
                }

                function getLoadLiteracyCurriculumMapFirst() {
                    return loadLiteracyCurriculumMapFirst;
                }

                function readTeacherInfo() {
                    folderService.readTeacherInfo().then(
                        function (response) {
                            if (response !== null && response.data !== null) {
                                isLiteracyEditor = response.data.isLiteracyEditor;
                                literacyTypeId = response.data.literacyTypeId ? response.data.literacyTypeId : 2;

                                subjectId = response.data.subjectId ? response.data.subjectId : null;
                                subjectName = response.data.subjectName ? response.data.subjectName : null;

                                siteId = response.data.siteId ? response.data.siteId : null;
                                site = response.data.site ? response.data.site : null;

                                hasRazPlus = response.data.hasRazPlus !== null &&  response.data.hasRazPlus === 1;
                                hasSaz = response.data.hasSaz !== null &&  response.data.hasSaz === 1;

                                isTexasEdition = response.data.isTexasEdition !== null && response.data.isTexasEdition === 1;
                                isLcm2FeatureOn = response.data.isLCM2FeatureOn !== null && response.data.isLCM2FeatureOn === 1;

                                isLC = response.data.isLC !== null &&  response.data.isLC === 1;
                                kaz_http_server = response.data.KAZ_HTTP_SERVER !== null ? response.data.KAZ_HTTP_SERVER : null;
                                hasTeachersToShareWith = response.data.hasTeachersToShareWith !== null &&  response.data.hasTeachersToShareWith === 1;
                                loadLiteracyCurriculumMapFirst = response.data.load_literacy_curriculum_map_first !== null && response.data.load_literacy_curriculum_map_first === 1;
                            }

                            teacherInfoRead = true;

                            readMyFolders();
                        },
                        function (reason) {
                            console.log(reason);
                        }
                    );
                }

                function getHasTeachersToShareWith() {
                    return hasTeachersToShareWith;
                }

                function readMyFolders() {
                    if (myFolders === null) {
                        folderService.setReadingFolders(true);
                        folderService.readMyFolders().then(
                            function (response) {
                                myFolders = response.data;
                                folderService.setReadingFolders(false);
                            },
                            function (reason) {
                                //messageHandler.publishError('Could not read private folders.');
                                folderService.setReadingFolders(false);
                            }
                        );
                    }
                }

                function readPublicFolders() {
                    if (publicFolders === null) {
                        folderService.setReadingFolders(true);
                        folderService.readPublicFolders().then(
                            function (response) {
                                publicFolders = response.data;
                                folderService.setReadingFolders(false);
                            },
                            function (reason) {
                                messageHandler.publishError('Could not read public folders.');
                                folderService.setReadingFolders(false);
                            }
                        );
                    }
                }

                function reReadPublicFolders() {
                    publicFolders = null;
                    readPublicFolders();
                }

                function readEveryoneFolders() {
                    if (everyoneFolders === null) {
                        folderService.setReadingFolders(true);
                        folderService.readEveryoneFolders(literacyTypeId).then(
                            function (response) {
                                setEveryoneFolders(response.data);
                                folderService.setReadingFolders(false);
                            },
                            function (reason) {
                                messageHandler.publishError('Could not read everyone folders.');
                                folderService.setReadingFolders(false);
                            }
                        );
                    }
                }

                function reReadEveryoneFolders() {
                    setEveryoneFolders(null);
                    readEveryoneFolders();
                }

                function onError(reason) {
                    //self.readingFolders = false;
                    console.error("An error occured in folders");
                    console.error(reason);
                }

                function getMyFoldersPromise() {
                    return folderService.getMyFoldersForBundleBar().then(function(response) {
                        myFolders = response;
                        return response;
                    });
                }

                function getEveryoneFoldersPromise() {
                    return folderService.readEveryoneFolders(literacyTypeId).then(function(response) {
                        setEveryoneFolders(response.data);
                        return response;
                    });
                }

                function getMyFolders() {
                    return myFolders;
                }

                function setMyFolders(val) {
                    myFolders = val;
                }

                function getPublicFolders() {
                    return publicFolders;
                }

                function setPublicFolders(val) {
                    publicFolders = val;
                }

                function doShowEveryoneFolders() {
                    if (isLiteracyEditor) {
                        return isReadingSubject();
                    }

                    if (isLcm2FeatureOn) {
                        return isReadingSubject() && isTexasEdition;
                    }

                    return isReadingSubject();
                }

                function getEveryoneFolders() {
                    return everyoneFolders;
                }

                function setEveryoneFolders(val) {
                    everyoneFolders = val;
                }

                function setToEmptyList() {
                    myFolders = new Array();
                }

                function addFolder() {
                    console.log("add Folder!");
                }

                function removeFolderFromList(list, folder_id) {
                    foundInFolderList = false;
                    for (var counter = 0;counter < list.length;counter++) {
                        var f = list[counter];
                        if (f.id == folder_id) {
                            list.splice(counter,1);
                            return true;
                        }
                        if (f.children != null && f.children.length > 0) {
                            if (removeFolderFromList(f.children,folder_id)) {
                                return true;
                            }
                        }
                    }
                    return false;
                }

                function removeFolder(folder_id) {
                    removeFolderFromList(myFolders, folder_id);
                }

                // Measures how many generations above you (parents)
                function getDepth(folder) {
                    if (folder == null) {
                        return 0;
                    }
                    var depth = 1;
                    var parent = findParent(folder);
                    while (parent != null) {
                        depth++;
                        parent = findParent(parent);
                    }
                    return depth;
                }

                // Measures how many generations below you (children)
                function getDepthBelow(folder, isPublic, isEveryone) {
                    if (folder == null) {
                        return 0;
                    }

                    var maxDepth = { value: 1 };
                    var depth = 1;

                    getMaxDepth(folder, depth, maxDepth, isPublic, isEveryone);

                    return maxDepth.value;
                }

                function getMaxDepth(folder, depth, maxDepth, isPublic, isEveryone) {
                    if (depth > maxDepth.value) {
                        maxDepth.value = depth;
                    }

                    if (folder.children != null && folder.children.length > 0) {
                        for (var counter = 0; counter < folder.children.length; counter++) {
                            var folderList;

                            if (isEveryone) {
                                folderList = everyoneFolders;
                            } else if (isPublic) {
                                folderList = publicFolders;
                            } else {
                                folderList = myFolders;
                            }

                            var f = findFolderForID(folderList, folder.children[counter].id);

                            getMaxDepth(f,depth + 1, maxDepth, isPublic, isEveryone);
                        }
                    }
                }

                function findParent(folder) {
                    if (folder.parent_resource_collection_id == null) {
                        return null;
                    }
                    return findFolderForID((everyonedest || folder.everyoneFolder) ? everyoneFolders : myFolders,folder.parent_resource_collection_id);
                }

                function findFolderForID(list, folder_id) {
                    if (list) {
                        for (var counter = 0; counter < list.length; ++counter) {
                            var f = list[counter];
                            if (f.id == folder_id) {
                                return f;
                            }
                            if (f.children != null && f.children.length > 0) {
                                var parent = findFolderForID(f.children,folder_id);
                                if (parent != null) {
                                    return parent;
                                }
                            }
                        }
                    }

                    return null;
                }

                function findFolderDepth(list,folder_id,depth) {
                    for (var counter = 0;counter < list.length;counter++) {
                        var f = list[counter];
                        if (f.id == folder_id) {
                            return depth;
                        }
                        if (f.children != null && f.children.length > 0) {
                            var newDepth = findFolderDepth(f.children,folder_id,depth+1);
                            if (newDepth > 0) {
                                return newDepth;
                            }
                        }
                    }
                    return 0;
                }

                function countFolders(folder) {
                    if (folder.children == null || folder.children.length < 1) {
                        return 1;
                    }
                    var sum=1;
                    for (var counter = 0;counter < folder.children.length;counter++) {
                        sum = sum + countFolders(folder.children[counter]);
                    }
                    return sum;
                }

                function hasNameConflict(parentFolder,name) {
                    var children = null;
                    if (parentFolder != null) {
                        if (parentFolder.children != null && parentFolder.children.length > 0) {
                            children = parentFolder.children;
                        }
                    }
                    else {
                        children = getMyFolders();
                        if (children == null || children.length < 1) {
                            children = null;
                        }
                    }
                    if (children == null) {
                        return false;
                    }
                    for (var counter = 0;counter < children.length;counter++) {
                        var fname = children[counter].name.toUpperCase();
                        if (fname == name.toUpperCase()) {
                            return true;
                        }
                    }
                    return false;
                }

                function moveFolder(source_id, destination_id, position, inIsCopy, isPublic, isEveryone, parentController, ineveryonedest) {
                    try {
                        everyonedest = ineveryonedest != undefined && ineveryonedest === true;
                        var sourceFolder;

                        if (isEveryone) {
                            sourceFolder = findFolderForID(getEveryoneFolders(),source_id);
                        } else if (isPublic) {
                            sourceFolder = findFolderForID(getPublicFolders(),source_id);
                        } else {
                            sourceFolder = findFolderForID(getMyFolders(),source_id);
                        }

                        var currentParentID = sourceFolder.parent_resource_collection_id;
                        var destFolder = everyonedest ? findFolderForID(getEveryoneFolders(),destination_id) : findFolderForID(getMyFolders(),destination_id);

                        currentParentID = currentParentID == null ? -1 : currentParentID;
                        movePosition = position == null ? 0 : position;
                        moveSourceID = sourceFolder.id;
                        moveDestID = destination_id;
                        isCopy = inIsCopy;

                        if (parentController != null) {
                            parentController.closeFolderList();
                            parentController.setSkipSelect(true);
                        }

                        if (parentController != null && !isCopy && currentParentID == destination_id) {
                            return;
                        }

                        if (!isValidMove(destFolder, sourceFolder)) {
                            messageHandler.publishError('Could not move folder.');
                            return;
                        }

                        successMessage = "The '" + sourceFolder.name + "' folder has been ";

                        if (isCopy) {
                            successMessage += "copied"
                        }
                        else {
                            successMessage += "moved"

                        }
                        if (destFolder == null) {
                            successMessage += (everyonedest ? " to 'Literacy Curriculum Map'." : " to 'My Files'.");
                        }
                        else {
                            successMessage += " to folder '" + destFolder.name + "'."
                        }

                        if (isCopy) {
                            var data = {
                                isEveryone: isEveryone,
                                folder: sourceFolder,
                                parent_id: destination_id,
                                position: movePosition,
                                everyonedest: everyonedest,
                                literacyTypeId: literacyTypeId
                            };
                        }
                        else {
                            var data = {
                                isEveryone: isEveryone,
                                folder_id: source_id,
                                parent_id: destination_id,
                                position: movePosition,
                                everyonedest: everyonedest,
                                literacyTypeId: literacyTypeId
                            };
                        }
                        if (isPublic || isCopy || currentParentID != destination_id) {
                            if (FeatureCheck.isFeatureEnabled('LCM_RAZ_PLUS_PAGE_VERSION_2') && sourceFolder.is_lcm_folder){
                                if (getDepth(destFolder) + parseInt(sourceFolder.depth) > 8) {
                                    messageHandler.publishError('You can only nest folders 8 levels deep.');
                                    return;
                                }
                            } else {
                                if (getDepth(destFolder) + getDepthBelow(sourceFolder, isPublic, isEveryone) > 8) {
                                    messageHandler.publishError('You can only nest folders 8 levels deep.');
                                    return;
                                }
                            }

                            if (!messageBoxOpen && hasNameConflict(destFolder, sourceFolder.name)) {
                                messageBoxOpen=true;
                                MessageBox.show({
                                    message: 'Another folder named "' + sourceFolder.name + '" already exists in this location.  Do you wish to continue?',
                                    responses: [
                                        {
                                            subtle: true,
                                            label: 'Cancel'
                                        },
                                        {
                                            id: 'continueMove',
                                            confirm: true,
                                            label: 'Continue'
                                        }
                                    ]
                                }).then(function (response) {
                                    messageBoxOpen = false;
                                    if (response.id == 'continueMove') {
                                        return dbMoveFolder(data);
                                    }
                                });
                            }
                            else {
                                return dbMoveFolder(data);
                            }
                        }
                        else {
                            return dbMoveFolder(data);
                        }
                    }
                    catch (err) {
                        if (parentController != null) {
                            parentController.closeFolderList();
                            parentController.setSkipSelect(true);
                        }
                        messageHandler.publishError('Could not move folder.');
                        messageBoxOpen = false;
                    }
                    return $q.resolve();
                }

                function isValidMove(destFolder, sourceFolder) {
                    var isValidMove = true;
                    if(destFolder && (sourceFolder.id == destFolder.id)) {
                        isValidMove = false;
                    }
                    if(destFolder && (destFolder.parent_resource_collection_id === sourceFolder.id)) {
                        isValidMove = false;
                    }
                    return isValidMove;
                }

                function dbMoveFolder(data) {
                    return folderService.dbMoveFolder(JSON.stringify(data)).then(
                        function (response) {
                            var result = response.data;
                            if (isCopy) {
                                inferfaceCopyFolder(result[0]);
                            }
                            else {
                                inferfaceMoveFolder();
                            }
                        },
                        function (reason) {
                            messageHandler.publishError('Could not move folder.');
                        }
                    );
                }

                function inferfaceMoveFolder() {
                    var sourceFolder = findFolderForID((everyonedest ? getEveryoneFolders() : getMyFolders()),moveSourceID);
                    var allFolders = everyonedest ? getEveryoneFolders() : getMyFolders();
                    var currentParentID = sourceFolder.parent_resource_collection_id;
                    currentParentID = currentParentID == null ? -1 : currentParentID;
                    var newParentID = moveDestID;
                    var newAr = allFolders;
                    var newParent = null;
                    if (newParentID > -1) {
                        newParent = findFolderForID(allFolders, newParentID);
                        if (newParent.children == null) {
                            newParent.children = new Array();
                        }
                        newAr = newParent.children;
                    }
                    var curAr = allFolders;
                    if (currentParentID > -1) {
                        curAr = findFolderForID(allFolders, currentParentID).children;
                    }
                    for (var pos = 0; pos < curAr.length; pos++) { // Find position in parent child array
                        if (sourceFolder.id == curAr[pos].id) {
                            break;
                        }
                    }
                    sourceFolder.parent_resource_collection_id = newParentID;
                    var currentDepth = newParent == null ? 0 : findFolderDepth(allFolders,newParentID,1);
                    sourceFolder.depth = currentDepth + 1;
                    curAr.splice(pos, 1); // Remove folder as child from current parent
                    newAr.splice(movePosition,0,sourceFolder); // Add folder as child to new parent

                    newParentID = newParentID < 0 ? null : newParentID;
                    sourceFolder.parent_resource_collection_id = newParentID; // Set new parent id
                    resetLastFolder = true;

                    if(currentParentID != moveDestID) {
                        messageHandler.publishSuccess(successMessage);
                    }
                }

                function inferfaceCopyFolder(copiedFolder) {
                    if (copiedFolder.parent_resource_collection_id == -1)
                        copiedFolder.parent_resource_collection_id = null;
                    copiedFolder.assignment = null;
                    var parent = findParent(copiedFolder);
                    if (parent != null) {
                        if (parent.children == null) {
                            parent.children = [];
                        }
                        parent.children.unshift(copiedFolder);
                    }
                    else {
                        if (everyonedest) {
                            getEveryoneFolders().unshift(copiedFolder);
                        } else {
                            var hasFolders = getMyFolders();
                            if (hasFolders) {
                                getMyFolders().unshift(copiedFolder);
                            } else {
                                myFolders = [];
                                getMyFolders().unshift(copiedFolder);
                            }
                        }
                    }
                    messageHandler.publishSuccess(successMessage);
                }

                function getResetLastFolder() {
                    return resetLastFolder;
                }

                function setResetLastFolder(val) {
                    resetLastFolder = val;
                }

                return {
                    getHasTeachersToShareWith: getHasTeachersToShareWith,
                    getKaz_http_server: getKaz_http_server,
                    moveFolder: moveFolder,
                    hasNameConflict: hasNameConflict,
                    getSubjectId: getSubjectId,
                    getSubjectName: getSubjectName,
                    isReadingSubject: isReadingSubject,
                    isScienceSubject: isScienceSubject,
                    setResetLastFolder: setResetLastFolder,
                    getResetLastFolder: getResetLastFolder,
                    getHasRazPlus: getHasRazPlus,
                    getHasSaz: getHasSaz,
                    getIsLiteracyEditor: getIsLiteracyEditor,
                    getLiteracyTypeId: getLiteracyTypeId,
                    isLiteracyEditorForEveryone: isLiteracyEditorForEveryone,
                    getIsLC: getIsLC,
                    reReadPublicFolders: reReadPublicFolders,
                    reReadEveryoneFolders: reReadEveryoneFolders,
                    getDepthBelow: getDepthBelow,
                    getDepth: getDepth,
                    setToEmptyList: setToEmptyList,
                    findFolderForID: findFolderForID,
                    findParent: findParent,
                    countFolders: countFolders,
                    removeFolder: removeFolder,
                    getMyFolders: getMyFolders,
                    setMyFolders: setMyFolders,
                    getPublicFolders: getPublicFolders,
                    removeFolderFromList: removeFolderFromList,
                    setPublicFolders: setPublicFolders,
                    doShowEveryoneFolders: doShowEveryoneFolders,
                    getEveryoneFolders: getEveryoneFolders,
                    setEveryoneFolders: setEveryoneFolders,
                    getMyFoldersPromise: getMyFoldersPromise,
                    getEveryoneFoldersPromise: getEveryoneFoldersPromise,
                    addFolder: addFolder,
                    getMyFoldersTypeName: getMyFoldersTypeName,
                    getLiteracyTypeName: getLiteracyTypeName,
                    getTeacherInfoRead: getTeacherInfoRead,
                    getLoadLiteracyCurriculumMapFirst: getLoadLiteracyCurriculumMapFirst
                };
            }]);
}());