package dev.peerat.parser.java.builder;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

import dev.peerat.parser.Parser;
import dev.peerat.parser.Token;
import dev.peerat.parser.java.JavaElement;
import dev.peerat.parser.java.JavaParser;
import dev.peerat.parser.java.tree.JavaTreeType;
import dev.peerat.parser.java.value.ArrayAccessValue;
import dev.peerat.parser.java.value.ArrayValue;
import dev.peerat.parser.java.value.BiValue;
import dev.peerat.parser.java.value.CastValue;
import dev.peerat.parser.java.value.InstanceValue;
import dev.peerat.parser.java.value.LambdaValue;
import dev.peerat.parser.java.value.MethodCallValue;
import dev.peerat.parser.java.value.ModifierValue;
import dev.peerat.parser.java.value.LambdaValue.LambdaParameter;
import dev.peerat.parser.java.value.StaticValue;
import dev.peerat.parser.java.value.TriValue;
import dev.peerat.parser.java.value.Value;
import dev.peerat.parser.java.value.VariableAccessValue;
import dev.peerat.parser.java.value.Value.ValueContainer;
import dev.peerat.parser.java.visitor.JavaVisitor;
import dev.peerat.parser.visitor.Visitor;
import dev.peerat.parser.visitor.VisitorBag;

public class JavaValueBuilder extends JavaBuilder<Value>{

	private static Parser<JavaElement> PARSER = new JavaParser(JavaTreeType.VALUE);
	
	static Value normalize(Value value){
		if(value == null) return null;
		if(value instanceof StaticValue) return normalizeStatic((StaticValue) value);
		if(value instanceof BiValue) return normalizeBi((BiValue) value);
		if(value instanceof TriValue) return normalizeTri((TriValue) value);
		if(value instanceof ArrayAccessValue) return normalizeArrayAccess((ArrayAccessValue) value);
		if(value instanceof ArrayValue) return normalizeArray((ArrayValue) value);
		if(value instanceof CastValue) return normalizeCast((CastValue) value);
		if(value instanceof InstanceValue) return normalizeInstance((InstanceValue) value);
		if(value instanceof LambdaValue) return normalizeLambda((LambdaValue) value);
		if(value instanceof MethodCallValue) return normalizeMethodCall((MethodCallValue) value);
		if(value instanceof ModifierValue) return normalizeModifier((ModifierValue) value);
		if(value instanceof VariableAccessValue) return normalizeVariableAccess((VariableAccessValue) value);
		return null;
	}
	
	static Value normalizeStatic(StaticValue value){
		return new StaticValue(new Token(0,0,value.getToken().getValue(), null));
	}
	
	static Value normalizeBi(BiValue value){
		return new BiValue(normalize(value.left()), value.getAction(), normalize(value.right()));
	}
	
	static Value normalizeTri(TriValue value){
		return new TriValue(normalize(value.getChecker()), normalize(value.success()), normalize(value.fail()));
	}
	
	static Value normalizeArrayAccess(ArrayAccessValue value){
		return new ArrayAccessValue(normalize(value.base()), normalize(value.getAccessor()));
	}
	
	static Value normalizeArray(ArrayValue value){
		Value[] values = value.getValues();
		Value[] result = new Value[values.length];
		for(int i = 0; i < values.length; i++){
			result[i] = normalize(values[i]);
		}
		return new ArrayValue(result);
	}
	
	static Value normalizeCast(CastValue value){
		return new CastValue(new Token(0,0,value.getType().getValue(), null), normalize(value.getValue()));
	}
	
	static Value normalizeInstance(InstanceValue value){
		List<Value> params = value.getParameters();
		List<Value> nparams = new ArrayList<>();
		for(Value param : params) nparams.add(normalize(param));
		InstanceValue result = new InstanceValue(new Token(0,0,value.getToken().getValue(), null), nparams);
		//elements
		return result;
	}
	
	static Value normalizeLambda(LambdaValue value){
		List<LambdaParameter> params = value.getParameters();
		List<LambdaParameter> nparams = new ArrayList<>();
		for(LambdaParameter param : params) nparams.add(new LambdaParameter(new Token(0,0,param.getType().getValue(), null), new Token(0,0,param.getName().getValue(), null)));
		LambdaValue result = new LambdaValue(nparams);
		//elements
		return result;
	}
	
	static Value normalizeMethodCall(MethodCallValue value){
		List<Value> params = value.getParameters();
		List<Value> nparams = new ArrayList<>();
		for(Value param : params) nparams.add(normalize(param));
		return new MethodCallValue(normalize(value.base()), value.getGeneric() == null ? null : new Token(0,0,value.getGeneric().getValue(), null), new Token(0,0,value.getToken().getValue(), null), nparams);
	}
	
	static Value normalizeModifier(ModifierValue value){
		return new ModifierValue(new Token(0,0,value.getModifier().getValue(), null), normalize(value.getValue()));
	}
	
	static Value normalizeVariableAccess(VariableAccessValue value){
		return new VariableAccessValue(normalize(value.base()), new Token(0,0, value.getVariable().getValue(), null));
	}
	
	
	private Value value;
	
	public JavaValueBuilder(String value) throws Exception{
		PARSER.parse(value, new Container());
	}

	@Override
	public Value build(){
		return this.value;
	}

	class Container implements JavaElement, ValueContainer{

		@Override
		public void addValue(Value value) {
			JavaValueBuilder.this.value = value;
		}
		
		@Override
		public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
			return null;
		}
		
		@Override
		public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {}

		@Override
		public VisitorBag visit(Visitor<JavaElement> visitor) {
			return null;
		}
		
	}
}