package bjc.dicelang;

import bjc.utils.data.IPair;
import bjc.utils.data.ITree;
import bjc.utils.data.Pair;
import bjc.utils.funcdata.FunctionalList;
import bjc.utils.funcdata.FunctionalMap;
import bjc.utils.funcdata.FunctionalStringTokenizer;
import bjc.utils.funcdata.IList;
import bjc.utils.funcdata.IMap;
import bjc.utils.funcutils.ListUtils;

import static bjc.dicelang.Errors.ErrorKey.*;
import static bjc.dicelang.Token.Type.*;

import java.util.Comparator;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DiceLangEngine {
	// Input rules for processing tokens
	private List<IPair<String, String>> opExpansionList;
	private List<IPair<String, String>> deaffixationList;

	// ID for generation
	private int nextLiteral;

	// Debug indicator
	private boolean debugMode;
	// Should we do shunting?
	private boolean postfixMode;
	// Should we reverse the token stream
	private boolean prefixMode;
	// Should we do step-by-step evaluation
	private boolean stepEval;

	// Shunter for token postfixing
	private Shunter shunt;
	// Tokenizer for tokenizing
	private Tokenizer tokenzer;
	// Parser for tree construction
	private Parser parsr;
	// Evaluator for evaluating
	private Evaluator eval;

	// Tables for symbols
	public final IMap<Integer, String> symTable;
	public final IMap<Integer, String> stringLits;


	// Lists for preprocessing
	private IList<Define> lineDefns;
	private IList<Define> tokenDefns;

	// Are defns sorted by priority
	private boolean defnsSorted;

	// Stream engine for processing streams
	private StreamEngine streamEng;

	public DiceLangEngine() {
		lineDefns   = new FunctionalList<>();
		tokenDefns  = new FunctionalList<>();
		defnsSorted = true;

		symTable   = new FunctionalMap<>();
		stringLits = new FunctionalMap<>();
		
		opExpansionList = new LinkedList<>();

		opExpansionList.add(new Pair<>("+",  "\\+"));
		opExpansionList.add(new Pair<>("-",  "-"));
		opExpansionList.add(new Pair<>("*",  "\\*"));
		opExpansionList.add(new Pair<>("//", "//"));
		opExpansionList.add(new Pair<>("/",  "/"));
		opExpansionList.add(new Pair<>(":=", ":="));
		opExpansionList.add(new Pair<>("=>", "=>"));
		opExpansionList.add(new Pair<>(",",  ","));

		deaffixationList = new LinkedList<>();

		deaffixationList.add(new Pair<>("(", "\\("));
		deaffixationList.add(new Pair<>(")", "\\)"));
		deaffixationList.add(new Pair<>("[", "\\["));
		deaffixationList.add(new Pair<>("]", "\\]"));
		deaffixationList.add(new Pair<>("{", "\\{"));
		deaffixationList.add(new Pair<>("}", "}"));  

		nextLiteral = 1;

		debugMode   = true;
		postfixMode = false;
		prefixMode  = false;
		stepEval    = false;

		streamEng = new StreamEngine(this);
		shunt = new Shunter();
		tokenzer = new Tokenizer(this);
		parsr = new Parser();
		eval  = new Evaluator(this);
	}

	public void sortDefns() {
		Comparator<Define> defnCmp = (dfn1, dfn2) -> dfn1.priority - dfn2.priority;

		lineDefns.sort(defnCmp);
		tokenDefns.sort(defnCmp);

		defnsSorted = true;
	}

	public void addLineDefine(Define dfn) {
		lineDefns.add(dfn);

		defnsSorted = false;
	}

	public void addTokenDefine(Define dfn) {
		tokenDefns.add(dfn);

		defnsSorted = false;
	}

	public boolean toggleDebug() {
		debugMode = !debugMode;

		return debugMode;
	}

	public boolean togglePostfix() {
		postfixMode = !postfixMode;

		return postfixMode;
	}

	public boolean togglePrefix() {
		prefixMode = !prefixMode;

		return prefixMode;
	}

	public boolean toggleStepEval() {
		stepEval = !stepEval;

		return stepEval;
	}

	/*
	 * Matches quote-delimited strings
	 * 		(like "text" or "text\"text")
	 *		Uses the "normal* (special normal*)*" pattern style
	 *		recommended in 'Mastering regular expressions'
	 *		Here, the normal is 'anything but a forward or backslash'
	 *		(in regex, thats '[^\""]') and the special is 'an escaped forward slash'
	 *		(in regex, thats '\\"')
	 *
	 *		Then, we just follow the pattern, escape it for java strings, and
	 *		add the enclosing quotes
	 */
	private Pattern quotePattern = Pattern.compile("\"([^\\\"]*(?:\\\"(?:[^\\\"])*)*)\"");

	// Similiar to the above, but using angle brackets instead of quotes
	private Pattern nonExpandPattern = Pattern.compile("<<([^\\>]*(?:\\>(?:[^\\>])*)*)>>");

	public boolean runCommand(String command) {
		// Sort the defines if they aren't sorted
		if(!defnsSorted) sortDefns();

		IList<String> streamToks = new FunctionalList<>();
		boolean success = streamEng.doStreams(command.split(" "), streamToks);
		if(!success) return false;

		String newComm = ListUtils.collapseTokens(streamToks, " ");

		if(debugMode)
			System.out.println("\tCommand after stream commands: " + newComm);

		for(Define dfn : lineDefns.toIterable()) {
			newComm = dfn.apply(newComm);
		}

		if(debugMode)
			System.out.println("\tCommand after line defines: " + newComm);

		IMap<String, String> stringLiterals = new FunctionalMap<>();

		Matcher quoteMatcher = quotePattern.matcher(newComm);
		StringBuffer destringedCommand = new StringBuffer();

		while(quoteMatcher.find()) {
			String stringLit = quoteMatcher.group(1);

			String litName = "stringLiteral" + nextLiteral++;
			stringLiterals.put(litName, stringLit);

			quoteMatcher.appendReplacement(destringedCommand, " " + litName + " ");
		}

		quoteMatcher.appendTail(destringedCommand);

		// Split the command into tokens
		IList<String> tokens = FunctionalStringTokenizer
			.fromString(destringedCommand.toString()).toList();

		if(debugMode) {
			System.out.println("\tCommand after destringing: " + destringedCommand);

			if(stringLiterals.getSize() > 0) {
				System.out.println("\tString literals in table");

				stringLiterals.forEach((key, val) -> {
					System.out.printf("\t\tName: (%s)\tValue: (%s)\n", key, val);
				});
			}
		}

		IMap<String, String> nonExpandedTokens = new FunctionalMap<>();
		
		tokens = tokens.map(tk -> {
			Matcher nonExpandMatcher = nonExpandPattern.matcher(tk);

			if(nonExpandMatcher.matches()) {
				String tkName = "nonExpandToken" + nextLiteral++;
				nonExpandedTokens.put(tkName, nonExpandMatcher.group(1));

				return tkName;
			} else {
				return tk;
			}
		});

		System.out.println("\tCommand after removal of non-expanders: " + tokens.toString());

		IList<String> semiExpandedTokens  = deaffixTokens(tokens, deaffixationList);
		IList<String> fullyExpandedTokens = deaffixTokens(semiExpandedTokens, opExpansionList);

		System.out.println("\tCommand after token expansion: " + fullyExpandedTokens.toString());

		fullyExpandedTokens = fullyExpandedTokens.map(tk -> {
			if(tk.startsWith("nonExpandToken")) {
				return nonExpandedTokens.get(tk);
			} else {
				return tk;
			}
		});

		if(debugMode) 
			System.out.printf("\tCommand after non-expander reinsertion: " 
					+ fullyExpandedTokens.toString() + "\n");
		

		IList<Token> lexedTokens = new FunctionalList<>();

		for(String token : fullyExpandedTokens) {
			String newTok = token;

			for(Define dfn : tokenDefns.toIterable()) {
				newTok = dfn.apply(newTok);
			}

			Token tk = tokenzer.lexToken(token, stringLiterals);

			if(tk == null) continue;
			else if(tk == Token.NIL_TOKEN) return false;
			else lexedTokens.add(tk);
		}

		if(debugMode)
			System.out.printf("\tCommand after tokenization: %s\n", lexedTokens.toString());

		IList<Token> shuntedTokens = lexedTokens;

		IList<Token> preparedTokens         = new FunctionalList<>();
		boolean sc = removePreshuntTokens(lexedTokens, preparedTokens);

		if(!sc) return false;
		
		if(debugMode && !postfixMode)
			System.out.printf("\tCommand after pre-shunter removal: %s\n", preparedTokens.toString());

		if(!postfixMode && !prefixMode) {
			shuntedTokens = new FunctionalList<>();
			success       = shunt.shuntTokens(preparedTokens, shuntedTokens);
			if(!success) return false;
		} else if(prefixMode) {
			preparedTokens.reverse();
			shuntedTokens = preparedTokens.map(tk -> {
				switch(tk.type) {
					case OBRACE:
						return new Token(CBRACE, tk.intValue);
					case OPAREN:
						return new Token(CPAREN, tk.intValue);
					case OBRACKET:
						return new Token(CBRACKET, tk.intValue);
					case CBRACE:
						return new Token(OBRACE, tk.intValue);
					case CPAREN:
						return new Token(OPAREN, tk.intValue);
					case CBRACKET:
						return new Token(OBRACKET, tk.intValue);
					default:
						return tk;
				}
			});
		}

		if(debugMode && !postfixMode)
			System.out.printf("\tCommand after shunting: %s\n", shuntedTokens.toString());

		IList<Token> readyTokens = shuntedTokens.flatMap(tk -> {
			if(tk.type == Token.Type.TOKGROUP) {
				return tk.tokenValues;
			} else if(tk.type == Token.Type.TAGOP || tk.type == Token.Type.TAGOPR) {
				return tk.tokenValues;
			} else {
				return new FunctionalList<>(tk);
			}
		});

		if(debugMode && !postfixMode)
			System.out.printf("\tCommand after re-preshunting: %s\n", readyTokens.toString());

		IList<ITree<Node>> astForest = new FunctionalList<>();
		success                      = parsr.parseTokens(readyTokens, astForest);

		if(!success) return false;

		if(debugMode) {
			evaluateForest(astForest);
		}

		return true;
	}

	private void evaluateForest(IList<ITree<Node>> astForest) {
		System.out.println("\tParsed forest of asts");
		int treeNo = 1;

		for(ITree<Node> ast : astForest) {
			System.out.println("\t\tTree " + treeNo + " in forest:\n" + ast);

			if(stepEval) {
				int step = 1;

				for(Iterator<ITree<Node>> itr = eval.stepDebug(ast); itr.hasNext();){
					ITree<Node> nodeStep = itr.next();

					System.out.printf("\t\tStep %d: Node is %s", step, nodeStep);

					if(nodeStep == null) {
						System.out.println();

						step += 1;
						continue;
					}

					if(nodeStep.getHead().type == Node.Type.RESULT) {
						EvaluatorResult res = nodeStep.getHead().resultVal;

						System.out.printf(" (result is %s", res);

						if(res.type == EvaluatorResult.Type.DICE) {
							System.out.printf(" (sample roll %s)", res.diceVal.value());
						}

						if(res.origVal != null) {
							System.out.printf(" (original tree is %s)", res.origVal);
						}

						System.out.printf(")");
					}


					System.out.println();
					step += 1;
				}
			} else {
				EvaluatorResult res = eval.evaluate(ast);
				System.out.printf("\t\tEvaluates to %s", res);

				if(res.type == EvaluatorResult.Type.DICE) {
					System.out.println("\t\t (sample roll " + res.diceVal.value() + ")");
				}
			}

			System.out.println();

			treeNo += 1;
		}
	}

	private boolean removePreshuntTokens(IList<Token> lexedTokens, IList<Token> preparedTokens) {
		boolean success;
		int curBraceCount                   = 0;
		Deque<IList<Token>> bracedTokens    = new LinkedList<>();
		IList<Token> curBracedTokens        = null;

		for(Token tk : lexedTokens) {
			if(tk.type == Token.Type.OBRACE && tk.intValue == 2) {
				curBraceCount += 1;

				if(curBraceCount != 1) {
					bracedTokens.push(curBracedTokens);
				}

				curBracedTokens = new FunctionalList<>();
			} else if(tk.type == Token.Type.CBRACE && tk.intValue == 2) {
				if(curBraceCount == 0) {
					Errors.inst.printError(EK_ENG_NOOPENING);
					return false;
				}

				curBraceCount -= 1;

				IList<Token> preshuntTokens = new FunctionalList<>();

				success = shunt.shuntTokens(curBracedTokens, preshuntTokens);

				if(debugMode)
					System.out.println("\t\tPreshunted " + curBracedTokens + " into " + preshuntTokens);

				if(!success) return false;

				if(curBraceCount >= 1) {
					curBracedTokens = bracedTokens.pop();

					curBracedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
				} else {
					preparedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
				}
			} else {
				if(curBraceCount >= 1) {
					curBracedTokens.add(tk);
				} else {
					preparedTokens.add(tk);
				}
			}
		}

		if(curBraceCount > 0) {
			Errors.inst.printError(EK_ENG_NOCLOSING);
			return false;
		}
		
		return true;
	}

	

	 private IList<String> deaffixTokens(IList<String> tokens, List<IPair<String, String>> deaffixTokens) {
		Deque<String> working = new LinkedList<>();

		for(String tk : tokens) {
			working.add(tk);
		}

		for(IPair<String, String> op : deaffixTokens) {
			Deque<String> newWorking = new LinkedList<>();
			
			String opRegex = op.getRight();

			Pattern opRegexPattern  = Pattern.compile(opRegex);
			Pattern opRegexOnly     = Pattern.compile("\\A(?:" + opRegex + ")+\\Z");
			Pattern opRegexStarting = Pattern.compile("\\A" + opRegex);
			Pattern opRegexEnding   = Pattern.compile(opRegex + "\\Z");

			for(String tk : working) {
				if(opRegexOnly.matcher(tk).matches()) {
					// The string contains only the operator
					newWorking.add(tk);
				} else {
					Matcher medianMatcher = opRegexPattern.matcher(tk);
					
					// Read the first match
					boolean found = medianMatcher.find();

					if(!found) {
						newWorking.add(tk);
						continue;
					}

					Matcher startMatcher  = opRegexStarting.matcher(tk);
					Matcher endMatcher    = opRegexEnding.matcher(tk);

					boolean startsWith = startMatcher.find();
					boolean endsWith   = endMatcher.find();
					boolean doSplit = medianMatcher.find();

					medianMatcher.reset();

					if(doSplit || (!startsWith && !endsWith)) {
						String[] pieces = opRegexPattern.split(tk);

						if(startsWith) {
							// Skip the starting operator
							medianMatcher.find();
							newWorking.add(tk.substring(0, startMatcher.end()));
						}

						for(int i = 0; i < pieces.length; i++) {
							String piece = pieces[i];

							// Find the next operator
							boolean didFind = medianMatcher.find();

							if(piece.equals("")) {
								System.out.printf("\tWARNING: Empty token found during operator expansion"
										+ "of token (%s). Weirdness may happen as a result\n", tk);
								continue;
							}

							newWorking.add(piece);

							if(didFind)
								newWorking.add(tk.substring(medianMatcher.start(), medianMatcher.end()));
						}

						if(endsWith)
							newWorking.add(tk.substring(endMatcher.start()));
					} else if(startsWith && endsWith) {
						newWorking.add(tk.substring(0, startMatcher.end()));
						newWorking.add(tk.substring(startMatcher.end(), endMatcher.start()));
						newWorking.add(tk.substring(endMatcher.start()));
					} else if(startsWith) {
						newWorking.add(tk.substring(0, startMatcher.end()));
						newWorking.add(tk.substring(startMatcher.end()));
					} else if(endsWith) {
						newWorking.add(tk.substring(0, endMatcher.start()));
						newWorking.add(tk.substring(endMatcher.start()));
					} else {
						newWorking.add(tk);
					}
				}

			}

			working = newWorking;
		}

		IList<String> returned = new FunctionalList<>();
		for(String ent : working) {
			returned.add(ent);
		}

		return returned;
	}
}