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);
		}
	}
}