package dev.peerat.parser.java;

import dev.peerat.parser.Parser;
import dev.peerat.parser.Token;
import dev.peerat.parser.java.tree.AnnotationClassTree;
import dev.peerat.parser.java.tree.AnnotationTree;
import dev.peerat.parser.java.tree.ClassBaseTree;
import dev.peerat.parser.java.tree.ClassContainerTree;
import dev.peerat.parser.java.tree.ClassTree;
import dev.peerat.parser.java.tree.EnumTree;
import dev.peerat.parser.java.tree.EnumValueTree;
import dev.peerat.parser.java.tree.FunctionContainerTree;
import dev.peerat.parser.java.tree.FunctionTree;
import dev.peerat.parser.java.tree.GenericTree;
import dev.peerat.parser.java.tree.ImportTree;
import dev.peerat.parser.java.tree.InterfaceTree;
import dev.peerat.parser.java.tree.JavaTree;
import dev.peerat.parser.java.tree.JavaTreeType;
import dev.peerat.parser.java.tree.ModifierTree;
import dev.peerat.parser.java.tree.OperationTree;
import dev.peerat.parser.java.tree.TypeTree;
import dev.peerat.parser.java.tree.ValueTree;
import dev.peerat.parser.java.tree.VariableTree;
import dev.peerat.parser.state.InitialStateTree;
import dev.peerat.parser.state.StateTree;
import dev.peerat.parser.tree.SyntaxTreeRegistery;

public class JavaParser extends Parser<JavaElement>{
	
	
	//TODO
	/**
	 * Visitor:
	 * 	All Visitor Types with all possible (wanted) queries
	 * 	VisitorBag -> collecter ce qui doit être collecter only + 1 element, n elements, n pair d'element,...
	 * 	VisitorBag -> validation de sous-ensemble, et non capture pour autant.
	 * 	VisitorBag -> Operators
	 * AST:
	 * 	Terminer les arbres
	 * 	Bind correctement tout (déplacer les noms & modifiers des classes dans ClassBase)
	 * 	
	 * 
	 * 
	 * Find a way to simplify the way of using the Tree, like Value..., without the need of casting, checking,... A Easy Way to Walk And Build.
	 * Benchmark, check how to optimise. Like changing node order, capturing Token,...
	 * Builder package -> look to only load what is needed ! (same for the whole program)
	 * 
	 * Review choice of implementation, is ArrayList a good choice for all case needed ? (spoiler : no), is null a good idea for some cases ? review it.
	 * Check thr whole tree, match with current Java Version
	 * 	Complete SwitchOperation
	 * Do Generic interface for case, like a generic interface for Class, for exemple, InstanceValue can contains class, annotation, method, variable,...
	 * Remove Value.ValueContainer class
	 * Do All build, find and visitor for all JavaElement
	 * 
	 *
	 */
	
//	public static void main(String[] args) throws Exception{
//		Timing main = Timing.of();
//	
//		Parser<JavaElement> parser = new JavaParser();
//		BufferedReader reader = new BufferedReader(new FileReader(new File("/tmp/example.txt")));
//		
//		Timing parse = Timing.of();
//		JavaFile container = new JavaFile();
//		parser.parse(reader, container);
//		parse.takeTiming("[Parsing] %dms");
//		System.out.println(TokenValidator.MAX_VALIDATE+" / "+TokenValidator.TOKENS+" ("+((TokenValidator.MAX_VALIDATE/(double)TokenValidator.TOKENS)*100.0)+"%)");
//		
//		reader.close();
//		
//		main.takeTiming("End with %dms");
//		
//		File out = new File("/tmp/dataObserve.txt");
//		BufferedWriter writer = new BufferedWriter(new FileWriter(out));
//		writer.write(TokenValidator.MAX_VALIDATE+" "+TokenValidator.TOKENS);
//		writer.flush();
//		writer.close();
//	}
	
	static class Timing{
		
		public static Timing of(){
			return new Timing();
		}
		
		private long time;
		
		Timing(){
			this.time = System.currentTimeMillis();
		}
		
		void takeTiming(String text){
			long result = System.currentTimeMillis()-time;
			System.out.printf(text+"\n", result);
		}
	}
	
	
	public JavaParser(){
		this(JavaTreeType.ALL);
	}
	
