package dev.peerat.parser.java;

import static org.junit.jupiter.api.Assertions.assertEquals;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.function.BiFunction;

import org.junit.jupiter.api.Test;

import dev.peerat.parser.Bag;
import dev.peerat.parser.Parser;
import dev.peerat.parser.Token;
import dev.peerat.parser.TokenType;
import dev.peerat.parser.TokenValidator;
import dev.peerat.parser.java.Annotation.AnnotableBuffer;
import dev.peerat.parser.java.Variable.VariableContainer;
import dev.peerat.parser.java.value.Value;
import dev.peerat.parser.state.InitialStateTree;
import dev.peerat.parser.state.RedirectStateTree;
import dev.peerat.parser.state.StateTree;

public class VariableTests{
	
	public static StateTree<JavaElement> get(){
		BiFunction<JavaElement, Bag, JavaElement> variable_builder = (parent, bag) -> {
			Integer mod = bag.get("mod");
			Token type = bag.get("type");
			Map<Token, Value> map = bag.get("vars");
			for(Entry<Token, Value> vars : map.entrySet()){
				Variable result = new Variable((((AnnotableBuffer)parent).getAnnotationBuffer()), mod == null ? 0 : mod, type, 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(AnnotationTests.get());
		StateTree<JavaElement> variable_mod = variable.then(new RedirectStateTree<>(ModifierTests.get(), (global, local) -> global.set("mod", local.get())));
		StateTree<JavaElement> variable_type = variable.then(new RedirectStateTree<>(TypeTests.get(), (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<>(ValueTests.get(), (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);
		
		return variable;
	}
	
	private static Parser<JavaElement> parser = new Parser<JavaElement>(){
		{
			setTokenizer(ModifierTests.TOKENIZER);
			
			setStateTree(get());
		}
	};
	
	JavaElement testCase(String value) throws Exception{
		TokenValidator.TOKENS = 0;
		TokenValidator.MAX_VALIDATE = 0;
		
		JavaElement result = new Class(null, new Token(0, 0, "Test", TokenType.NAME));
		
		parser.parse(value, result);
		
		assertEquals(TokenValidator.TOKENS, TokenValidator.MAX_VALIDATE);
		
		return result;
	}

	@Test
	void hashMap() throws Exception{
		JavaElement result = testCase("private static final Map<Map<List<String[]>>> map = new HashMap<>();");
	}
}