package terms;

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

import org.junit.jupiter.api.Test;

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

import models.algebra.Variable;
import models.terms.DependencyTerm;
import models.terms.RDLTerm;
import models.terms.Resource;
import models.terms.meta.MatchConstraint;
import models.terms.meta.MetaDynamicTerm;
import models.terms.meta.MetaRDLTerm;
import models.terms.meta.MetaResource;
import models.terms.meta.MetaTermPairGenerator;
import models.terms.meta.MetaTermPairGenerator.TermPair;
import models.terms.meta.OrderVariableConstraint;
import utils.Utils;

public class DependencyTermTest {

	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 EqualsTest() {
		DependencyTerm t1 = new DependencyTerm(a, b, c);
		DependencyTerm t2 = new DependencyTerm(a, b, c);
		assertEquals(t1, t2);
		
		DependencyTerm t3 = new DependencyTerm(a, b, c, b, c);
		assertEquals(t1, t3);
		
		DependencyTerm t4 = new DependencyTerm(a, c, b);
		assertFalse(t1.equals(t4));
		
		DependencyTerm t5 = new DependencyTerm(a, b, c, d, e);
		DependencyTerm t6 = new DependencyTerm(a, d, e, b, c);
		DependencyTerm t7 = new DependencyTerm(a, b, e, d, c);
		assertEquals(t5, t6);
		assertFalse(t5.equals(t7));
		
		DependencyTerm t8 = new DependencyTerm(t1, t5, t6);
		DependencyTerm t9 = new DependencyTerm(t1, t6, t5);
		assertEquals(t8, t9);
		
	}
	
	@Test
	void MatchTest() {
		DependencyTerm t1 = new DependencyTerm(a, b, c, d, e);
		DependencyTerm t2 = new DependencyTerm(a, g, f, b, c);
		MetaResource x = new MetaResource(new Variable("x"));
		MetaResource y = new MetaResource(new Variable("y"));
		MetaResource z = new MetaResource(new Variable("z"));
		MetaResource w = new MetaResource(new Variable("w"));
		MetaResource p = new MetaResource(new Variable("p"));
		MetaResource o = new MetaResource(new Variable("o"));
		MetaResource n = new MetaResource(new Variable("n"));
		MetaRDLTerm mt1 = new MetaRDLTerm(x, y, z, w, p);
		MetaRDLTerm mt2 = new MetaRDLTerm(x, w, p, y, z);
		MetaRDLTerm mt3 = new MetaRDLTerm(x, p, w, y, z);
		MetaRDLTerm mt4 = new MetaRDLTerm(x, n, o, w, p);
		Map<Variable, RDLTerm> binding = new HashMap<>();
		Map<Variable, OrderVariableConstraint> orderConstraint = new HashMap<>();
		Map<Variable, RDLTerm> correctBinding = new HashMap<>();
		correctBinding.put(x.getVariableName(), a);
		correctBinding.put(y.getVariableName(), d);
		correctBinding.put(z.getVariableName(), e);
		correctBinding.put(w.getVariableName(), b);
		correctBinding.put(p.getVariableName(), c);
		mt4.toString();
		Set<MatchConstraint> tmp = mt1.isMatchedBy(t1, new MatchConstraint(binding, orderConstraint));
		assertTrue(! tmp.isEmpty());
		tmp = mt2.isMatchedBy(t1, tmp);
		assertTrue(! tmp.isEmpty());
		assertFalse(! mt3.isMatchedBy(t1, tmp).isEmpty());
		assertTrue(! mt4.isMatchedBy(t2, tmp).isEmpty());
		RDLTerm t = mt1.substitute(tmp.iterator().next().getBinding());
		assertEquals(t, t1);
	}
	
