source: trunk/src/org/expeditee/encryption/items/surrogates/Label.java@ 1480

package org.expeditee.encryption.items.surrogates;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.expeditee.gui.DisplayController;
import org.expeditee.gui.ItemsList;
import org.expeditee.items.Item;
import org.expeditee.items.Text;
import org.expeditee.settings.identity.secrets.KeyList;

public class Label {
        private static List<String> userLabels = new ArrayList<String>();
        private static List<LabelInfo> labelsInfo = new ArrayList<LabelInfo>();
        private static int surrogateStep = 0;
        private static boolean isInSurrogateMode = false;
        private static boolean isUnprivileged = false;
        
        public static LabelInfo getLabel(String labelName) {
                // Maintain the local cache of user labels
                ensureUserLabels();
                
                int indexOfLabel = userLabels.indexOf(labelName);
                if (indexOfLabel == -1) {
                        //A label by the specified name does not exist.
                        return unableToFindLabelResult(labelName);
                } else {
                        //A label by the specified name is in the local cache and can be used.
                        LabelInfo labelResult = labelsInfo.get(indexOfLabel);
                        return labelResult;
                }
        }
        
        public static boolean isInSurrogateMode() {
                return isInSurrogateMode;
        }
        
        /**
         * Progresses surrogate mode and returns a list of labels that are currently in effect.
         * @param context The list of expeditee Items to be considered for context.  These are checked for labels.
         * @return Returns either:
         *      <ol type='a'> 
         *              <li> A list of length 1 specifying the label that the current surrogate mode accepts or </li>
         *              <li> A list of length 0 which specifies that surrogate mode is in unprivileged view or </li>
         *              <li> Null, which means there are no labels in play on this frame 
         *                      (so asking for surrogate mode does not make sense) </li> 
         *  </ol>
         */
        public static List<String> progressSurrogateMode(ItemsList context) {
                // Maintain the local cache of user labels
                ensureUserLabels();
                
                List<String> ret;
                
                List<String> localLabels = getLabelsFromContext(context);
                if (localLabels.isEmpty()) {
                        // If there are no labels on this Frame return null;
                        return null;
                } 
                
                ArrayList<String> intersection = new ArrayList<String>(userLabels);
                intersection.retainAll(localLabels);
                if (!isInSurrogateMode) {
                        isInSurrogateMode = true;
                        // Priming surrogate step to become zero in the loop below.
                        surrogateStep = -1; 
                }
                
                // We are already in surrogate mode, progress it.
                int index = surrogateStep + 1;
                boolean found = false;
                while (index < userLabels.size()) {
                        String surrogateMode = userLabels.get(index);
                        if (intersection.contains(surrogateMode)) {
                                found = true;
                                break;
                        }                       
                        index++;
                }
                                
                if (found) {
                        isUnprivileged = false;
                        surrogateStep = index;
                        String chosenSurrogateMode = userLabels.get(surrogateStep);
                        ret = Arrays.asList(chosenSurrogateMode);
                } else {                        
                        if (surrogateStep >= userLabels.size()) {
                                surrogateStep = 0;
                                isInSurrogateMode = false;
                                isUnprivileged = false;
                                ret = intersection;
                        } else {
                                ret = new ArrayList<String>();
                                surrogateStep = index;
                                isUnprivileged = true;
                        }
                }
                
                return ret;
        }
        
        public static void resetSurrogateMode() {
                // Maintain the local cache of user labels
                ensureUserLabels();
                
                surrogateStep = 0;
                isInSurrogateMode = false;
        }
        
        public static List<String> getAccessibleLabelsNames(ItemsList itemsList) {
                // Maintain the local cache of user labels
                ensureUserLabels();
                
                if (isInSurrogateMode) {
                        if (isUnprivileged) {
                                return new ArrayList<String>();
                        } else {
                                return Arrays.asList(userLabels.get(surrogateStep));
                        }
                } else {
                        List<String> labelsFromContext = getLabelsFromContext(itemsList);
                        ArrayList<String> copy = new ArrayList<String>(labelsFromContext);
                        copy.retainAll(userLabels);
                        return copy;
                }
        }
        
