package be.jeffcheasey88.peeratcode.parser.java;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import be.jeffcheasey88.peeratcode.parser.Parser;
import be.jeffcheasey88.peeratcode.parser.Token;
import be.jeffcheasey88.peeratcode.parser.TokenType;
import be.jeffcheasey88.peeratcode.parser.TokenValidator;
import be.jeffcheasey88.peeratcode.parser.Tokenizer;
import be.jeffcheasey88.peeratcode.parser.state.BuilderStateTree;
import be.jeffcheasey88.peeratcode.parser.state.InitialStateTree;
import be.jeffcheasey88.peeratcode.parser.state.RedirectStateTree;
import be.jeffcheasey88.peeratcode.parser.state.StateTree;

public class JavaParser extends Parser<JavaElement> {
	
	public static long time;
	
	static {
		time = System.currentTimeMillis();
	}
	
	public JavaParser(){
		Tokenizer tokenizer = new Tokenizer(){
			
			@Override
			public void parse(BufferedReader reader) throws Exception{
				int lineNumber = 0;
				String line;
				while((line = reader.readLine()) != null){
					lineNumber++;
					
					for(int i = 0; i < line.length(); i++){
						char c = line.charAt(i);
						Token token;
						if(isNameValid(c)){
							String value = "";
							int j = i;
							for(; j < line.length(); j++){
								c = line.charAt(j);
								if(isNameValid(c)) value+=c;
								else break;
							}
							token = new Token(lineNumber, i+1, value, TokenType.NAME);
							i = j-1;
						}else if(Character.isWhitespace(c)) continue;
						else{
							if(c == '/' && (i == line.length()-1 || line.charAt(i+1) == '/')) break;
							token = new Token(lineNumber, i+1, ""+c, TokenType.DELIMITER);
						}
						getTokens().add(token);
					}
				}
			}
			
			private boolean isNameValid(char c) {
				return Character.isAlphabetic(c) || Character.isDigit(c) || c == '_' || c == '$';
			}
		};
		
		
		//SUMMARY
		//- Modifier
		//- Type
		//- Value
		//- Enum Value
		//- Annotation
		//- Operation
		//- Variable
		//- Function
		//- Class
		//- Interface
		//- Enum
		//- Annotation Clazz
		//- Import
		//- Package
		
		//MODIFIER
		StateTree<JavaElement> modifier = new StateTree<JavaElement>();
		modifier.then((validator) -> {
			boolean mod = false;
			while(validator.validate(
					(token) -> getModifier(token.getValue()) > 0, 
					(bag, token) -> {
						int m = getModifier(token.getValue());
						Integer current = bag.get();
						bag.set(current == null ? m : current+m);
						System.out.println("mod "+token);
					})) mod = true;
			return mod;
		}).end((a,b) -> a);
		
		//TYPE
		StateTree<JavaElement> type = new StateTree<JavaElement>();
		StateTree<JavaElement> type_ = type.then((validator) -> 
			validator.validate(
					(token) -> token.getType().equals(TokenType.NAME),
					(bag, token) -> bag.set(token)));
		StateTree<JavaElement> type_begin = type_.then((validator) -> validator.validate((token) -> token.getValue().equals("<")));
		StateTree<JavaElement> type_generic = type_begin.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)));
		StateTree<JavaElement> type_generic_end = type_generic.then((validator) -> validator.validate((token) -> token.getValue().equals(">")));
		StateTree<JavaElement> type_generic_split = type_generic.then((validator) -> validator.validate((token) -> token.getValue().equals(",")));
		type_generic_split.then(type_generic);
		
		type_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("?")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals("extends")))
			.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)))
			.then(type_generic_end);
		
		type_begin.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)))
		.then((validator) -> validator.validate((token) -> token.getValue().equals("extends")))
		.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)))
		.then(type_generic_end);
		
		type_.end((a,b) -> a);
		type_generic_end.end((a,b) -> a);
		
		StateTree<JavaElement> type_array_begin = type_.then((validator) -> validator.validate((token) -> token.getValue().equals("[")));
		StateTree<JavaElement> type_array_end = type_array_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("]")));
		type_generic_end.then(type_array_begin);
		type_array_end.then(type_array_begin);
		type_array_end.end((a,b) -> a);
		
		
		StateTree<JavaElement> clazz_container = new StateTree<>();
		StateTree<JavaElement> braces_container = new StateTree<>();
		
		//VALUE
		StateTree<JavaElement> value = new StateTree<>();
		
		StateTree<JavaElement> value_container = new StateTree<>();
		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
			.end((a,b) -> a);
		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("!"))).then(value_container);
		StateTree<JavaElement> value_left = value_container.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)));
		value_left.end((a,b) -> a);
		StateTree<JavaElement> value_equals = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("=")));
		value_equals.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_equals.then((validator) -> validator.validate((token) -> token.getValue().equals("="))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		StateTree<JavaElement> value_minus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("<"))).loop();
		value_minus.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_minus.then((validator) -> validator.validate((token) -> token.getValue().equals("="))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		StateTree<JavaElement> value_max = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals(">"))).loop();
		value_max.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_max.then((validator) -> validator.validate((token) -> token.getValue().equals("="))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("!")) && validator.validate((token) -> token.getValue().equals("="))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("|")) && validator.validate((token) -> token.getValue().equals("|"))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("&")) && validator.validate((token) -> token.getValue().equals("&"))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		StateTree<JavaElement> value_plus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("+")));
		value_plus.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("="))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("+"))).end((a,b) -> a);
		StateTree<JavaElement> value_min = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("-")));
		value_min.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("="))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("-"))).end((a,b) -> a);
		StateTree<JavaElement> value_div = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("/")));
		value_div.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_div.then((validator) -> validator.validate((token) -> token.getValue().equals("="))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		StateTree<JavaElement> value_mult = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("*")));
		value_mult.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_mult.then((validator) -> validator.validate((token) -> token.getValue().equals("="))).then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("?")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(":")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.end((a,b) -> a);
		
		StateTree<JavaElement> value_instance = value.then((validator) -> validator.validate((token) -> token.getValue().equals("new")));
		StateTree<JavaElement> value_name = new StateTree<JavaElement>();
		value.then(value_name);
		value_instance.then(new RedirectStateTree<>(value_name, (global, local) -> global.set(local)))
			.end((a,b) -> {
				System.out.println("new "+b);
				return 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((validator) -> validator.validate(
				(token) ->  token.getType().equals(TokenType.NAME),
				(bag, token) -> {
					Token current = bag.get();
					if(current == null) current = token;
					else current = current.concat(token);
					bag.set(current);
				}));
		value_name.end((a,b) -> a);
		
		StateTree<JavaElement> value_call = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals(".")));
		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_container, (global, local) -> global.set("inside", local)))
			.then(value_array_end);
		value_array_end.end((a,b) -> a);
		value_array_end.then(value_call);
		
		StateTree<JavaElement> value_arg_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
		StateTree<JavaElement> value_arg_end = value_arg_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		value_arg_end.end((a,b) -> a);
		value_arg_end.then(value_call);
		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_split.then(value_generic_name);
		StateTree<JavaElement> value_arg = value_arg_begin.then(new RedirectStateTree<>(value_container, (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);
		value.then((validator) -> {
			if(validator.validate((token) -> token.getValue().equals("'"))){
				validator.validate((token) -> token.getValue().equals("\\"));
				return
						validator.validate(
								(token) -> true,
								(bag, token) -> bag.set(token)) &&
						validator.validate((token) -> token.getValue().equals("'"));
			}
			return false;
		}).end((a,b) -> a);
		value.then((validator) -> {
			if(validator.validate((token) -> token.getValue().equals("\""))){
				
				boolean escaped = true;
				while(escaped){
					while(validator.validate(
							(token) -> !token.getValue().equals("\""),
							(bag, token) -> {
								Token current = bag.get();
								if(current == null) current = token;
								else current = current.concat(token);
								bag.set(current);
							}));
					
					if(validator.validate((token) -> token.getValue().equals("\""), (bag, token) -> {
						   Token current = bag.get();
							if(current == null) current = token;
							else current = current.concat(token);
							bag.set(current);
					   })){
					}else escaped = false;
				}
				
				return validator.validate((token) -> token.getValue().equals("\""));
			}
			return false;
		}).end((a,b) -> a);
		
		StateTree<JavaElement> braces_array = braces_container.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
		braces_array.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
			.then(braces_array);
		braces_array.end((a,b) -> a);
		
		//ENUM VALUE
		StateTree<JavaElement> enum_value = new StateTree<>();
		StateTree<JavaElement> enum_name = enum_value.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		enum_name.end((a,b) -> a);
		StateTree<JavaElement> enum_arg = enum_name.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
				.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
		StateTree<JavaElement> enum_end = enum_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		enum_end.end((a,b) -> a);
		enum_end.then((validator) -> validator.validate((token) -> token.getValue().equals(",")) || validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
		enum_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
			.then(enum_arg);
		
		//ANNOTATION
		StateTree<JavaElement> annotation = new StateTree<>();
		StateTree<JavaElement> annotation_name = annotation.then((validator) ->
			validator.validate((token) -> token.getValue().equals("@")) &&
			!validator.validate((token) -> token.getValue().equals("interface")))
				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		annotation_name.then((validator) -> validator.validate((token) -> token.getValue().equals("."))).then(annotation_name);
		annotation_name.end((a,b) -> a);
		StateTree<JavaElement> annotation_begin = annotation_name.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
		StateTree<JavaElement> annotation_end = annotation_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		annotation_end.end((a,b) -> a);
		StateTree<JavaElement> annotation_var = annotation_begin.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		StateTree<JavaElement> annotation_value = annotation_var.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
				.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
		annotation_value.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(annotation_var);
		annotation_value.then(annotation_end);
		annotation_begin.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).then(annotation_end);
		
		StateTree<JavaElement> function_container = new StateTree<>();
		
		//OPERATION
		StateTree<JavaElement> operation = new StateTree<>();
		StateTree<JavaElement> operation_name = operation.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
		operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
		operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> a);
		StateTree<JavaElement> operation_call = operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals(".")));
		operation_call.then(operation_name);
		StateTree<JavaElement> operation_begin = operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
		StateTree<JavaElement> operation_end = operation_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		operation_end.then(operation_call);
		operation_end.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> a);
		StateTree<JavaElement> operation_value = operation_begin.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
		operation_value.then(operation_end);
		operation_value.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(operation_value);
		
		StateTree<JavaElement> operation_return = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("return")));
		operation_return.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> a);
		operation_return.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
		.end((a,b) -> a);
		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("throw")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> a);
		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("do")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> a);
		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("else")))
			.end((a,b) -> a);
		
		StateTree<JavaElement> operation_try = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("try")));
		StateTree<JavaElement> operation_try_base = operation_try.then((validator) -> validator.validate((token) -> token.getValue().equals("{")));
		operation_try.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
			.then(operation_try_base);
		StateTree<JavaElement> operation_try_end = operation_try_base.end((a,b) -> a)
			.multiple(function_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}")))
			.end((a,b) -> a);
		
