package terms.meta;
import static org.junit.jupiter.api.Assertions.*;
import static utils.Utils.*;

import org.junit.jupiter.api.Test;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import models.algebra.Constant;
import models.algebra.Variable;
import models.terms.Dependency;
import models.terms.DependencyTerm;
import models.terms.RDLTerm;
import models.terms.Resource;
import models.terms.meta.MatchConstraint;
import models.terms.meta.MetaDependency;
import models.terms.meta.MetaDependencyTerm;
import models.terms.meta.MetaDependencyTermVariable;
import models.terms.meta.MetaDynamicTerm;
import models.terms.meta.MetaRDLTerm;
import models.terms.meta.MetaResource;
import models.terms.meta.MetaTermGenerator;
import models.terms.meta.OrderVariableConstraint;
import utils.Utils;

public class MetaDependencyTest {

	
	Resource a = new Resource("a", Utils.INT, 1);
	Resource b = new Resource("b", Utils.INT, 1);
	Resource c = new Resource("c", Utils.INT, 1);
	Resource d = new Resource("d", Utils.INT, 1);
	Resource e = new Resource("e", Utils.INT, 1);
	Resource f = new Resource("f", Utils.INT, 1);
	Resource g = new Resource("g", Utils.INT, 1);
	
	@Test
	void MatchTest() {
		MetaResource p = new MetaResource(new Variable("p"));
		MetaResource q = new MetaResource(new Variable("q"));
		MetaResource r = new MetaResource(new Variable("r"));
		MetaResource s = new MetaResource(new Variable("s"));
		MetaResource t = new MetaResource(new Variable("t"));
		
		MetaRDLTerm mt1 = new MetaDependency(p, q);
		MetaRDLTerm mt2 = new MetaDependency(p, q, r, s);
		MetaRDLTerm mt3 = new MetaDependency(p, r, q, s);
		MetaRDLTerm mt4 = new MetaDependency(p, s, r, q);
		
		Dependency d1 = new Dependency(a, b);
		Dependency d2 = new Dependency(a, b, c, f);
		Dependency d3 = new Dependency(a, f, c, b);
		Dependency d4 = new Dependency(a, b, f, c);
		Dependency d5 = new Dependency(a, b, e, f);
		
		
		Map<Variable, RDLTerm> binding = new HashMap<>();
		Map<Variable, OrderVariableConstraint> orderConst = new HashMap<>();
		Set<MatchConstraint> tmp = new HashSet<>();
		tmp = mt1.isMatchedBy(d1, new MatchConstraint(binding, orderConst));
		assertTrue(! tmp.isEmpty());
		assertEquals(tmp.iterator().next().getBinding().get(p.getVariableName()), a);
		assertEquals(tmp.iterator().next().getBinding().get(q.getVariableName()), b);
		tmp = mt2.isMatchedBy(d2, new MatchConstraint(binding, orderConst));
		assertTrue(!tmp.isEmpty());
		tmp = mt3.isMatchedBy(d2, tmp);
		assertTrue(!tmp.isEmpty());
		tmp = mt4.isMatchedBy(d2, tmp);
		assertTrue(!tmp.isEmpty());
		tmp = mt4.isMatchedBy(d5, tmp);
		assertFalse(!tmp.isEmpty());
	}
	
	@Test
	void MetaDependencyMatchingWithoutOrderTest() {
		Resource a = new Resource("a", INT, 1);
		Resource b = new Resource("b", INT, 1);
		Resource c = new Resource("c", INT, 1);
		Dependency dep1 = new Dependency(a, b);
		DependencyTerm te1 = new DependencyTerm(a, b, c);
		Dependency dep2 = new Dependency(te1, b);
		
		MetaResource v1 = new MetaResource(new Variable("v1"));
		MetaResource v2 = new MetaResource(new Variable("v2"));
		MetaResource v3 = new MetaResource(new Variable("v3"));
		MetaDependencyTermVariable vte = new MetaDependencyTermVariable(new Variable("vte"));
		MetaRDLTerm metaDep = new MetaDependency(v1, v2);
		MetaRDLTerm metaDep2 = new MetaDependency(vte, v2);
		MetaRDLTerm metaTe = new MetaDependencyTerm(v1, v2, v3);
		MetaRDLTerm metaDep3 = new MetaDependency(metaTe, v2);
		MetaRDLTerm metaDep4 = new MetaDependency(metaTe, v3);
		
		//[a : b] matches [v1 : v2]
		assertTrue(! metaDep.isMatchedBy(dep1).isEmpty());
		//[[a : b -> c] : b] does not match [v1 : v2]
		assertFalse(! metaDep.isMatchedBy(dep2).isEmpty());
		//[[a : b -> c] : b] matches [vte : v2]
		assertTrue(! metaDep2.isMatchedBy(dep2).isEmpty());
		//[[a : b -> c] : b] matches [[v1 : v2 -> v3] : v2]
		assertTrue(! metaDep3.isMatchedBy(dep2).isEmpty());
		//[[a : b -> c] : b] does not match [[v1 : v2 -> v3] : v3]
		assertFalse(! metaDep4.isMatchedBy(dep2).isEmpty());
	}
	