	@Test
	void MatchTest2() {
		MetaResource x = new MetaResource(new Variable("x"));
		MetaResource y = new MetaResource(new Variable("y"));
		MetaResource z = new MetaResource(new Variable("z"));
		MetaResource v = new MetaResource(new Variable("v"));
		MetaResource w = new MetaResource(new Variable("w"));
		MetaResource p = new MetaResource(new Variable("p"));
		MetaResource q = new MetaResource(new Variable("q"));
		
		DependencyTerm t1 = new DependencyTerm(a, b, c, d, e);
		DependencyTerm t2 = new DependencyTerm(a, d, e, f, g);
		MetaRDLTerm mt1 = new MetaRDLTerm(x, p, q, v, w);
		MetaRDLTerm mt2 = new MetaRDLTerm(x, v, w, y, z);
		Map<Variable, RDLTerm> binding = new HashMap<>();
		Map<Variable, OrderVariableConstraint> orderConstraint = new HashMap<>();
		Set<MatchConstraint> tmp = mt1.isMatchedBy(t1, new MatchConstraint(binding, orderConstraint));
		assertTrue(! tmp.isEmpty());
		tmp = mt2.isMatchedBy(t2, tmp);
		assertTrue(! tmp.isEmpty());
	}
	
	@Test
	void MatchTest3() {
		DependencyTerm t1 = new DependencyTerm(a, b, c, d, e);
		DependencyTerm t2 = new DependencyTerm(c, f, g);
		MetaResource o = new MetaResource(new Variable("o"));
		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"));
		MetaResource u = new MetaResource(new Variable("u"));
		MetaRDLTerm mt1 = new MetaRDLTerm(o, p, q, r, s);
		MetaRDLTerm mt2 = new MetaRDLTerm(s, t, u);
		Set<MatchConstraint> tmp = mt1.isMatchedBy(t1);
		assertTrue(! tmp.isEmpty());
		tmp = mt2.isMatchedBy(t2, tmp);
		assertTrue(! tmp.isEmpty());
	}
	
	@Test
	void DynamicMatchTest() {
		Resource a1 = new Resource("a1", Utils.INT, 3);
		Resource a2 = new Resource("a2", Utils.INT, 1);
		Resource a3 = new Resource("a3", Utils.INT, 4);
		Resource a4 = new Resource("a4", Utils.INT, 2);
		Resource a5 = new Resource("a5", Utils.INT, 4);
		DependencyTerm t1 = new DependencyTerm(a1, a2, a3, a4, a5);
		MetaResource x = new MetaResource(new Variable("x"), new Variable("n"));
		MetaDynamicTerm mt1 = new MetaDynamicTerm(x, 
				(MetaTermPairGenerator) (i, depth, isLast) -> 
					new TermPair(
							new MetaResource(new Variable("x" + (2*i + 1)), Utils.parse("n-1-" + i)), 
							new MetaResource(new Variable("x" + (2*i + 2)), Utils.parse("n+1"))
					)
			);
		Set<MatchConstraint> tmp = mt1.isMatchedBy(t1);
		
		assertTrue(! tmp.isEmpty());
	}
	
	@Test
	void DynamicMatchTest2() {
		MetaResource x = new MetaResource(new Variable("x"));
		MetaDynamicTerm mt1 = new MetaDynamicTerm(x, (MetaTermPairGenerator) (i, depth, isLast) -> new TermPair(new MetaResource(new Variable("x" + i)), new MetaResource(new Variable("y"+i))));
		DependencyTerm d1 = new DependencyTerm(a, b, c);
		DependencyTerm d2 = new DependencyTerm(a, b, c, d, e);
		assertTrue(! mt1.isMatchedBy(d1).isEmpty());
		assertTrue(! mt1.isMatchedBy(d2).isEmpty());
	}
	
	@Test
	void OrderTest() {
		Resource text = new Resource("text", Utils.INT, 2);
		Resource wNo = new Resource("wNo", Utils.INT, 2);
		Resource v = new Resource("v", Utils.INT, 1);
		Resource scId = new Resource("scId", Utils.INT, 1);
		Resource curScId = new Resource("curScId", Utils.INT, 0);
		Resource curWNo = new Resource("curWNo", Utils.INT, 1);
		
		DependencyTerm t1 = new DependencyTerm(text, wNo, v);
		DependencyTerm t2 = new DependencyTerm(t1, scId, curScId, v, curWNo);
		assertEquals(t2.getOrder(), 1);
	}
	
}