import java.util.HashMap;
import java.util.Map;

import com.google.common.collect.TreeMultimap;

import constants.Types;
import models.algebra.Constant;
import models.algebra.Expression;
import models.algebra.Type;
import models.algebra.Variable;
import models.terms.Dependency;
import models.terms.Resource;
import models.terms.meta.MetaDynamicDependency;
import models.terms.meta.MetaDynamicDependencyTerm;
import models.terms.meta.MetaEvaluatableTermVariable;
import models.terms.meta.MetaRDLTerm;
import models.terms.meta.MetaResource;
import models.terms.meta.MetaTermGenerator;

public class Main {

	static Type INT = Types.typeInt;

	public static void main(String[] args) {
		//
		sandbox();
		sandbox2();
		sandbox3();
		sandbox4();
		sandbox5();
	}
	
	
	static void sandbox() {
		Expression tmp = utils.ExpressionUtils.parse("x");
		System.out.println(tmp);
		tmp = utils.ExpressionUtils.parse("(x + 5) * 3");
		Map<Variable, Integer> nums = new HashMap<>();
		int a = utils.ExpressionUtils.getCoefficientAndConstantsFromExpression(tmp, nums, 1);
		System.out.println(tmp);
		System.out.println(a);
		System.out.println(nums);
		
		int b = utils.ExpressionUtils.getConstantValue(new  Constant("3"));
		System.out.println(b);
	}
	
	static void sandbox2() {
		TreeMultimap<Integer, Integer> tmp = TreeMultimap.create();
		tmp.put(1, 1);
		tmp.put(1, 2);
		tmp.put(1, 1);
		tmp.put(1, 3);
		System.out.println(tmp.get(1));
	}
	
	static void sandbox3() {
		MetaDynamicDependency d1 = new MetaDynamicDependency((ci, cd, mi, md, context) -> new MetaResource(new Variable("x" + ci)));
		MetaDynamicDependency d2 = new MetaDynamicDependency(new MetaTermGenerator() {
			@Override
			public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map<String, Object> context) {
				if (curIndex == 0 && curDepth < maxDepth) return new MetaDynamicDependency(this);
				else return new MetaResource(new Variable("x" + curIndex + "_" + curDepth));
			} 
		});
		d2.generate(0, 2, 2, null);
		System.out.println(d2.generate(0, 2, 2, null));
	}
	
	static void sandbox4() {
		MetaDynamicDependencyTerm t1 = new MetaDynamicDependencyTerm((ci, cd, mi, md, contex) -> new MetaResource(new Variable("x" + ci)));
		MetaDynamicDependencyTerm t2 = new MetaDynamicDependencyTerm(new MetaTermGenerator() {
			@Override
			public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map<String, Object> context) {
				if (curDepth == 0 && curIndex != 0 && curIndex % 2 == 0) {
					return new MetaDynamicDependencyTerm(this);
				}
				return new MetaResource(new Variable("x" + curDepth + "_" + curIndex));
			}
		});
		System.out.println(t1.generate(0, 5, 0, null));
		System.out.println(t2.generate(0, 3, 2, null));
	}
	
	static void sandbox5() {
		MetaDynamicDependency md1 = new MetaDynamicDependency(new MetaTermGenerator() {
			@Override
			public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map<String, Object> context) {
				int maxOrder = (Integer) context.get("maxOrder");
				if (curDepth < maxDepth && curIndex == 0) {
					return new MetaDynamicDependency(this);
				}
				if (curIndex == 0) {
					return new MetaEvaluatableTermVariable(new Variable("s"), new Constant("" + maxOrder));
				}
				return new MetaEvaluatableTermVariable(new Variable("v" + curDepth), new Constant("" + (maxOrder - (maxDepth - curDepth))));
			}});
		System.out.println(md1.generate(2, 3, Map.of("maxOrder", 4)).toStringWithOrder());
		Dependency d1 = new Dependency(new Resource("s", 4), new Resource("t", 4));
		Dependency d2 = new Dependency(d1, new Resource("v3", 3));
		Dependency d3 = new Dependency(d2, new Resource("v2", 2));
		Dependency d4 = new Dependency(d3, new Resource("v1", 1));
		System.out.println(d3);
		System.out.println(md1.isMatchedBy(d3, Map.of("maxOrder", 4)));
	}
}