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

package org.expeditee.encryption.items.surrogates;

import java.util.ArrayList;
import java.util.Base64;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import org.expeditee.auth.AuthenticatorBrowser;
import org.expeditee.gui.DisplayController;
import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameIO;
import org.expeditee.gui.MessageBay;
import org.expeditee.items.Item;
import org.expeditee.items.Text;
import org.expeditee.settings.UserSettings;

public class Label {
        
        private static List<LabelResult> labelCache = new ArrayList<LabelResult>();
        private static List<String> forbiddenLabels = new ArrayList<String>();
        
        public static LabelResult resolveKey(String label) {
                
                if (forbiddenLabels.contains(label)) {
                        return LabelResult.ErrorUnableToFindLabel;
                }
                
                LabelResult fromCache = getFromCache(label);
                if (fromCache != null) {
                        return fromCache;
                }

                
                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 LabelResult.ErrorUnableToFindSecretsFrame;
                }
                Text linkToSecretsFrame = textItems.iterator().next();
                if (!linkToSecretsFrame.hasLink()) {
                        return LabelResult.ErrorUnableToFindSecretsFrame;
                }
                Frame secretsFrame = FrameIO.LoadFrame(linkToSecretsFrame.getParent().getFramesetName() + linkToSecretsFrame.getLink());
                Collection<Text> labels = secretsFrame.getTextItems();
                labels.removeIf(lbl -> !lbl.getText().equals(label));
                labels.removeIf(lbl -> lbl.getData() == null || lbl.getData().size() == 0);
                if (labels.isEmpty()) {
                        return LabelResult.ErrorUnableToFindLabel;
                }
                Text labelItem = labels.iterator().next();
                String data = labelItem.getData().get(0);
                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.add(res);
                                return res;
                        } catch (IllegalArgumentException e) {
                                return LabelResult.ErrorUnableToFindLabel;
                        }
                }
        }
        
        public static void progressSurrogateMode() {
                Collection<Item> allItems = DisplayController.getCurrentFrame().getAllItems();
                allItems.removeIf(item -> item.getEncryptionLabel() == null);
                MessageBay.displayMessage("Encryption labels found on items on current frame: ");
                Set<String> allLabels = allItems.stream().map(i -> i.getEncryptionLabel()).collect(Collectors.toSet());
                StringBuilder sb = new StringBuilder();
                for (String label: allLabels) {
                        sb.append(label + ",");
                }
                MessageBay.displayMessage(sb.deleteCharAt(sb.length() - 1).toString());
        }
        
        public static void resetSurrogateMode() {
                // TODO Auto-generated method stub
                
        }
        
        private static LabelResult getFromCache(String label) {
                List<LabelResult> cacheCanditates = labelCache.stream().filter(labelResult -> labelResult.name.equals(label)).collect(Collectors.toList());
                if (!cacheCanditates.isEmpty()) {
                        return cacheCanditates.get(0);
                } else {
                        return null;
                }
        }
        
//      private static List<List<String>> permutation(List<String> strings, List<List<String>> acc) {
//              for (int i = 0; i < strings.size(); i++) {
//                      
//              }
//      }
        
        public enum LabelResult {
                SuccessResolveLabelToKey, 
                SuccessResolveLabelToPartialKey, 
                ErrorUnableToFindSecretsFrame, 
                ErrorUnableToFindLabel;
                
                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: ";
                        }
                        
                        String message = "Was the list of possible enum results updated without nessasary changes to the toString() function?";
                        throw new IllegalArgumentException(message);
                }
        }
}