//		StateTree<JavaElement> operation_finally = operation_try_end.then((validator) -> validator.validate((token) -> token.getValue().equals("finally")))
//				.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);
//		
		StateTree<JavaElement> operation_catch_named = operation_try_end.then((validator) -> validator.validate((token) -> token.getValue().equals("catch")))
				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
				.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)));
		operation_catch_named.then((validator) -> validator.validate((token) -> token.getValue().equals("|")))
			.then(operation_catch_named);
		StateTree<JavaElement> operation_catch = operation_catch_named.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
			.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);
//		operation_catch.then(operation_finally);
//		operation_catch.then(operation_catch);
			
		
		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("continue")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> a);
		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("break")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> a);
		StateTree<JavaElement> operation_if = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("if")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
			.end((a,b) -> a);
		operation_if.then(operation);
		operation_if.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);
		
		StateTree<JavaElement> operation_for = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("for")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
		StateTree<JavaElement> operation_for_init = operation_for.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		StateTree<JavaElement> operation_foreach = operation_for_init.then((validator) -> validator.validate((token) -> token.getValue().equals(":")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		operation_foreach.end((a,b) -> a);
		operation_foreach.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);
		
		
		StateTree<JavaElement> operation_while = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("while")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		operation_while.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);
		
		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("synchronized")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
			.end((a,b) -> a);
		
		//VARIABLE
		InitialStateTree<JavaElement> variable = new InitialStateTree<>();
		variable.multiple(annotation);
		StateTree<JavaElement> variable_mod = variable.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
		StateTree<JavaElement> variable_type = variable.then(new RedirectStateTree<>(type, (global, local) -> global.set("type", local)));
		variable_mod.then(variable_type);
		StateTree<JavaElement> variable_name = variable_type.then((validator) -> validator.validate(
				(token) -> token.getType().equals(TokenType.NAME),
				(bag, token) -> bag.set(token)));
		variable_name.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> new Variable(b));
		StateTree<JavaElement> variable_split = variable_name.then((validator) -> validator.validate((token) -> token.getValue().equals(",")));
		variable_split.then(variable_name);
		StateTree<JavaElement> variable_value = variable_name.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set("value", local)));
		variable_value.then(variable_split);
		variable_value.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end((a,b) -> a);
		
		function_container.then(variable);
		function_container.then(operation);
		
		//FUNCTION
		InitialStateTree<JavaElement> function = new InitialStateTree<>();
		function.multiple(annotation);
		BuilderStateTree<JavaElement,JavaElement> function_static = function.then((validator) -> validator.validate((token) -> token.getValue().equals("static")) && validator.validate((token) -> token.getValue().equals("{"))).end((a,b) -> a);
		function_static.multiple(function_container);
		function_static.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		StateTree<JavaElement> function_mod = function.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
		StateTree<JavaElement> function_type = function.then(new RedirectStateTree<>(type, (global, local) -> global.set("type", local)));
		function_mod.then(function_type);
		
		StateTree<JavaElement> function_name = function_type.then((validator) -> validator.validate(
				(token) -> token.getType().equals(TokenType.NAME),
				(bag, token) -> bag.set(token)));
		StateTree<JavaElement> function_begin = function_name.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
		StateTree<JavaElement> function_end = function_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		function_end.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);
		function_end.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
		
		StateTree<JavaElement> function_throws = function_end.then((validator) -> validator.validate((token) -> token.getValue().equals("throws")))
				.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)));
		BuilderStateTree<JavaElement,JavaElement> function_start_throws = function_throws.then((validator) -> validator.validate((token) -> token.getValue().equals("{"))).end((a,b) -> a);
		function_start_throws.multiple(function_container);
		function_start_throws.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		function_throws.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(function_throws);
		function_throws.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
		
		
		StateTree<JavaElement> function_arg_type = function_begin.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)));
		StateTree<JavaElement> function_arg_name = function_arg_type.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		function_arg_type.then((validator) ->
				validator.validate((token) -> token.getValue().equals(".")) &&
				validator.validate((token) -> token.getValue().equals(".")) &&
				validator.validate((token) -> token.getValue().equals(".")))
			.then(function_arg_name);
		function_arg_name.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(function_arg_type);
		function_arg_name.then(function_end);
		

		clazz_container.then(function);
		clazz_container.then(variable);
		
		braces_container.then(clazz_container);
		
		//CLASS
		StateTree<JavaElement> clazz_ = new StateTree<>();
		StateTree<JavaElement> clazz = new StateTree<>();
		
		StateTree<JavaElement> clazz_base = clazz.then((validator) -> validator.validate((token) -> token.getValue().equals("class")))
			.then(new RedirectStateTree<>(type, (global, local) -> global.set("name", local.get())));
		clazz_base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
			.<JavaElement>end((JavaElement, bag) -> new Class(bag))
			.multiple(clazz_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}")))
			.end((a,b) -> a);
		StateTree<JavaElement> clazz_implement = clazz_base.then((validator) -> validator.validate((token) -> token.getValue().equals("implements")));
		StateTree<JavaElement> clazz_implement_name = clazz_implement.then(new RedirectStateTree<>(type, (global, local) -> {
			Token token = global.get("implement");
			if(token == null) token = local.get();
			else token = token.concat(local.get());
			global.set("implement", token);
		}));
		clazz_implement_name.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(clazz_implement_name);
		clazz_implement_name.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
			.<JavaElement>end((JavaElement, bag) -> new Class(bag))
			.multiple(clazz_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}")))
			.end((a,b) -> a);
		StateTree<JavaElement> clazz_extend = clazz_base.then((validator) -> validator.validate((token) -> token.getValue().equals("extends")))
				.then(new RedirectStateTree<>(type, (global, local) -> global.set("extend", local.get())));
		clazz_extend.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
			.<JavaElement>end((JavaElement, bag) -> new Class(bag))
			.multiple(clazz_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}")))
			.end((a,b) -> a);
		clazz_extend.then(clazz_implement);
		
		
		StateTree<JavaElement> clazz_mod = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
		clazz_.then(clazz);
		clazz_mod.then(clazz);
		
		//INTERFACE
		StateTree<JavaElement> interfaces = new StateTree<>();
		StateTree<JavaElement> interface_base = interfaces.then((validator) -> validator.validate((token) -> token.getValue().equals("interface")))
				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		interface_base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
			.end((a,b) -> a)
			.multiple(clazz_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		
		StateTree<JavaElement> interface_mod = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
		clazz_.then(interfaces);
		interface_mod.then(interfaces);
		
		//ENUM
		StateTree<JavaElement> enums = new StateTree<>();
		StateTree<JavaElement> enum_base = enums.then((validator) -> validator.validate((token) -> token.getValue().equals("enum")))
				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		enum_base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
			.end((a,b) -> a)
			.multiple(enum_value)
			.multiple(clazz_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		
		StateTree<JavaElement> enum_mod = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
		clazz_.then(enums);
		enum_mod.then(enums);
		
		//ANNOTATION CLAZZ
		StateTree<JavaElement> def_annos = new StateTree<>();
		StateTree<JavaElement> def_anno_base = def_annos.then((validator) -> 
		validator.validate((token) -> token.getValue().equals("@")) &&
			validator.validate((token) -> token.getValue().equals("interface")))
				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		def_anno_base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
			.end((a,b) -> a)
			.multiple(clazz_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		
		StateTree<JavaElement> def_anno_mod = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
		clazz_.then(def_annos);
		def_anno_mod.then(def_annos);
		
		//IMPORT
		StateTree<JavaElement> importState = new StateTree<>();
		importState.then((validator) -> {
			if(validator.validate(
					(token) -> token.getValue().equals("import"),
					(bag, token) -> bag.set(new LinkedList<>()))){
				
				validator.validate(
						(token) -> token.getValue().equals("static"),
						(bag, token) -> bag.set("static", null));
				
				while(validator.validate(
						(token) -> !token.getValue().equals(";"),
						(bag, token) -> bag.<List<Token>>get().add(token))
					);
				
				return validator.validate((token) -> token.getValue().equals(";"));
			}
			return false;
		}).<JavaElement>end((javafile, bag) -> javafile);

		
		InitialStateTree<JavaElement> main = new InitialStateTree<>();
		
		//PACKAGE
		StateTree<JavaElement> pack = main.then((validator) -> {	
			if(validator.validate(
					(token) -> token.getValue().equals("package"),
					(bag, token) -> bag.set(new LinkedList<>()))){
				
				while(validator.validate(
						(token) -> !token.getValue().equals(";"),
						(bag, token) -> bag.<List<Token>>get().add(token))
					);
				return validator.validate((token) -> token.getValue().equals(";"));
			}
			return false;
		}).end((javafile, bag) -> javafile);
		main.multiple(pack);
		main.multiple(importState);
		main.multiple(annotation);
		main.multiple(clazz_);
		
		
		System.out.println((System.currentTimeMillis()-time)+"ms");
		
		setTokenizer(tokenizer);
		setStateTree(main);
	}
	
	public static int getModifier(String modifier){
		switch(modifier){
			case "public": return Modifier.PUBLIC;
			case "private": return Modifier.PRIVATE;
			case "protected": return Modifier.PROTECTED;
			case "static": return Modifier.STATIC;
			case "final": return Modifier.FINAL;
			case "synchronized": return Modifier.SYNCHRONIZED;
			case "volatile": return Modifier.VOLATILE;
			case "transient": return Modifier.TRANSIENT;
			case "native": return Modifier.NATIVE;
			case "abstract": return Modifier.ABSTRACT;
			case "strictfp": return Modifier.STRICT;
			default: break;
		}
		return 0;
	}
	
	public static void main(String[] args) throws Exception{
		File file = new File("C:\\Users\\jeffc\\eclipse-workspace\\B1PRB_Janvier2021_Oral_LhoistXavier\\src\\be\\lhoistxavier\\GameFrame.java");
		
		BufferedReader reader = new BufferedReader(new FileReader(file));
		
		time = System.currentTimeMillis();
		
		Parser<JavaElement> parser = new JavaParser();
		JavaElement jFile = new JavaElement();
		parser.parse(reader, jFile);

		System.out.println((System.currentTimeMillis()-time)+"ms");
		
		System.out.println(TokenValidator.MAX_VALIDATE);
		
		parser.build(new BufferedWriter(new FileWriter(new File("/home/ParserV2.txt"))));
	}
}