	@Test
	void MetaDependencyMatchingWithConstantOrderTest() {
		MetaResource v1 = new MetaResource(new Variable("v1"), new Constant("1"));
		MetaResource v2 = new MetaResource(new Variable("v2"), new Constant("2"));
		MetaRDLTerm vd1 = new MetaDependency(v1, v2);
		
		Resource a1 = new Resource("a1", INT, 1);
		Resource a2 = new Resource("a2", INT, 2);
		Dependency d1 = new Dependency(a1, a2);
		//[1 : 2] matches [1 : 2]
		assertTrue(! vd1.isMatchedBy(d1).isEmpty());
		
		Resource b1 = new Resource("b1", INT, 1);
		Dependency d2 = new Dependency(a1, b1);
		//[1 : 1] does not match [1 : 2]
		assertFalse(! vd1.isMatchedBy(d2).isEmpty());
	}
	
	@Test
	void MetaDependencyMatchingWithVariableOrderTest() {
		MetaResource v1 = new MetaResource(new Variable("v1"), parse("x"));
		MetaResource v2 = new MetaResource(new Variable("v2"), parse("x"));
		MetaResource v3 = new MetaResource(new Variable("v3"), parse("y"));
		MetaRDLTerm vd1 = new MetaDependency(v1, v2);
		MetaRDLTerm vd2 = new MetaDependency(v1, v3);
		MetaRDLTerm vd3 = new MetaDependency(new MetaDependency(v3, v1), v2);
		
		Resource a1 = new Resource("a1", INT, 1);
		Resource a2 = new Resource("a2", INT, 2);
		Resource b1 = new Resource("b1", INT, 1);
		Resource b2 = new Resource("b2", INT, 2);
		Dependency d1 = new Dependency(a1, a2);
		Dependency d2 = new Dependency(a1, b1);
		Dependency d3 = new Dependency(new Dependency(a1, b1), a2);
		Dependency d4 = new Dependency(new Dependency(a1, a2), b2);
		//[1 : 2] does not match [x : x]
		assertFalse(! vd1.isMatchedBy(d1).isEmpty());
		//[1 : 1] matches [x : x]
		assertTrue(! vd1.isMatchedBy(d2).isEmpty());
		//[1 : 2] matches [x : y]
		assertTrue(! vd2.isMatchedBy(d1).isEmpty());
		//[1 : 1] matches [x : y]
		assertTrue(! vd2.isMatchedBy(d2).isEmpty());
		//[[1 : 1] : 2] does not match [[y : x] : x]
		assertFalse(! vd3.isMatchedBy(d3).isEmpty());
		//[[1 : 2] : 2] matches [[y : x] : x]
		assertTrue(! vd3.isMatchedBy(d4).isEmpty());
	}
	
	@Test
	void DynamicMatchTest() {
		MetaResource x = new MetaResource(new Variable("x"));
		MetaDynamicTerm md1 = new MetaDynamicTerm(x, new MetaTermGenerator() {
			@Override
			public MetaRDLTerm generate(int index, int depth, boolean isLast) {
				if (index != 0) {
					return new MetaResource(new Variable("r" + index));
				} else {
					return new MetaResource(new Variable("y"));
				}
			}});
		MetaRDLTerm md2 = new MetaDependency(new MetaResource(new Variable("y")), new MetaResource(new Variable("z")));
		Dependency d1 = new Dependency(a, b, c);
		Dependency d2 = new Dependency(c, d);
		Dependency d3 = new Dependency(b, d);
		
		Set<MatchConstraint> tmp = md1.isMatchedBy(d1);
		assertTrue(!tmp.isEmpty());
		assertTrue(! md2.isMatchedBy(d2, tmp).isEmpty());
		assertTrue(! md2.isMatchedBy(d3, tmp).isEmpty());
	}
	
}