package terms.meta;

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

import org.junit.jupiter.api.Test;

import java.util.Map;

import models.algebra.Variable;
import models.terms.DependencyTerm;
import models.terms.Resource;
import models.terms.meta.MetaDynamicDependencyTerm;
import models.terms.meta.MetaEvaluatableTermVariable;
import models.terms.meta.MetaRDLTerm;
import models.terms.meta.MetaTermGenerator;

public class MetaDynamicDependencyTermTest {

	Resource a = new Resource("a", 1);
	Resource b = new Resource("b", 1);
	Resource c = new Resource("c", 1);
	Resource d = new Resource("d", 1);
	Resource e = new Resource("e", 1);
	Resource f = new Resource("f", 1);
	Resource g = new Resource("g", 1);
	Resource h = new Resource("h", 1);
	
	@Test
	void DynamicMatchTest() {
		MetaDynamicDependencyTerm mdt1 = new MetaDynamicDependencyTerm(
				new MetaTermGenerator() {
					@Override
					public MetaRDLTerm generate(int curIndex, int curDepth, int maxIndex, int maxDepth, Map<Object, Object> context) {
						if (curDepth == maxDepth && curIndex == 0) {
							return new MetaEvaluatableTermVariable(new Variable("t"));
						}
						if (curIndex == 0) {
							return new MetaDynamicDependencyTerm(this);
						}
						curIndex -= 1;
						if (curIndex % 2 == 0) {
							return new MetaEvaluatableTermVariable(new Variable("s" + curDepth + "_" + curIndex));
						}
						return new MetaEvaluatableTermVariable(new Variable("u" + curDepth + "_" + curIndex));
					}
				}
		);
		DependencyTerm t1 = new DependencyTerm(a, b, c);
		DependencyTerm t2 = new DependencyTerm(t1, b, c, d, e);
		assertFalse(mdt1.isMatchedBy(t1).isEmpty());
		assertFalse(mdt1.isMatchedBy(t2).isEmpty());
	}
	
	
}