        private static void ensureUserLabels() {
                List<String> userSettingsLabelNames = KeyList.getLabelsNameOnly();
                boolean hasNoKeys = userLabels.isEmpty() && userSettingsLabelNames.isEmpty();
                boolean hasNotChanged = userLabels.equals(userSettingsLabelNames) || hasNoKeys;
                
                if (hasNotChanged) { return; }
                
                // Deal with the fact that the position of our current surrogate mode 
                // might have moved in the users list of labels.
                if (userLabels.size() > surrogateStep) {
                        String surrogateMode = userLabels.get(surrogateStep);
                        int newIndexOfSurrogateMode = userSettingsLabelNames.indexOf(surrogateMode);
                        if (newIndexOfSurrogateMode >= 0) {
                                surrogateStep = newIndexOfSurrogateMode;
                        } else {
                                surrogateStep = 0;
                                isInSurrogateMode = false;
//                              MessageBay.displayMessage("You have lost access to the encryption label " 
//                                              + surrogateMode + ".  Dropping out of surrogate mode.");
                                System.out.println("You have lost access to the encryption label " 
                                                + surrogateMode + ".  Dropping out of surrogate mode.");
                        }
                }
                
                // (Re)Initialise the userLabels list and labelResultsCache.
                userLabels.clear();
                labelsInfo.clear();
                Text[] userSettings = KeyList.UserLabels.get();
                for (Text userSetting: userSettings) {
                        String labelName = userSetting.getName();
                        List<String> data = userSetting.getData();
                        if (data == null || data.isEmpty()) {
                                continue;
                        }
                        
                        // Extract the data and check if we have a full or partial key.
                        String dataEntry = data.get(0);
                        if (dataEntry.contains("{")) {
                                userLabels.add(labelName);
                                LabelInfo labelInfo = new LabelInfo(LabelResult.SuccessResolveLabelToPartialKey, labelName, null);
                                labelsInfo.add(labelInfo);
                        } else {
                                userLabels.add(labelName);
                                byte[] key = Base64.getDecoder().decode(dataEntry);
                                LabelInfo labelInfo = new LabelInfo(LabelResult.SuccessResolveLabelToKey, labelName, key);
                                labelsInfo.add(labelInfo);
                        }
                }
        }
        
        private static List<String> getLabelsFromContext(ItemsList context) {
                Predicate<Item> hasEncryptionLabel = item -> item.getEncryptionLabel() != null && !item.getEncryptionLabel().isEmpty();
                List<Item> local = context.cloneList();
                Stream<Item> itemsWithLabel = local.stream().filter(hasEncryptionLabel);
                Stream<String> labels = itemsWithLabel.map(item -> item.getEncryptionLabel()).distinct();
                return labels.collect(Collectors.toList());
        }

        private static LabelInfo unableToFindLabelResult(String label) {
                LabelInfo info = new LabelInfo(LabelResult.ErrorUnableToFindLabel, label, null);
                return info;
        }
        
        public static class LabelInfo {
                
                public byte[] key;
                public String name;
                public LabelResult type;
                
                public LabelInfo(LabelResult type, String name, byte[] key) {
                        this.type = type;
                        this.name = name;
                        this.key = key;
                }
                
                public boolean is(LabelResult type) {
                        return this.type == type;
                }
                
                public String toString() {
                        switch(type) {
                        case SuccessResolveLabelToKey:
                                return "Resolved label to key: " + Base64.getEncoder().encodeToString(key);
                        case SuccessResolveLabelToPartialKey:
                                return "Resolved label to slice of a key: " + Base64.getEncoder().encodeToString(key);
                        case ErrorUnableToFindSecretsFrame:
                                return "Unable to find your Secrets Frame.";
                        case ErrorUnableToFindLabel:
                                return "Unable to resolve label to encrypt/decrypt frame.  Label: " + name;
                        case ErrorForbiddenLabel:
                                return "Whilst you have the key for label " + name + " ; you are not allowed to use it.";
                        }
                        
                        String message = "Was the list of possible enum results updated without nessasary changes to the toString() function?";
                        throw new IllegalArgumentException(message);
                }
        }
        
        public enum LabelResult {
                SuccessResolveLabelToKey, 
                SuccessResolveLabelToPartialKey, 
                ErrorUnableToFindSecretsFrame, 
                ErrorUnableToFindLabel, 
                ErrorForbiddenLabel;
        }

        public static String surrogateModeString() {
                String surrogateModeString = null;
                List<String> accessibleLabelsNames = getAccessibleLabelsNames(DisplayController.getCurrentFrame().getPrimaryBody());
                if (accessibleLabelsNames.size() == 0) {
                        surrogateModeString = "Surrogate Mode: Unprivileged";
                        //_surrogateMode = new Text("Surrogate Mode: Unprivileged");
                } else {
                        String list = String.join(",", accessibleLabelsNames);
                        if (accessibleLabelsNames.size() > 1) { 
                                list = "(" + list + ")";
                        } 
                        surrogateModeString = "Surrogate Mode: " + list;
                        //_surrogateMode = new Text("Surrogate Mode: " + list);
                }
                return surrogateModeString;
        }
}