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

import org.junit.jupiter.api.Test;

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

import exceptions.SyntaxException;
import models.algebra.Variable;
import models.terms.Dependency;
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.MetaTermGenerator;
import models.terms.meta.OrderVariableConstraint;
import utils.Utils;

public class DependencyTest {

	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, 2);
	Resource e = new Resource("e", Utils.INT, 1);
	Resource f = new Resource("f", Utils.INT, 1);
	
	@Test
	void EqualsTest() {
		
		Dependency d1 = new Dependency(a, b);
		Dependency d2 = new Dependency(a, b, b);
		assertEquals(d1, d2);
		
		Dependency d3 = new Dependency(a, c);
		assertFalse(d1.equals(d3));
		
		Dependency d4 = new Dependency(a, b, c);
		Dependency d5 = new Dependency(a, c, b);
		assertEquals(d4, d5);
		
		Dependency d6 = new Dependency(b, a);
		assertFalse(d1.equals(d6));
	}
	
	@Test
	void OrderTest() {
		
		assertThrows(SyntaxException.class, () -> {
			new Dependency(d, a);
		});
		
		assertThrows(SyntaxException.class, () -> {
			new Dependency(a, b, d);
		});
		
		Dependency d1 = new Dependency(a, b);
		assertEquals(d1.getOrder(), 1);
		assertEquals(d1.getTermOrder(), 0);
		
		Dependency d2 = new Dependency(a, d);
		assertEquals(d2.getOrder(), 2);
		assertEquals(d2.getTermOrder(), 1);
		
		Dependency d3 = new Dependency(a, b, c);
		assertEquals(d3.getOrder(), 1);
	}
	
	@Test
	void StringTest() {
		Dependency d1 = new Dependency(a, b);
		assertEquals(d1.toString(), "a : b");
		
		Dependency d2 = new Dependency(a, b, c);
		assertEquals(d2.toString(), "a : b, c");
		
		Dependency d3 = new Dependency(a, c, b);
		assertEquals(d3.toString(), "a : b, c");
	}
	
	@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 MetaRDLTerm(p, q);
		MetaRDLTerm mt2 = new MetaRDLTerm(p, Set.of(q, r, s));
		MetaRDLTerm mt3 = new MetaRDLTerm(p, Set.of(r, q, s));
		MetaRDLTerm mt4 = new MetaRDLTerm(p, Set.of(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 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 MetaRDLTerm(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());
	}
	
}