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

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.ItemsList;
import org.expeditee.items.Item;
import org.expeditee.items.Text;
import org.expeditee.settings.identity.secrets.KeyList;

public class Label {
        
        private static int surrogateStep = -1;

        public static LabelResult getLabel(String label) {
                Text[] userLabels = KeyList.UserLabels.get();
                Text labelText = null;
                for (Text userLabel : userLabels) {
                        if (userLabel.getText().equals(label)) {
                                labelText = userLabel;
                                break;
                        }
                }

                if (labelText == null) {
                        return unableToFindLabelResult(label);
                } else {
                        List<String> data = labelText.getData();
                        if (data == null || data.isEmpty()) { 
                                return unableToFindLabelResult(label);
                        }
                        String dataEntry = data.get(0);
                        
                        if (dataEntry.contains("{")) {
                                return partialKeyResult(label, dataEntry);
                        } else {
                                return fullKeyResult(label, dataEntry);
                        }
                }
        }
        
        public static void progressSurrogateMode() {
                surrogateStep += 1;
        }

        public static void resetSurrogateMode() {
                surrogateStep = -1;
        }

        public static List<String> getAccessibleLabelsNames(ItemsList itemsList) {
                // TODO make copy of itemsList in here and then adjust callers so they do not need to make copy.
                // Alternatively, filter instead of removeIf
                Text[] userLabels = KeyList.UserLabels.get();
                Stream<String> accessibleUserWideLabels = Arrays.asList(userLabels).stream().map(label -> label.getText());
                
                Predicate<Item> isItemWithoutEncryptionLabel = item -> item.getEncryptionLabel() == null || item.getEncryptionLabel().isEmpty();
                itemsList.removeIf(isItemWithoutEncryptionLabel);
                Stream<String> accessibleFrameLocalLabels = itemsList.underlying().stream().map(item -> item.getEncryptionLabel()).distinct();
                
                List<String> accessibleLabelsUnion = accessibleUserWideLabels.collect(Collectors.toList());
                accessibleLabelsUnion.retainAll(accessibleFrameLocalLabels.collect(Collectors.toList()));
                
                if (surrogateStep > -1 && surrogateStep < accessibleLabelsUnion.size()) {
                        String surrogateModeFilter = accessibleLabelsUnion.get(surrogateStep);
                        List<String> single = new ArrayList<String>();
                        single.add(surrogateModeFilter);
                        return single;
                } else {
                        resetSurrogateMode();
                }
                
                return accessibleLabelsUnion;
        }

        private static LabelResult partialKeyResult(String label, String dataEntry) {
                dataEntry = dataEntry.substring(dataEntry.indexOf('}') + 1).trim();
                LabelResult res = LabelResult.SuccessResolveLabelToPartialKey;
                res.name = label;
                return res;
        }

        private static LabelResult unableToFindLabelResult(String label) {
                LabelResult res = LabelResult.ErrorUnableToFindLabel;
                res.name = label;
                return res;
        }
        
        private static LabelResult fullKeyResult(String label, String dataEntry) {
                try {
                        LabelResult res = LabelResult.SuccessResolveLabelToKey;
                        res.key = Base64.getDecoder().decode(dataEntry);
                        res.name = label;
                        return res;
                } catch (IllegalArgumentException e) {
                        return LabelResult.ErrorUnableToFindLabel;
                }
        }

        //private static Map<LabelResult, LabelAccess> labelCache = new LinkedHashMap<LabelResult, LabelAccess>();
        //private static int surrogateStep = -1;
        //private static final Predicate<? super LabelResult> isAccessible = a -> labelCache.get(a).allowed;
        
//      public static LabelResult resolveKey(String label) {
//              Stream<LabelResult> stream = labelCache.keySet().stream();
//              stream = stream.filter(res -> res.name.equals(label));
//              if (stream.count() == 0) {
//                      return resolveKeyWorker(label);
//              } else {
//                      LabelResult labelResult = stream.collect(Collectors.toList()).get(0);
//                      LabelAccess accessible = labelCache.get(labelResult);
//                      if (accessible.allowed) { return labelResult; }
//                      else { return LabelResult.ErrorForbiddenLabel; }
//              }
//      }       
//      private static LabelResult resolveKeyWorker(String label) {
//              Frame secretsFrame = getSecretsFrame();
//              if (secretsFrame == null) { 
//                      return LabelResult.ErrorUnableToFindSecretsFrame;
//              }
//              
//              String data = getDataFromLabel(secretsFrame, label);
//              if (data == null) {
//                      return LabelResult.ErrorUnableToFindLabel;
//              }
//              
//              if (data.contains("{")) {
//                      data = data.substring(data.indexOf('}') + 1).trim();
//                      LabelResult res = LabelResult.SuccessResolveLabelToPartialKey;
//                      res.key = Base64.getDecoder().decode(data);
//                      return res;
//              } else {
//                      try {
//                              LabelResult res = LabelResult.SuccessResolveLabelToKey;
//                              res.key = Base64.getDecoder().decode(data);
//                              res.name = label;
//                              labelCache.put(res, new LabelAccess(true));
//                              return res;
//                      } catch (IllegalArgumentException e) {
//                              return LabelResult.ErrorUnableToFindLabel;
//                      }
//              }
//      }
//      
//      private static String getDataFromLabel(Frame frame, String label) {
//              Collection<Text> labels = frame.getTextItems();
//              labels.removeIf(lbl -> !lbl.getText().equals(label));
//              labels.removeIf(lbl -> lbl.getData() == null || lbl.getData().size() == 0);
//              if (labels.isEmpty()) { return null; }
//              Text labelItem = labels.iterator().next();
//              List<String> data = labelItem.getData();
//              if (data.isEmpty()) { return null; }
//              return data.get(0);
//      }
//      
//      private static Frame getSecretsFrame() {
//              String credentialsFrameName = UserSettings.ProfileName.get() + 
//                              AuthenticatorBrowser.CREDENTIALS_FRAME;
//              Frame credentialsFrame = FrameIO.LoadFrame(credentialsFrameName);
//              Collection<Text> textItems = credentialsFrame.getTextItems();
//              textItems.removeIf(t -> !t.getText().equals("Secrets"));
//              textItems.removeIf(t -> !t.hasLink());
//              if (textItems.isEmpty()) {
//                      return null;
//              }
//              Text linkToSecretsFrame = textItems.iterator().next();
//              if (!linkToSecretsFrame.hasLink()) {
//                      return null;
//              }
//              Frame secretsFrame = FrameIO.LoadFrame(linkToSecretsFrame.getParent().getFramesetName() + linkToSecretsFrame.getLink());
//              return secretsFrame;
//      }
//      
//      private static class LabelAccess {
//              public final boolean allowedDefault;
//              public boolean allowed;
//              
//              public LabelAccess(boolean value) { 
//                      allowedDefault = value;
//                      allowed = allowedDefault;
//              }
//      } 
        
        public enum LabelResult {
                SuccessResolveLabelToKey, 
                SuccessResolveLabelToPartialKey, 
                ErrorUnableToFindSecretsFrame, 
                ErrorUnableToFindLabel, 
                ErrorForbiddenLabel;
                
                public byte[] key;
                public String name;
                
                @Override
                public String toString() {
                        switch (this) {
                        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);
                }
        }
}