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) {
		Text[] userLabels = KeyList.UserLabels.get();
		Stream<String> accessibleUserWideLabels = Arrays.asList(userLabels).stream().map(label -> label.getText());
		
		Predicate<Item> isLabelWithoutEncryptionLabel = item -> item.getEncryptionLabel() == null || item.getEncryptionLabel().isEmpty();
		itemsList.removeIf(isLabelWithoutEncryptionLabel);
		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);
		}
	}
}