(function () {
  "use strict";

  var app = angular.module("items");

  // A controller to trust a value as HTML
  app.filter("toTrusted", function ($sce) {
    return function (value) {
      return $sce.trustAsHtml(value);
    };
  });

  // A controller to handle the initial creation of an item
  app.controller("createItemModalController", [
    "$scope",
    "$modalInstance",
    "itemsModals",
    "selectedFolder",
    "availableFolders",
    function (
      $scope,
      $modalInstance,
      itemsModals,
      selectedFolder,
      availableFolders
    ) {
      // Create a blank item and open the edit modal
      $scope.createNewItem = function (
        itemType,
        embedType,
        selectedFolder,
        availableFolders
      ) {
        $modalInstance.dismiss();
        itemsModals.editItem(
          {
            type: itemType,
            itemType: itemType,
            embedType: embedType,
            selectedFolder: selectedFolder,
            availableFolders: availableFolders,
          },
          false
        );
      };

      $scope.cancel = function () {
        $modalInstance.close();
      };

      $scope.selectedFolder = selectedFolder;
      $scope.availableFolders = availableFolders;
    },
  ]);

  app.controller("editItemModalController", [
    "$q",
    "$rootScope",
    "$scope",
    "$modalInstance",
    "itemsModals",
    "virusScanModalService",
    "datacontext",
    "config",
    "common",
    "terminology",
    "itemSummary",
    "itemService",
    "itemsDataContext",
    "userDataContext",
    "fileUploadNew",
    "fileReader",
    "foldersDataContext",
    "folderService",
    function (
      $q,
      $rootScope,
      $scope,
      $modalInstance,
      itemsModals,
      virusScanModalService,
      datacontext,
      config,
      common,
      terminology,
      itemSummary,
      itemService,
      itemsDataContext,
      userDataContext,
      fileUpload,
      fileReader,
      foldersDataContext,
      folderService
    ) {
      var logSuccess = common.logger.getLogFn("editItem", "success");
      var logError = common.logger.getLogFn("editItem", "error");

      // Data for file uploads
      $scope.fileData = {
        file: null,
        fileChanged: false,
        previewUrl: null,
        sizeValid: true,
        typeValid: true,
        uploadPercentage: 0,
      };
      $scope.zipFiles = [];
      $scope.zipFileItems = [];
      $scope.itemCount = 0;

      // Data for file uploads, specific to badges
      $scope.badgeFileData = {
        notIssuedToUser: false,
        isBadgeFile: null,
        backpackItem: null,
      };

      // Data for badge collections
      $scope.badgeCollectionsData = {
        noneSelected: true,
      };

      // Data for weblinks
      $scope.weblinkData = {
        linkChanged: false,
      };

      $scope.loaded = false;
      $scope.item = itemSummary;
      $scope.itemType = itemSummary.itemType;
      $scope.terminology = terminology;
      $scope.editingItem = false;

      // Todo check uniqueness
      $scope.isFolderNameUnique = true;

      // Data for retrieved assignments (framework competencies) that the user has viewed
      $scope.retrievedAssignments = {};

      // Get the item summary and tags when the modal is opened
      activate();
      function activate() {
        if (itemSummary.itemId) {
          getItem();
          $scope.editingItem = true;
        } else {
          foldersDataContext.getUserFolders().then(function (folders) {
            $scope.item.availableFolders = folders;
            $scope.loaded = true;
            if ($scope.item.selectedFolder) {
              $scope.item.folderId = $scope.item.selectedFolder.itemId;
              $scope.item.selectedFolder = {
                folderId: $scope.item.selectedFolder.itemId,
                name: $scope.item.selectedFolder.title,
              };
            }
          });
        }

        getTagsList();
      }

      // Get the list of all tags for this user
      function getTagsList() {
        return userDataContext.getTagSummary().then(function (data) {
          $scope.allTags = data;
        });
      }

      // Check that the name of the showcase is unique
      $scope.checkFolderNameIsUnique = function (name) {
        $scope.isFolderNameUnique = folderService.checkFolderNameIsUnique(
          $scope.item.availableFolders,
          name
        );
      };

      // Get a list of tags that match a value entered by the user
      $scope.getTagsForQuery = function (val) {
        return Promise.resolve(
          $scope.allTags.reduce(function (filtered, tag) {
            if (tag.text.indexOf(val) !== -1) {
              filtered.push(tag);
            }

            return filtered;
          }, [])
        );
      };

      // get item being edited
      function getItem() {
        $q.all([
          itemsDataContext.getItem(itemSummary.itemId),
          foldersDataContext.getUserFolders(),
        ])
          .then(function (data) {
            $scope.loaded = true;
            var item = data[0];
            var folders = data[1];
            $scope.item = item;
            $scope.item.availableFolders = folders;
            $scope.item.newFolder = {
              name: null,
              description: null,
            };
            if (item.folderId) {
              var appliedFolders = [];
              for (var folder in folders) {
                if (folder.folderId === item.folderId) {
                  appliedFolders.push(folder);
                }
              }

              if (appliedFolders) {
                item.selectedFolder = appliedFolders[0];
              }
            }

            if (item) {
              $scope.itemType = item.type;

              if ($scope.itemType === "myprogress assessment") {
                $scope.item.jsonResponse = itemService.parseResponse(
                  $scope.item.jsonResponse
                );
              }
            }
          })
          .finally(function () {
            if (!$scope.item) {
              $scope.error = "An error occured whilst loading this item.";
            }
          });
      }

      // Update the current file when the dropzone directive is used
      $scope.$on("pushImageUp", function (_e, droppedFile) {});

      // Update the preview image
      $scope.$on("filePreviewUpdated", function (_e, previewUrl) {
        $scope.fileData.previewUrl = previewUrl;
      });

      // Validate a selected or dropped file (for image / file / badge items)
      $scope.onFileSelect = function ($files) {
        var reader = new FileReader();
        $scope.fileData.sizeValid = true;
        $scope.fileData.typeValid = true;

        if (!$files[0]) {
          return;
        }

        var $file = $files[0];

        $scope.fileData.file = $file;
        $scope.fileData.fileChanged = true;

        if (!checkValidFileSize($scope.item, $file.size)) {
          $scope.fileData.sizeValid = false;
          $scope.fileData.previewUrl = null;
          return;
        }

        if (!checkValidFileType($scope.item, $file.type)) {
          $scope.fileData.typeValid = false;
          $scope.fileData.previewUrl = null;
          return;
        }

        if ($scope.item.type === "badge") {
          $scope.badgeFileData.notIssuedToUser = false;
          $scope.badgeFileData.isBadgeFile = true;

          // Check image metadata
          fileReader
            .readAsText($file, $scope)
            .then(function (result) {
              // Get all email addresses for this user in an array
              var emailArray = [];

              var allEmails = $rootScope.verifiedEmails;
              for (var i in allEmails) {
                var email = allEmails[i];
                var emailToPush = email;
                if (email.id) {
                  emailToPush = email.email;
                }
                emailArray.push(emailToPush);
              }

              // Get the badge data
              datacontext
                .parseOpenbadge(result, emailArray)
                .then(function (parsedBadge) {
                  if (parsedBadge === "This badge was not issued to you") {
                    $scope.fileData.previewUrl = null;
                    $scope.badgeFileData.notIssuedToUser = true;
                    return;
                  } else if (!parsedBadge || typeof parsedBadge !== "object") {
                    //its not a valid badge file so tell the user

                    $scope.fileData.typeValid = false;
                    $scope.fileData.previewUrl = null;
                    $scope.badgeFileData.isBadgeFile = false;
                    return;
                  }

                  saveBadgeDataToItem(parsedBadge);
                })
                .catch(function () {
                  $scope.fileData.typeValid = false;
                });
            })
            .catch(function () {
              $scope.fileData.typeValid = false;
            });
        }

        $scope.item.size = $file.size;
        $scope.item.iconType = $file.type;

        if ($scope.item.type === "zip") {
          $scope.itemCount = 0;
          $scope.item.zipFileItems = [];
          $scope.zipFiles = [];
          var zip = new JSZip();
          zip.loadAsync($file).then(function (e) {
            Object.keys(e.files).forEach(function (filename) {
              if (
                filename.match(
                  /^[^\\\/\:\*\?\"\<\>\|\.]+(\.[^\\\/\:\*\?\"\<\>\|\.]+)+$/
                )
              ) {
                var mimeType = getMimeType(filename);
                if (mimeType !== "") {
                  $scope.item.zipFileItems.push(filename.toLowerCase());
                  e.files[filename].async("blob").then(function (fileData) {
                    var file = new File([fileData], filename.toLowerCase(), {
                      type: mimeType,
                    });

                    $scope.zipFiles.push(file);
                  });
                }
              }
            });

            $scope.$applyAsync();
          });
        }
        if ($scope.itemType !== "file" && $scope.itemType !== "zip") {
          $scope.fileData.previewUrl = null;
        }

        reader.readAsDataURL($file);
        reader.onload = function (event) {
          if (
            $scope.itemType !== "file" &&
            $scope.itemType !== "zip" &&
            $scope.itemType !== "video"
          ) {
            $scope.fileData.previewUrl = event.target.result;
            $scope.$apply();
          }

          $scope.item.fileAsBase64 = reader.result;
        };
      };

      $scope.clearFileTypes = function () {
        $scope.item.zipFileItems = null;
        $scope.$applyAsync();
      };

      var createFolder = function (item) {
        if (hasNewFolder(item)) {
          return foldersDataContext
            .createFolder(item.newFolder)
            .then(function (createdFolder) {
              item.folderId = createdFolder.folderId;
              $scope.$applyAsync();
            });
        }
        return Promise.resolve();
      };
      // Save the item, uploading any files and saving evidence for the item.
      $scope.saveItem = function (item) {
        $scope.saveClicked = true;
        $scope.isZipFile = false;

        if (item.type === "myprogress assessment" && item.jsonResponse) {
          item.jsonResponse = JSON.stringify(item.jsonResponse);
        }

        itemService.editItemBeforeSaving(item);

        var saveItem = !$scope.editingItem
          ? itemsDataContext.createItem
          : itemsDataContext.editItem;

        var uploadItemFile = {
          image: saveImageOrBadgeItem,
          badge: saveImageOrBadgeItem,
          video: saveVideoItem,
          file: saveFileItem,
        }[$scope.item.type];

        var afterSavingItem = function (item) {
          item.fileAsBase64 = null;
          fileUploadProgress(100);

          logAfterSaving(item);
          itemService.saveEvidenceForItem(item, $scope.retrievedAssignments);
          if (item.folderId) {
            $rootScope.$broadcast("BrowseFolderItems", {
              itemId: item.folderId,
              title: item.folderTitle,
            });
          } else {
            $rootScope.$broadcast("UpdateItems");
          }
          if (!$scope.isZipFile) {
            $modalInstance.close();
          }
        };

        var saveItemWrapper = function (item) {
          if (uploadItemFile) {
            return uploadItemFile(item)
              .then(function () {
                return saveItem(item);
              })
              .then(afterSavingItem)
              .catch(function (errorData) {
                if (errorData === "Virus scan positive.") {
                  item.fileAsBase64 = null;
                  virusScanModalService.virusModal();
                } else {
                  logError("An error occured saving the item.");
                }
                $scope.saveClicked = false;
                fileUploadProgress(0);
                $scope.$apply();
              });
          } else {
            return saveItem(item).then(afterSavingItem);
          }
        };
        if (item.type === "zip") {
          $scope.isZipFile = true;

          createFolder(item).then(function (data1) {
            var folder = item.folderId;

              function processFileSequentially(index) {
                if (index >= $scope.zipFiles.length) {
                  return; 
                }      
                var fileData = $scope.zipFiles[index];
                if (!fileData.name.match(/^[^\\\/\:\*\?\"\<\>\|\.]+(\.[^\\\/\:\*\?\"\<\>\|\.]+)+$/)) {
                  processFileSequentially(index + 1);
                  return;
                }
          
                var file = ($scope.fileData.file = fileData);
                var newItem = null;

                if (getMimeType(fileData.name).indexOf("image") !== -1) {
                  item.type = "image";
                  $scope.item.type = "image";
                  $scope.item.itemType = "image";
                  newItem = {
                    availableFolders: item.availableFolders,
                    competencies: item.competencies,
                    details: item.details,
                    originalImageFileName: fileData.name,
                    imageFileSize: fileData.size,
                    imageFileType: getMimeType(fileData.name),
                    iconType: getMimeType(fileData.name),
                    itemType: "image",
                    type: "image",
                    tags: item.tags,
                    title:
                      item.useFileName === "yes"
                        ? fileData.name.split(".").slice(0, -1).join(".")
                        : item.title,
                    newFolder: item.newFolder,
                    selectedFolder: folder,
                    folderId: item.folderId,
                  };
                } else {
                  item.type = "file";
                  $scope.item.type = "file";
                  $scope.item.itemType = "file";
                  newItem = {
                    availableFolders: item.availableFolders,
                    competencies: item.competencies,
                    details: item.details,
                    filename: fileData.name,
                    fileSize: fileData.size,
                    fileType: getMimeType(fileData.name),
                    iconType: getMimeType(fileData.name),
                    itemType: "file",
                    type: "file",
                    tags: item.tags,
                    newFolder: item.newFolder,
                    selectedFolder: folder,
                    folderId: item.folderId,
                    title:
                      item.useFileName === "yes"
                        ? fileData.name.split(".").slice(0, -1).join(".")
                        : item.title,
                  };
                }
                uploadItemFile = {
                  image: saveImageOrBadgeItem,
                  file: saveFileItem,
                }[$scope.item.type];
          
                var reader = new FileReader();
                reader.onload = function () {
                  newItem.fileAsBase64 = reader.result;
                  saveItemWrapper(newItem).then(function() {
                    processFileSequentially(index + 1);
                  }).catch(function(error) {
                    logError("An error occured saving the item.");
                    processFileSequentially(index + 1);
                  });
                };
                reader.readAsDataURL(file);
              }          
              processFileSequentially(0);
            });
          $modalInstance.close();
        }
        if (!$scope.isZipFile) {
          if (hasNewFolder(item)) {
            return foldersDataContext
              .createFolder(item.newFolder)
              .then(function (createdFolder) {
                item.folderId = createdFolder.folderId;
                return saveItemWrapper(item);
              });
          } else {
            return saveItemWrapper(item);
          }
        }
      };

      function getMimeType(filename) {
        var fileextension = filename.toLowerCase().split(".").pop();
        console.log(fileextension);
        switch (fileextension) {
          case "doc":
            return "application/msword";
          case "docx":
          case "rtf":
            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
          case "pdb":
            return "application/vnd.palm";
          case "pdf":
            return "application/pdf";
          case "xls":
          case "csv":
          case "xla":
            return "pplication/vnd.ms-excel";
          case "xlsx":
            return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
          case "ppt":
          case "pps":
          case "pptx":
            return "application/vnd.ms-powerpoint";
          case "mp3":
            return "audio/mpeg";
          case "bmp":
            return "image/bmp";
          case "gif":
            return "image/gif";
          case "jpg":
            return "image/jpeg";
          case "jpeg":
            return "image/jpeg";
          case "jpe":
            return "image/jpeg";
          case "png":
            return "image/png";
          case "tiff":
            return "image/tiff";
          case "tif":
            return "image/tif";
          case "ico":
            return "image/vnd.microsoft.icon";
          case "mdi":
            return "image/vnd.ms-modi";
          case "logs":
          case "txt":
            return "text/plain";
          case "mp4":
          case "m4v":
            return "video/mp4";
          case "mpeg":
          case "mpg":
            return "video/mp4";
          case "midi":
            return "audio/midi";
          case "wav":
            return "audio/wav";
          case "avi":
            return "video/x-msvideo";
        }

        return "";
      }

      function hasNewFolder(item) {
        return (
          item.newFolder &&
          item.newFolder !== null &&
          item.newFolder.name !== null
        );
      }

      // Check if the file size is valid
      function checkValidFileSize(item, fileSize) {
        switch (item.type) {
          case "video":
            return fileSize <= config.maxVideoUpload;
          case "image":
            return fileSize <= config.maxImageUpload;
          default:
            return fileSize <= config.maxFileUpload;
        }
      }

      // Check if the file type is valid
      function checkValidFileType(item, fileType) {
        var validImageTypes = ["image/jpeg", "image/png", "image/gif"];
        var validZipTypes = [
          "application/zip",
          "application/x-zip-compressed",
          "multipart/x-zip",
        ];
        var validVideoTypes = [
          "video/x-flv",
          "video/mp4",
          "video/3gpp",
          "video/webm",
          "video/mov",
          "video/quicktime",
          "video/x-m4v",
          "video/avi",
        ];

        switch (item.type) {
          case "image":
          case "badge":
            return validImageTypes.indexOf(fileType) != -1;
          case "video":
            return validVideoTypes.indexOf(fileType) != -1;
          case "file":
            return validImageTypes.indexOf(fileType) == -1;
          case "zip":
            return validZipTypes.indexOf(fileType) != -1;
        }
      }

      // Save data from a parsed open badge to the item
      function saveBadgeDataToItem(parsedBadge) {
        $scope.item.validBadgeFile = true;
        $scope.item.badgeData = JSON.stringify(parsedBadge);

        // Template data
        if (parsedBadge.badgeTemplate != null) {
          $scope.item.badgeName = parsedBadge.badgeTemplate.name;
          $scope.item.BadgeDescription = parsedBadge.badgeTemplate.description;
          $scope.item.BadgeCustomData = parsedBadge.openBadge.customData;
        }

        // Graphic data
        if (parsedBadge.badgeGraphic != null) {
          $scope.item.badgeImageUrl = parsedBadge.badgeGraphic.url;
        }

        // Criteria data
        if (parsedBadge.badgeCriteria != null) {
          $scope.item.BadgeCriteria = parsedBadge.badgeCriteria.url;
          $scope.item.BadgeCriteriaText = parsedBadge.badgeCriteria.value;
          $scope.item.BadgeCriteriaType = parsedBadge.badgeCriteria.type;
        }

        // Issuer data
        if (parsedBadge.badgeIssuer != null) {
          $scope.item.BadgeIssuerName = parsedBadge.badgeIssuer.name;
          $scope.item.BadgeIssuerDescription =
            parsedBadge.badgeIssuer.description;
          $scope.item.BadgeIssuerOrigin = parsedBadge.badgeIssuer.url;
          $scope.item.BadgeIssuerLogo = parsedBadge.badgeIssuer.logoUrl;
        }

        $scope.item.badgeIssuedOn = parsedBadge.openBadge.issuedDate;
        $scope.item.badgeAwardedTo = parsedBadge.openBadge.awardedToEmail;
        $scope.item.badgeUnhashedEmail = parsedBadge.openBadge.unhashedEmail;
        $scope.item.openBadgeId = parsedBadge.openBadge.id;

        // $scope.badgeFileData.backpackItem = {
        //   backpackId: $rootScope.badgeUserConfig.backpack.id,
        //   backpackItems: [$scope.item],
        // };
      }

      // Save a file item
      function saveFileItem(item) {
        if ($scope.fileData.file) {
          var file = $scope.fileData.file;
          item.fileName = file.name;
          item.fileSize = file.size;
          item.fileType = file.type;

          fileUploadProgress(50);

          return Promise.resolve();
        }

        return Promise.resolve();
      }

      // Save a image or badge item
      function saveImageOrBadgeItem(item) {
         if ($scope.fileData.file) {
           var file = $scope.fileData.file;

            if ($scope.badgeFileData.backpackItem) {
              datacontext.createBackpackItem($scope.badgeFileData.backpackItem);
            }

            item.originalImageFileName = file.name;
            item.imageFileSize = file.size;
            item.imageFileType = file.type;

            fileUploadProgress(50);
         }

        return Promise.resolve();
      }

      // Save a video item
      function saveVideoItem(item) {
        if ($scope.fileData.file) {
          var file = $scope.fileData.file;

          item.originalVideoFileName = file.name;
          item.videoFileSize = file.size;
          item.videoFileType = file.type;

          fileUploadProgress(50);
        }

        return Promise.resolve();
      }

      // Log a message to the user after their item is saved
      function logAfterSaving(item) {
        logSuccess(
          item.type.toUpperCaseFirstChar() +
            " item " +
            ($scope.editingItem ? "edited" : "created")
        );
      }

      // Report progress of a file upload to the user
      function fileUploadProgress(percentage) {
        $scope.fileData.uploadPercentage = percentage;
      }

      // Close the modal
      $scope.cancel = function () {
        $modalInstance.dismiss("cancel");
      };

      $scope.onFormEdited = function () {
        logSuccess("Form updated");
        $scope.formEditMode = false;
      };
    },
  ]);

  // A controller for editing embed items within an edit item modal
  app.controller("itemEmbedController", [
    "$scope",
    function ($scope) {
      // Ensure that https urls are used
      $scope.ensureProtocol = function (url) {
        if (
          url &&
          url.indexOf("http://") !== -1 &&
          $scope.item.embedType !== "embed-item"
        ) {
          $scope.url = url.replace(/^http:\/\//i, "https://");
          $scope.url += "?html5=1";
        }
      };
    },
  ]);

  // A controller to edit items within a showcase
  app.controller("manageShowcaseItemModalController", [
    "$rootScope",
    "$scope",
    "$modalInstance",
    "virusScanModalService",
    "common",
    "config",
    "currentShowcase",
    "item",
    "itemsDataContext",
    function (
      $rootScope,
      $scope,
      $modalInstance,
      virusScanModalService,
      common,
      config,
      currentShowcase,
      item,
      itemsDataContext
    ) {
      var logSuccess = common.logger.getLogFn("editItem", "success");
      var logError = common.logger.getLogFn("editItem", "error");

      // Data for file uploads
      $scope.fileData = {
        file: null,
        fileChanged: false,
        previewUrl: null,
        sizeValid: true,
        typeValid: true,
        uploadPercentage: 0,
      };

      // Get the title for add-in items
      $scope.addInTitle = function () {
        switch (item.addInType) {
          case "richtext":
            return "Text";
          case "heading":
            return "Heading";
          default:
            return null;
        }
      };

      $scope.saveClicked = false;
      $scope.editedItem = angular.copy(item);
      $scope.originalItem = item;

      // Apply the changes to the item and close modal
      $scope.applyChanges = function () {
        $scope.saveClicked = true;
        $scope.originalItem = Object.assign(
          $scope.originalItem,
          $scope.editedItem
        );
        $scope.originalItem.itemId = $scope.originalItem.itemId || true;
        $scope.originalItem.displaySize =
          $scope.originalItem.displaySize || "Large";
        $scope.originalItem.areDetailsEditedForShowcase = true;

        var saveItem = function () {
          itemsDataContext
            .manageShowcaseItems(currentShowcase.id, currentShowcase.items)
            .then(function (data) {
              if (item.toAdd) {
                $scope.editedItem.toAdd = false;
                currentShowcase.items.push($scope.editedItem);
              } else {
                currentShowcase.items = data;
              }
              logSuccess("Showcase Item edited");
              $rootScope.$broadcast("UpdateShowcases", currentShowcase.id);
              $modalInstance.close();
            })
            .catch(function (errorData) {
              if (errorData === "Virus scan positive.") {
                $scope.originalItem.fileAsBase64 = null;
                $scope.editedItem.fileAsBase64 = null;
                $scope.fileData.file = null;

                virusScanModalService.virusModal();
              } else {
                logError("An error occured saving the item.");
              }
              $scope.saveClicked = false;
            });
        };

        if ($scope.originalItem.overideDisplay && $scope.fileData.file) {
          fileUploadProgress(50);
        }

        saveItem();
      };

      // Report progress of a file upload to the user
      function fileUploadProgress(percentage) {
        $scope.fileData.uploadPercentage = percentage;
      }

      // Validate a selected or dropped file (for image / file / badge items)
      $scope.onFileSelect = function ($files) {
        var reader = new FileReader();
        $scope.fileData.sizeValid = true;
        $scope.fileData.typeValid = true;

        if (!$files[0]) {
          $scope.originalItem.fileAsBase64 = null;
          $scope.editedItem.fileAsBase64 = null;
          return;
        }

        var $file = $files[0];

        $scope.fileData.file = $file;
        $scope.fileData.fileChanged = true;

        if (!checkValidFileSize($file.size)) {
          $scope.fileData.sizeValid = false;
          $scope.fileData.previewUrl = null;
          return;
        }

        if (!checkValidFileType($file.type)) {
          $scope.fileData.typeValid = false;
          $scope.fileData.previewUrl = null;
          return;
        }

        $scope.fileData.previewUrl = null;
        reader.readAsDataURL($file);
        reader.onload = function (event) {
          $scope.fileData.previewUrl = event.target.result;
          $scope.$apply();

          $scope.editedItem.fileAsBase64 = reader.result;
        };
      };

      // Check if the file size is valid
      function checkValidFileSize(fileSize) {
        return fileSize <= config.maxFileUpload;
      }

      // Check if the file type is valid
      function checkValidFileType(fileType) {
        return ["image/jpeg", "image/png", "image/gif"].indexOf(fileType) != -1;
      }

      // Close the modal
      $scope.cancel = function () {
        $modalInstance.dismiss("cancel");
      };
    },
  ]);

  // A controller to preview an item
  app.controller("itemPreviewModalController", [
    "$scope",
    "$modalInstance",
    "userDataContext",
    "itemService",
    "itemSummary",
    "itemsDataContext",
    function (
      $scope,
      $modalInstance,
      userDataContext,
      itemService,
      itemSummary,
      itemsDataContext
    ) {
      $scope.data = {
        loaded: false,
        itemSummary: itemSummary,
        item: null,
      };

      // Get the full item details
      itemsDataContext
        .getItem(itemSummary.itemId)
        .then(function (result) {
          $scope.data.item = result;
          $scope.data.loaded = true;

          if (result && result.type == "myprogress assessment") {
            $scope.data.item.jsonResponse = itemService.parseResponse(
              $scope.data.item.jsonResponse
            );
          }
        })
        .finally(function () {
          if (!$scope.data.item) {
            $scope.data.error = "An error occured whilst loading this item.";
          }
        });

      // Close the model
      $scope.ok = function () {
        $modalInstance.close();
      };

      $scope.cancel = function () {
        $modalInstance.dismiss("cancel");
      };
    },
  ]);

  // A controller to recycle an item
app.controller("itemRecycleModalController", [
    "$rootScope",
    "$scope",
    "$modalInstance",
    "common",
    "showcasesDataContext",
    "itemSummary",
    "itemsDataContext",
    "showcasesService",
    "terminology",
    function (
        $rootScope,
        $scope,
        $modalInstance,
        common,
        showcasesDataContext,
        itemSummary,
        itemsDataContext,
        showcasesService,
        terminology
    ) {
        var logSuccess = common.logger.getLogFn("recycleBin", "success");
        $scope.itemSummary = itemSummary;
        $scope.getThemeThumbnail = showcasesService.getThemeThumbnail;
        $scope.terminology = terminology;

        $scope.data = {
            loaded: false,
            linkedShowcases: [],
            unmarkedLinkedEvidenceItems: [],
            uniqueAssignments: [],
        };

        // Get all showcases linked to the item so we can tell the user that the item will be removed from them if they go ahead
        getShowcasesLinkedToItem();

        function getShowcasesLinkedToItem() {
            showcasesDataContext
                .getShowcasesLinkedToItem(itemSummary.itemId)
                .then(function (result) {
                    $scope.data.linkedShowcases = result;
                    // Check if the item has any evidence maps that haven't been marked
                    itemsDataContext
                        .getItemUnlockedEvidence(itemSummary.itemId)
                        .then(function (result) {
                            $scope.data.hasEvidenceMarks = result.hasEvidenceMarks;
                            $scope.data.hasOutcomeGrading = result.hasOutcomeGrading;
                            $scope.data.hasEvidenceGrading = result.hasEvidenceGrading;
                            $scope.data.hasIncompleteCopiedEvidence = result.hasIncompleteCopiedEvidence;
                            $scope.data.unmarkedLinkedEvidenceItems = result.evidenceDetails;
                            $scope.data.uniqueAssignments = result.uniqueAssignments;
                            $scope.data.loaded = true;
                        });
                });
        }

      $scope.ok = function () {
        itemsDataContext.recycleBinItem(itemSummary.itemId).then(function () {
            //Delete evidence mappings on unmarked outcomes
            angular.forEach($scope.data.unmarkedLinkedEvidenceItems, function (evidence) {
                itemsDataContext.deleteEvidence(evidence.id, evidence.assignmentId);
            });
          $rootScope.$broadcast("UpdateItems");
          logSuccess("Item removed");
          $modalInstance.close();
        });
      };

      $scope.cancel = function () {
        $modalInstance.dismiss("cancel");
      };
    },
  ]);

  // A controller to remove item from folder
  app.controller("removeItemFromFolderModalController", [
    "$rootScope",
    "$scope",
    "$modalInstance",
    "common",
    "showcasesDataContext",
    "itemSummary",
    "itemsDataContext",
    "showcasesService",
    function (
      $rootScope,
      $scope,
      $modalInstance,
      common,
      showcasesDataContext,
      itemSummary,
      itemsDataContext,
      showcasesService
    ) {
      var logSuccess = common.logger.getLogFn(
        "removeItemFromFolder",
        "success"
      );
      $scope.itemSummary = itemSummary;
      $scope.data = {
        loaded: true,
      };

      $scope.ok = function () {
        itemsDataContext.getItem(itemSummary.itemId).then(function (item) {
          const folderId = item.folderId;
          const title = item.folderTitle;
          item.folderId = null;
          itemsDataContext.editItem(item).then(function (resp) {
            $rootScope.$broadcast("BrowseFolderItems", {
              itemId: folderId,
              title: title,
            });
            logSuccess("Item removed from folder");
            $modalInstance.close();
          });
        });
      };

      $scope.cancel = function () {
        $modalInstance.dismiss("cancel");
      };
    },
  ]);

  // A controller to delete folder
  app.controller("deleteFolderModalController", [
    "$rootScope",
    "$scope",
    "$modalInstance",
    "common",
    "showcasesDataContext",
    "itemSummary",
    "itemsDataContext",
    "showcasesService",
    "foldersDataContext",
    function (
      $rootScope,
      $scope,
      $modalInstance,
      common,
      showcasesDataContext,
      itemSummary,
      itemsDataContext,
      showcasesService,
      foldersDataContext
    ) {
      var logSuccess = common.logger.getLogFn("deleteFolder", "success");
      $scope.itemSummary = itemSummary;
      $scope.data = {
        loaded: true,
      };

      $scope.ok = function () {
        foldersDataContext.deleteFolder(itemSummary).then(function (item) {
          $rootScope.$broadcast("UpdateItems");
          logSuccess("Folder deleted");
          $modalInstance.close();
        });
      };

      $scope.cancel = function () {
        $modalInstance.dismiss("cancel");
      };
    },
  ]);

    // A controller to share a folder
    app.controller("shareFolderModalController", [
        "$scope",
        "$rootScope",
        "$modalInstance",
        "common",
        "config",
        'datacontext',
        "itemSummary",
        "terminology",
        "foldersDataContext",
        function (
            $scope,
            $rootScope,
            $modalInstance,
            common,
            config,
            datacontext,
            itemSummary,
            terminology,
            foldersDataContext
        ) {
            var logSuccess = common.logger.getLogFn("shareFolder", "success");
            $scope.terminology = terminology;
            $scope.itemSummary = itemSummary;
            $scope.newEmail = "";
            $scope.sendingInvite = false;

            $scope.loadFolder = function () {
                foldersDataContext.getFolder($scope.itemSummary.itemId).then(function (folder) {
                    $scope.folder = folder;
                    $scope.data = {
                        loaded: true,
                    };
                });
            }

            $scope.loadFolder();

         

            $scope.share = function () {
                $scope.sendingInvite = true;

                var model = {
                    folderId: $scope.itemSummary.itemId,
                    userId: $scope.userId,
                    email: $scope.newEmail
                };

                foldersDataContext.shareFolder(model).then(function (item) {
                    logSuccess("Folder shared");
                    $scope.loadFolder();
                    $rootScope.$broadcast('UpdateItems');
                    $scope.userId = null;
                    $scope.emailExists = false;
                    $scope.checking = false;
                    $scope.newEmail = "";
                    $scope.sendingInvite = false;
                });
            };

            $scope.remove = function (userId) {
                var model = {
                    folderId: $scope.itemSummary.itemId,
                    userId: userId,
                };

                foldersDataContext.unshareFolder(model).then(function () {
                    logSuccess("Folder unshared");
                    $scope.loadFolder();
                    $rootScope.$broadcast('UpdateItems');
                });
            };

            $scope.doesEmailExist = function (email) {
                $scope.isSelf = false;
                $scope.userId = null;
                $scope.emailExists = false;
                $scope.checking = true;
                $scope.alreadyShared = false;

                if (email && $rootScope.verifiedEmails.filter(function (e) { return e.toLowerCase() === email.toLowerCase() }).length > 0) {
                    $scope.isSelf = true;
                    $scope.checking = false;
                } else if (email && $scope.folder.sharedUsers.filter(function (e) { return e.email.toLowerCase() === email.toLowerCase() && !e.dateRejected; }).length > 0) {
                    $scope.alreadyShared = true;
                    $scope.checking = false;
                } else {

                    //HTML encode the username so that e.g. '+' is handled correctly
                    var email = encodeURIComponent(email);

                    datacontext
                        .getUserIdByEmail(email)
                        .then(function (id) {
                            if (id !== "00000000-0000-0000-0000-000000000000") {
                                $scope.userId = id;
                                $scope.emailExists = true;
                                $scope.checking = false;
                            } else {
                                $scope.emailExists = false;
                                $scope.checking = false;
                            }
                        });
                }
            };

            $scope.cancel = function () {
                $modalInstance.dismiss("cancel");
            };
        },
    ]);
})();