	public JavaParser(JavaTreeType level){
		
		Timing tRegistery = Timing.of();
		
		SyntaxTreeRegistery<JavaElement> registery = new SyntaxTreeRegistery<>();
		registery.register(new ModifierTree(registery));
		registery.register(new ImportTree(registery));
		registery.register(new TypeTree(registery));
		registery.register(new GenericTree(registery));
		registery.register(new ValueTree(registery));
		registery.register(new EnumValueTree(registery));
		registery.register(new AnnotationTree(registery));
		registery.register(new VariableTree(registery));
		registery.register(new ClassContainerTree(registery));
		registery.register(new FunctionContainerTree(registery));
		registery.register(new OperationTree(registery));
		registery.register(new FunctionTree(registery));
		registery.register(new ClassBaseTree(registery));
		registery.register(new ClassTree(registery));
		registery.register(new InterfaceTree(registery));
		registery.register(new EnumTree(registery));
		registery.register(new AnnotationClassTree(registery));
		registery.register(new JavaTree(registery));
		
		registery.init();
		
		tRegistery.takeTiming("[Registery] %dms");
		Timing load = Timing.of();
		
//		//SUMMARY
//		//- Import
//		//- Package
//		
//
////		clazz_container.then(function);
////		clazz_container.then(variable);
////		
////		clazz_container.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
////			.end((a,b) -> a)
////				.multiple(function_container)
////				.unique((validator) -> validator.validate((token) -> token.getValue().equals("{")))
////				.end((a,b) -> a);
//		
//		//IMPORT
//		StateTree<JavaElement> importState = new StateTree<>();
//		importState.then((validator) -> {
//			if(validator.validate(
//					(token) -> token.getValue().equals("import"))){
//				
//				validator.validate(
//						(token) -> token.getValue().equals("static"),
//						(bag, token) -> bag.set("static", null));
//				
//				while(validator.validate(
//						(token) -> !token.getValue().equals(";"),
//						(bag, token) -> {
//							Token current = bag.get();
//							if(current == null) bag.set(token);
//							else bag.set(current.concat(token));
//						})
//					);
//				
//				return validator.validate((token) -> token.getValue().equals(";"));
//			}
//			return false;
//		}).<JavaElement>end((parent, bag) -> {
//			((JavaFile)parent).addImport(new Import(bag.has("static"), bag.get()));
//			return parent;
//		});
//
//		
//		InitialStateTree<JavaElement> main = new InitialStateTree<>();
//		
//		//PACKAGE
//		StateTree<JavaElement> pack = main.then((validator) -> {	
//			if(validator.validate(
//					(token) -> token.getValue().equals("package"))){
//				
//				while(validator.validate(
//						(token) -> !token.getValue().equals(";"),
//						(bag, token) -> {
//							Token current = bag.get();
//							if(current == null) bag.set(token);
//							else bag.set(current.concat(token));
//						})
//					);
//				return validator.validate((token) -> token.getValue().equals(";"));
//			}
//			return false;
//		}).end((parent, bag) -> {
//			((JavaFile)parent).setPackage(bag);
//			return parent;
//		});
//		main.multiple(pack);
//		main.multiple(importState);
////		main.multiple(annotation);
////		main.multiple(clazz_);
		
		
//		System.out.println((System.currentTimeMillis()-time)+"ms");
		
		setTokenizer(new JavaTokenizer());
		setStateTree(registery.getNode(level.getType()));
		
		load.takeTiming("[load] %dms");
	}
	
	
	/*
	 
	 
	 StateTree<JavaElement> value = new StateTree<>();
		
		StateTree<JavaElement> value_list = new StateTree<>();
		StateTree<JavaElement> value_list_element = value_list.then(new RedirectStateTree<>(value, (global, local) -> {
			List<Value> list = global.get();
			if(list == null){
				list = new ArrayList<>();
				global.set(list);
			}
			list.add(local.get());
		}));
		value_list_element.end();
		value_list_element.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
			.then(value_list_element);
		
		value.then((validator) -> validator.validate(
				(token) -> token.getType().equals(TokenType.STRING) || token.getType().equals(TokenType.CHAR),
				(bag, token) -> bag.set(token)))
		.end((parent,bag) -> {
			bag.set(new StaticValue(bag.<Token>get()));
			return null;
		});
		
		StateTree<JavaElement> value_instance = value.then((validator) -> validator.validate(
				(token) -> token.getValue().equals("new"),
				(bag, token) -> bag.set("newit", token)));
		StateTree<JavaElement> value_name = new StateTree<JavaElement>();
		value.then(value_name);
		value_instance.then(new RedirectStateTree<>(value_name, (global, local) -> {
			System.out.println(local.get()+"");
			if(global.has("newit")) global.set(new InstanceValue(global.<Token>get("newit"), local.<MethodCallValue>get().getToken(), local.<MethodCallValue>get().getParameters()));
			else global.set(local.get());
		}))
			.end((a,b) -> a)
				.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
				.end((a,b) -> a)
					.multiple(braces_container)
					.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		value_name = value_name.then(new RedirectStateTree<>(type, (global, local) -> {
			System.out.println("value_name {");
			System.out.println("global: "+global);
			System.out.println("local: "+local);
			System.out.println("}");
			if(global.get() == null) global.set(local.get());
			else global.set(global.<Token>get().concat(local.get()));
		}));
		value_name.end((parent,bag) -> {
			System.out.println("{value_name} "+bag);
			Value result = new StaticValue(bag.<Token>get());
			bag.set(result);
			return null;
		});
		
		value_name.then((validator) -> validator.validate((token) -> token.getValue().equals(":")) && validator.validate((token) -> token.getValue().equals(":")))
			.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)))
			.end((a,b) -> a);
		
		StateTree<JavaElement> value_call = value_name.then((validator) -> validator.validate(
				(token) -> token.getValue().equals("."),
				(bag, token) -> {
					Value prev = bag.get("prev");
					if(prev == null){
						bag.set("prev", new StaticValue(bag.<Token>get()));
					}else{
						Integer paramters = bag.get("args");
						List<Value> list = null;
						if(paramters != null){
							list = new ArrayList<>();
							for(int i = 0; i < paramters; i++) list.add(bag.<Bag>get("arg"+i).get());
							bag.remove("args");
						}
						MethodCallValue methodCall = new MethodCallValue(prev, bag.get("gen"), bag.get(), list);
						bag.set("prev", methodCall);
						bag.remove("gen");
					}
					bag.set(new Token(token.getLineNumber(), token.getCharacterNumber(), "", TokenType.GROUP));
				}));
		value_call.end((a,b) -> a);
		value_call.then(new RedirectStateTree<>(gen, (global, local) -> global.set("gen", global.<Token>get().concat(local.get())))).then(value_name);
		value_call.then(value_name);
		StateTree<JavaElement> value_array_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("[")));
		StateTree<JavaElement> value_array_end = value_array_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("]")));
		value_array_begin.then(new RedirectStateTree<>(value, (global, local) -> global.set("inside", local)))
			.then(value_array_end);
		value_array_end.end((parent,bag) -> {
			//to change
			bag.set(new MethodCallValue(null, null, bag.get(), null));
			return parent;
		})
			.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
			.end((a,b) -> a)
				.multiple(value_list)
				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		value_array_end.then(value_call);
		value_array_end.then(value_array_begin);
		
		StateTree<JavaElement> value_arg_begin = value_name.then((validator) -> validator.validate(
				(token) -> token.getValue().equals("("),
				(bag, token) -> bag.set(bag.<Token>get().concat(token))));
		StateTree<JavaElement> value_arg_end = value_arg_begin.then((validator) -> validator.validate(
				(token) -> token.getValue().equals(")"),
				(bag, token) -> bag.set(bag.<Token>get().concat(token))));
		value_arg_end.end((parent,bag) -> {
			Integer paramters = bag.get("args");
			List<Value> list = null;
			if(paramters != null){
				list = new ArrayList<>();
				for(int i = 0; i < paramters; i++) list.add(bag.<Bag>get("arg"+i).get());
			}
			
			MethodCallValue methodCall = new MethodCallValue(bag.get("prev"), bag.get("gen"), bag.get(), list);
			bag.set(methodCall);
			return null;
		});
		value_arg_end.then(value_call);
		value_arg_end.then(value_array_begin);
		StateTree<JavaElement> value_generic_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("<")));
		StateTree<JavaElement> value_generic_name = value_generic_begin.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		StateTree<JavaElement> value_generic_split = value_generic_name.then((validator) -> validator.validate((token) -> token.getValue().equals(",")));
		StateTree<JavaElement> value_generic_end = value_generic_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(">")));
		value_generic_end.then(value_arg_begin);
		value_generic_end.then(value_generic_name);
		value_generic_end.then(value_generic_split);
		value_generic_name.then(value_generic_begin);
		value_generic_name.then(value_generic_end);
		value_generic_split.then(value_generic_name);
		StateTree<JavaElement> value_arg = value_arg_begin.then(new RedirectStateTree<>(value, (global, local) -> {
			Integer count = global.get("args");
			if(count == null) count = 0;
			global.set("arg"+count, local);
			global.set("args", (count+1));
		}));
		value_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
			.then(value_arg);
		value_arg.then(value_arg_end);
		
		StateTree<JavaElement> value_left = new StateTree<>();
		
		StateTree<JavaElement> value_parenthesis = value.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
		StateTree<JavaElement> value_cast = value_parenthesis.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
			.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)));
		value_cast.then(value_left);
		StateTree<JavaElement> value_lambda_arg = value_parenthesis.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		value_lambda_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
			.then(value_lambda_arg);
		StateTree<JavaElement> value_lambda = value_parenthesis.then((validator) ->
			validator.validate((token) -> token.getValue().equals(")")) &&
			validator.validate((token) -> token.getValue().equals("-")) &&
			validator.validate((token) -> token.getValue().equals(">")));
		value_lambda.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
			.<JavaElement>end((a,bag) -> {
				bag.set(new LambdaValue(null, new ArrayList<>()));
				return a;
			})
			.multiple(function_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		value_lambda.then(new RedirectStateTree<>(value, (global, local) -> global.set("in", local.get()))).end((a,bag) ->{
			bag.set(new LambdaValue(null, bag.<Value>get("in")));
			return a;
		});
		value_lambda_arg.then(value_lambda);
		StateTree<JavaElement> value_parenthesis_end = value_parenthesis.then(new RedirectStateTree<>(value, (global, local) -> global.set("left", local.get())))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		value_parenthesis_end.end();
		value_parenthesis_end.then(value_call);
		value_parenthesis_end.then(value_left);
		value.then((validator) -> validator.validate((token) -> token.getValue().equals("!"))).then(value);
		value.then((validator) -> validator.validate((token) -> token.getValue().equals("-"))).then(value);
		value.then((validator) -> validator.validate((token) -> token.getValue().equals("+"))).then(value);
		value.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(value);
		StateTree<JavaElement> value_inside = value.then(new RedirectStateTree<>(value, (global, local) -> {
			global.set("left", local.get());
			System.out.println("value_inside "+global);
		}));
		value_inside.then((validator) -> validator.validate((token) -> token.getValue().equals("[")))
			.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals("]")))
			.then(value_left);
		value_inside.then(value_left);
		value_left.end((parent, bag) -> {
			System.out.println("value_left -> end "+bag);
			if(bag.get("left") instanceof Value) bag.set(bag.get("left"));
			else bag.set(new StaticValue(bag.<Token>get("left")));
			return null;
		});
		StateTree<JavaElement> value_equals = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=")));
		value_equals.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_equals.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		StateTree<JavaElement> value_minus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("<"), (bag, token) -> bag.set("action", "<"))).loop();
		value_minus.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_minus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "<="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		StateTree<JavaElement> value_max = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals(">"), (bag, token) -> bag.set("action", ">"))).loop();
		value_max.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_max.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", ">="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("!")) && validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "!="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		StateTree<JavaElement> value_or = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("|"), (bag, token) -> bag.set("action", "|")));
		value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("|"), (bag, token) -> bag.set("action", "||"))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "|="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_or.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		StateTree<JavaElement> value_and = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("&"), (bag, token) -> bag.set("action", "&")));
		value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("&"), (bag, token) -> bag.set("action", "&&"))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "&="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_and.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		StateTree<JavaElement> value_plus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("+"), (bag, token) -> bag.set("action", "+")));
		value_plus.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "+="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("+"), (bag, token) -> bag.set("action", "++"))).end(value_builder);
		StateTree<JavaElement> value_min = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("-"), (bag, token) -> bag.set("action", "-")));
		value_min.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "-="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("-"), (bag, token) -> bag.set("action", "--"))).end(value_builder);
		StateTree<JavaElement> value_div = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("/"), (bag, token) -> bag.set("action", "/")));
		value_div.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_div.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "/="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		StateTree<JavaElement> value_mod = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("%"), (bag, token) -> bag.set("action", "%")));
		value_mod.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_mod.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "%="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		StateTree<JavaElement> value_xor = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("^"), (bag, token) -> bag.set("action", "^")));
		value_xor.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_xor.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "^="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		StateTree<JavaElement> value_mult = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("*"), (bag, token) -> bag.set("action", "*")));
		value_mult.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_mult.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "*="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("?")))
			.then(new RedirectStateTree<>(value, value_right))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(":"), (bag, token) -> bag.set("action", "?:")))
			.then(new RedirectStateTree<>(value, value_right))
			.end(value_builder);
		StateTree<JavaElement> value_instanceof = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("instanceof"), (bag, token) -> bag.set("action", "instanceof")))
			.then(new RedirectStateTree<>(type, value_right));
		value_instanceof.end(value_builder);
		value_instanceof.then(value_left);
		
		braces_container.then(clazz_container);
		StateTree<JavaElement> braces_array = braces_container.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)));
		braces_array.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
			.then(braces_array);
		braces_array.end((a,b) -> a);
	 
	 
	 
	 
	 */
	
}