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.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;

import be.jeffcheasey88.peeratcode.parser.Bag;
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.java.Annotation.Annotable;
import be.jeffcheasey88.peeratcode.parser.java.Function.FunctionContainer;
import be.jeffcheasey88.peeratcode.parser.java.Variable.VariableContainer;
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;
				boolean longCommentary = false;
				while((line = reader.readLine()) != null){
					lineNumber++;
					
					for(int i = 0; i < line.length(); i++){
						char c = line.charAt(i);
						if(longCommentary){
							if(c == '*' && (i < line.length()-1 && line.charAt(i+1) == '/')){
								longCommentary = false;
								i++;
							}
//							System.out.print(c);
							continue;
						}
						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 == '"'){
								String value = "\"";
								int j = i+1;
								for(; j < line.length(); j++){
									c = line.charAt(j);
									if(c == '"'){
										value+=c;
										j++;
										break;
									}else if(c == '\\'){
										value+=c+line.charAt(++j);
									}else{
										value+=c;
									}
								}
								token = new Token(lineNumber, i+1, value, TokenType.STRING);
								i = j-1;
								System.out.println(token);
							}else{
								if(c == '/' && (i < line.length()-1 && line.charAt(i+1) == '/')) break;
								if(c == '/' && (i < line.length()-1 && line.charAt(i+1) == '*')){
									longCommentary = true;
									continue;
								}
								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
		//- Variable
		//- Operation
		//- 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);
					})) mod = true;
			return mod;
		}).end();
		
		//TYPE
		BiConsumer<Bag, Token> concat = (bag, token) -> {
			Token value = bag.get();
			if(value == null) bag.set(token);
			else bag.set(value.concat(token));
		};
		
		StateTree<JavaElement> type = new StateTree<JavaElement>();
		StateTree<JavaElement> type_ = type.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME),concat));
		type_.then((validator) -> validator.validate((token) -> token.getValue().equals("."), concat))
			.then(type_);
		StateTree<JavaElement> gen = new StateTree<>();
		type_.then(gen);
		StateTree<JavaElement> type_begin = gen.then((validator) -> validator.validate((token) -> token.getValue().equals("<"), concat));
		StateTree<JavaElement> type_generic = type_begin.then(new RedirectStateTree<>(type, (global, local) -> global.set(global.<Token>get().concat(local.get()))));
		StateTree<JavaElement> type_generic_end = type_generic.then((validator) -> validator.validate((token) -> token.getValue().equals(">"), concat));
		StateTree<JavaElement> type_generic_split = type_generic.then((validator) -> validator.validate((token) -> token.getValue().equals(","), concat));
		type_generic_split.then(type_generic);
		
		type_begin.then(type_generic_end); //remove ?
		
		StateTree<JavaElement> type_generic_unknow = type_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("?"), concat));
		type_generic_unknow.then(type_generic_end);
		type_generic_split.then(type_generic_unknow);
		type_generic_unknow.then(type_generic_split);
		StateTree<JavaElement> type_generic_unknow_extends = type_generic_unknow.then((validator) -> validator.validate((token) -> token.getValue().equals("extends"), concat))
			.then(new RedirectStateTree<>(type, (global, local) -> global.set(global.<Token>get().concat(local.get()))));
		type_generic_unknow_extends.then(type_generic_end);
		type_generic_unknow_extends.then(type_generic_split);
		StateTree<JavaElement> type_generic_unknow_super = type_generic_unknow.then((validator) -> validator.validate((token) -> token.getValue().equals("super"), concat))
		.then(new RedirectStateTree<>(type, (global, local) -> global.set(global.<Token>get().concat(local.get()))));
		type_generic_unknow_super.then(type_generic_end);
		type_generic_unknow_super.then(type_generic_split);
		
		StateTree<JavaElement> type_generic_named_extends = type_generic.then((validator) -> validator.validate((token) -> token.getValue().equals("extends"), concat))
				.then(new RedirectStateTree<>(type, (global, local) -> global.set(global.<Token>get().concat(local.get()))));
		type_generic_named_extends.then(type_generic_end);
		type_generic_named_extends.then(type_generic_split);
		StateTree<JavaElement> type_generic_named_super = type_generic.then((validator) -> validator.validate((token) -> token.getValue().equals("super"), concat))
				.then(new RedirectStateTree<>(type, (global, local) -> global.set(global.<Token>get().concat(local.get()))));
		type_generic_named_super.then(type_generic_end);
		type_generic_named_super.then(type_generic_split);
		
		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_array_end.then(type_array_begin);
		type_array_end.end();
		
		type_.end();
		type_generic_end.end();
		
		
		StateTree<JavaElement> clazz_container = new StateTree<>();
		clazz_container.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
		StateTree<JavaElement> braces_container = new StateTree<>();
		
		StateTree<JavaElement> function_container = new StateTree<>();
		function_container.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
		
		//VALUE
		BiFunction<JavaElement, Bag, JavaElement> value_builder = (parent, bag) -> {
//			if(bag.has("right")){
//				
//				BiValue result = new BiValue(
//						
//						bag.get("left"),
//						
//						bag.get("action"),
//						
//						bag.get("right"));
//				bag.set(result);
//			}
			return null;
		};
		
		BiConsumer<Bag, Bag> value_right =  (global, local) -> {
			global.set("right", local.get("left"));
		};
		
		StateTree<JavaElement> value = new StateTree<>();
		
		StateTree<JavaElement> value_container = new StateTree<>();
		
		StateTree<JavaElement> value_list = new StateTree<>();
		StateTree<JavaElement> value_list_element = value_list.then(new RedirectStateTree<>(value_container, (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) -> {
			if(validator.validate((token) -> token.getValue().equals("'"))){
				validator.validate((token) -> token.getValue().equals("\\"));
				
				return
						validator.validate((token) -> token.getValue().equals("'"))
						|| 
						(validator.validate((token) -> !token.getValue().equals("'"))
						&& validator.validate((token) -> token.getValue().equals("'")));
			}
			return false;
		}).end();
		
		value.then((validator) -> validator.validate((token) -> {
			System.out.println("string? "+token);
			return token.getType().equals(TokenType.STRING);
		})).end((parent,bag) -> {
			bag.set(new Value(bag.<Token>get()));
			return null;
		});
		
		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(null)))
			.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) -> global.set(local.get())));
		value_name.end((parent,bag) -> {
			Value result = new Value(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(".")));
		value_call.end((a,b) -> a);
		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)
			.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("(")));
		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_name.then(value_generic_end);
		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));
			System.out.println("ah "+local);
		}));
		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_container.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_container, (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("{")))
			.end((a,b) -> a).end((a,b) -> a)
			.multiple(function_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		value_lambda.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
		value_lambda_arg.then(value_lambda);
		StateTree<JavaElement> value_parenthesis_end = value_parenthesis.then(new RedirectStateTree<>(value_container, (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_container.then((validator) -> validator.validate((token) -> token.getValue().equals("!"))).then(value_container);
		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("-"))).then(value_container);
		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("+"))).then(value_container);
		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(value_container);
		StateTree<JavaElement> value_inside = value_container.then(new RedirectStateTree<>(value, (global, local) -> {
			System.out.println("captured "+local);
			global.set("left", local.get());
		}));
		value_inside.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(value_left);
		value_inside.then(value_left);
		value_left.end((parent, bag) -> {
			if(bag.get() == null) bag.set(bag.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_container, value_right)).end(value_builder);
		value_equals.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_minus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "<?="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_max.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", ">?="))).then(new RedirectStateTree<>(value_container, 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_container, 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_container, value_right)).end(value_builder);
		value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "|="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
		value_or.then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "&="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
		value_and.then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "+="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "-="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_div.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "/="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_mod.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "%="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_xor.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "^="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
		value_mult.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "*="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("?")))
			.then(new RedirectStateTree<>(value_container, value_right))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(":"), (bag, token) -> bag.set("action", "?:")))
			.then(new RedirectStateTree<>(value_container, 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_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);
		enum_name.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
		enum_name.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(enum_name);
		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(";"))).end((a,b) -> a);
		enum_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
			.then(enum_arg);
		enum_end.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(enum_name);
		
		//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),
						(bag, token) -> {
							Token name = bag.get("name");
							if(name == null) bag.set("name", token);
							else bag.set("name", name.concat(token));
						}));
		annotation_name.then((validator) -> validator.validate(
				(token) -> token.getValue().equals("."),
				(bag, token) -> {
					Token name = bag.get("name");
					if(name == null) bag.set("name", token);
					else bag.set("name", name.concat(token));
				}))
			.then(annotation_name);
		annotation_name.end((parent, bag) -> {
			Annotation result = new Annotation(bag.get("name"));
			bag.set(result);
			if(parent instanceof Annotable) ((Annotable)parent).addAnnotation(result);
			return null;
		});
		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((parent, bag) -> {
			Annotation result = new Annotation(bag.get("name"), bag.get("values"));
			bag.set(result);
			if(parent instanceof Annotable) ((Annotable)parent).addAnnotation(result);
			return null;
		});
		StateTree<JavaElement> annotation_var = annotation_begin.then((validator) -> validator.validate(
				(token) -> token.getType().equals(TokenType.NAME),
				(bag, token) -> bag.set("index", token)));
		StateTree<JavaElement> annotation_value = annotation_var.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
				.then(new RedirectStateTree<>(value, (global, local) -> {
					Map<Token, Value> map = global.get("values");
					if(map == null){
						map = new LinkedHashMap<>();
						global.set("values", map);
					}
					map.put(global.get("index"), local.get());
				}));
		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) -> {
			Map<Token, Value> map = global.get("values");
			if(map == null){
				map = new LinkedHashMap<>();
				global.set("values", map);
			}
			map.put(null, local.get());
		})).then(annotation_end);
		
		//VARIABLE
		BiFunction<JavaElement, Bag, JavaElement> variable_builder = (parent, bag) -> {
			Integer mod = bag.get("mod");
			Token vtype = bag.get("type");
			Map<Token, Value> map = bag.get("vars");
			for(Entry<Token, Value> vars : map.entrySet()){
				Variable result = new Variable(mod == null ? 0 : mod, vtype, vars.getKey(), false, vars.getValue());
				bag.set(result);
				if(parent instanceof VariableContainer) ((VariableContainer)parent).addVariable(result);
			}
			return null;
		};
		
		InitialStateTree<JavaElement> variable = new InitialStateTree<>();
		variable.multiple(annotation);
		StateTree<JavaElement> variable_mod = variable.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("mod", local.get())));
		StateTree<JavaElement> variable_type = variable.then(new RedirectStateTree<>(type, (global, local) -> global.set("type", local.get())));
		variable_mod.then(variable_type);
		StateTree<JavaElement> variable_name = variable_type.then((validator) -> validator.validate(
				(token) -> token.getType().equals(TokenType.NAME),
				(bag, token) -> {
					Map<Token, Value> map = bag.get("vars");
					if(map == null){
						map = new LinkedHashMap<>();
						bag.set("vars", map);
					}
					bag.set("last", token);
					map.put(token, null);
				}));
		variable_name.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end(variable_builder);
		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.<Map<Token, Value>>get("vars").put(global.get("last"), local.get());
			}));
		variable_value.then(variable_split);
		variable_value.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end(variable_builder);
		variable_value.end(variable_builder);
		
		//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((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_else = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("else")))
			.end((a,b) -> a);
		operation_else.then(operation);
		operation_else.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_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<>(variable, (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")));
		operation_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_named);
			
		
		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> switch_cases = new StateTree<>();
		StateTree<JavaElement> switch_case_begin = switch_cases.then((validator) -> validator.validate((token) -> token.getValue().equals("case")));
		StateTree<JavaElement> switch_case = switch_case_begin.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(":")));
		switch_case.then(switch_case_begin);
		switch_case.end((a,b) -> a)
			.multiple(function_container);
		
		switch_cases.then((validator) -> validator.validate((token) -> token.getValue().equals("default")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(":")))
			.end((a,b) -> a)
			.multiple(function_container);
		
		
		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("switch")))
				.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(")"))
								&& validator.validate((token) -> token.getValue().equals("{")))
				.end((a,b) -> a)
				.multiple(switch_cases)
				.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_first_part = operation_for.then((validator) -> validator.validate((token) -> token.getValue().equals(";")));
		
		
		StateTree<JavaElement> operation_for_modifier = operation_for.then((validator) -> validator.validate((token) -> getModifier(token.getValue()) > 0));
		operation_for_modifier.then(operation_for_modifier);
		
		StateTree<JavaElement> operation_for_type = operation_for.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)));
		operation_for_modifier.then(operation_for_type);
		
		StateTree<JavaElement> operation_for_assign = operation_for.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
		operation_for_modifier.then(operation_for_assign);
		operation_for_type.then(operation_for_assign);
		
		StateTree<JavaElement> operation_for_assign_end = operation_for_assign.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
				.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
		
		operation_for_assign.then(operation_for_assign);
		operation_for_assign.then(operation_for_first_part);
		
		
		operation_for_assign_end.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
		.then(operation_for_assign);
		operation_for_assign_end.then(operation_for_first_part);
		
		
		StateTree<JavaElement> operation_for_second_part = operation_for_first_part.then((validator) -> validator.validate((token) -> token.getValue().equals(";")));
	
		operation_for_first_part.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
			.then(operation_for_second_part);
		
		StateTree<JavaElement> operation_for_end = operation_for_second_part.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
		operation_for_end.end((a,b) -> a);

		operation_for_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);
		
		operation_for_assign.then((validator) -> validator.validate((token) -> token.getValue().equals(":")))
		.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
		.then(operation_for_end);
		
		StateTree<JavaElement> operation_for_update = operation_for_second_part.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
		operation_for_update.then(operation_for_end);
		operation_for_update.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
			.then(operation_for_update);
		
		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_while.then(new RedirectStateTree<>(operation, (global, local) -> global.set(null)))
			.end((a,b) -> a);
		
		operation_while.then((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(")")))
			.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_container.then(variable);
		function_container.then(operation);
		
		//FUNCTION
		BiFunction<JavaElement, Bag, JavaElement> function_builder = (parent, bag) -> {
			buildVariable(bag);
			Integer mod = bag.get("mod");
			Function function = new Function(mod == null ? 0 : mod, bag.get("generic"), bag.get("type"), bag.get("name"), bag.get("param"), bag.get("throws"));
			if(parent instanceof FunctionContainer) ((FunctionContainer)parent).addFunction(function);
			return 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((parent, bag) -> {
			Function build = new Function(Modifier.STATIC, null, null);
			if(parent instanceof FunctionContainer) ((FunctionContainer)parent).addFunction(build);
			return build;
		});
		function_static.multiple(function_container);
		function_static.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
		StateTree<JavaElement> function_mod = function.then(new RedirectStateTree<>(modifier, (global, local) -> {
			Integer mod = global.get("mod");
			if(mod == null) global.set("mod", local.get());
			else global.set("mod", mod+local.<Integer>get());
		}));
		StateTree<JavaElement> function_generic = function.then(new RedirectStateTree<>(gen, (global, local) -> global.set("generic", local.get())));
		StateTree<JavaElement> function_type = function.then(new RedirectStateTree<>(type, (global, local) -> global.set("type", local.get())));
		function_mod.then(function_mod);
		function_mod.then(function_generic);
		function_mod.then(function_type);
		function_generic.then(function_type);
		
		StateTree<JavaElement> function_name = function.then((validator) -> validator.validate(
				(token) -> token.getType().equals(TokenType.NAME),
				(bag, token) -> bag.set("name", token)));
		function_type.then(function_name);
		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(function_builder)
				.multiple(function_container)
				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
		function_end.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end();
		function_end.then((validator) -> validator.validate((token) -> token.getValue().equals("default")))
			.then(new RedirectStateTree<>(value_container, (global, local) -> System.out.println("TODO DEFAULT IN FUNCTION")))
			.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
			.end(function_builder);
		
		StateTree<JavaElement> function_throws = function_end.then((validator) -> validator.validate((token) -> token.getValue().equals("throws")))
				.then(new RedirectStateTree<>(type, (global, local) -> {
					List<Token> throwables = global.get("throws");
					if(throwables == null){
						throwables = new ArrayList<>();
						global.set("throws", throwables);
					}
					throwables.add(local.get());
				}));
		BuilderStateTree<JavaElement,JavaElement> function_start_throws = function_throws.then((validator) -> validator.validate((token) -> token.getValue().equals("{"))).end(function_builder);
		function_start_throws.multiple(function_container);
		function_start_throws.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
		function_throws.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(function_throws);
		function_throws.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end(function_builder);
		
		
		StateTree<JavaElement> function_arg_mod = function_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("final"), (bag, token) -> bag.set("arg_mod", true)));
		StateTree<JavaElement> function_arg_type = function_begin.then(new RedirectStateTree<>(type, (global, local) -> global.set("arg_type", local.get())));
		function_arg_mod.then(function_arg_type);
		StateTree<JavaElement> function_arg_type_array_begin = function_arg_type.then((validator) -> validator.validate((token) -> token.getValue().equals("["), (bag, token) -> bag.set("arg_type", bag.<Token>get("arg_type").concat(token))));
		StateTree<JavaElement> function_arg_type_array_end = function_arg_type_array_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("]"), (bag, token) -> bag.set("arg_type", bag.<Token>get("arg_type").concat(token))));
		function_arg_type_array_end.then(function_arg_type_array_begin);
		StateTree<JavaElement> function_arg_name = function_arg_type.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME), (bag, token) -> bag.set("arg_name", token)));
		function_arg_type_array_end.then(function_arg_name);
		function_arg_type.then((validator) ->
				validator.validate((token) -> token.getValue().equals(".")) &&
				validator.validate((token) -> token.getValue().equals(".")) &&
				validator.validate((token) -> token.getValue().equals("."), (bag, token) -> bag.set("arg_elips", true)))
			.then(function_arg_name);
		StateTree<JavaElement> function_arg_split = function_arg_name.then((validator) -> validator.validate((token) -> token.getValue().equals(","), (bag, token) -> {
			buildVariable(bag);
		}));
		function_arg_split.then(function_arg_mod);
		function_arg_split.then(function_arg_type);
		function_arg_name.then(function_end);
		

		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);
		
		//CLASS
		StateTree<JavaElement> clazz_ = new StateTree<>();
		StateTree<JavaElement> clazz = new StateTree<>();
		
		clazz_container.then(clazz_);
		
		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) -> null)
			.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) -> null)
			.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) -> null)
			.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)));
		StateTree<JavaElement> interface_start = interface_base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")));
		interface_start.end((a,b) -> a)
			.multiple(clazz_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		
		interface_base.then((validator) -> validator.validate((token) -> token.getValue().equals("extends")))
			.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)))
			.then(interface_start);
		
		StateTree<JavaElement> interface_mod = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
		clazz_.then(interfaces);
		interface_mod.then(interfaces);
		
		InitialStateTree<JavaElement> mult_clazz_container = new InitialStateTree<>();
		mult_clazz_container.multiple(clazz_container);
		mult_clazz_container.end((a,b) -> a);
		
		//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)));
		
		StateTree<JavaElement> enum_start = enum_base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")));
		enum_start.end((a,b) -> a)
			.unique(enum_value)
			.unique(mult_clazz_container)
			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
		
		StateTree<JavaElement> enum_implement = enum_base.then((validator) -> validator.validate((token) -> token.getValue().equals("implements")));
		StateTree<JavaElement> enum_implement_name = enum_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);
		}));
		enum_implement_name.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(enum_implement_name);
		enum_implement_name.then(enum_start);
		StateTree<JavaElement> enum_extend = enum_base.then((validator) -> validator.validate((token) -> token.getValue().equals("extends")))
				.then(new RedirectStateTree<>(type, (global, local) -> global.set("extend", local.get())));
		enum_extend.then(enum_start);
		enum_extend.then(enum_implement);
		
		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((parent, bag) -> {
			((JavaFile)parent).addImport(bag);
			return parent;
		});

		
		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((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(tokenizer);
		setStateTree(main);
		
		System.out.println("init");
	}
	
	private static void buildVariable(Bag bag){
		if(!bag.has("arg_name")) return;
		
		List<Variable> parameters = bag.get("param");
		if(parameters == null){
			parameters = new ArrayList<>();
			bag.set("param", parameters);
		}
		
		Integer mod = bag.get("arg_mod");
		
		Variable variable = new Variable(mod == null ? 0 : mod, bag.<Token>get("arg_type"), bag.<Token>get("arg_name"), bag.get("arg_elips") == Boolean.TRUE);
		bag.remove("arg_name");
		bag.remove("arg_mod");
		bag.remove("arg_type");
		bag.remove("arg_name");
		bag.remove("arg_elips");
		
		parameters.add(variable);
	}
	
	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;
			case "default": return Modifier.STRICT;
			default: break;
		}
		return 0;
	}
	
	public static void main(String[] args) throws Exception{
		File file = new File("C:\\Users\\jeffc\\eclipse-workspace\\peer-at-code-backend\\src\\dev\\peerat\\backend\\bonus\\extract\\RouteExtracter.java");
		
		BufferedReader reader = new BufferedReader(new FileReader(file));
		
		time = System.currentTimeMillis();
		
		Parser<JavaElement> parser = new JavaParser();
		JavaFile jFile = new JavaFile();
		parser.parse(reader, jFile);

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