package tests.terms.meta;

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

import org.junit.jupiter.api.Test;

import models.algebra.Variable;
import models.terms.Dependency;
import models.terms.DependencyTerm;
import models.terms.Resource;
import models.terms.meta.MetaDependencyTermVariable;
import models.terms.meta.MetaDependencyVariable;
import models.terms.meta.MetaEvaluatableTermVariable;
import models.terms.meta.MetaRDLTermVariable;
import models.terms.meta.MetaResource;
import models.terms.meta.OrderConstraint;

public class MetaResourceVariableTest {

	@Test
	void MetaResourceVariableMathcingWithoutOrder() {
		Resource a = new Resource("a", INT, 0);
		Resource b = new Resource("b", INT, 0);
		Resource c = new Resource("c", INT, 0);
		Dependency dep = new Dependency(a, b);
		DependencyTerm depTerm = new DependencyTerm(a, b, c);
		
		MetaResource x = new MetaResource(new Variable("x"));
		MetaDependencyVariable d = new MetaDependencyVariable(new Variable("d"));
		MetaDependencyTermVariable dte = new MetaDependencyTermVariable(new Variable("dte"));
		MetaEvaluatableTermVariable te = new MetaEvaluatableTermVariable(new Variable("te"));
		MetaRDLTermVariable t = new MetaRDLTermVariable(new Variable("t"));
		
		// a matches x(resource variable)
		assertTrue(x.isMatchedBy(a));
		// a does not match d(dependency)
		assertFalse(d.isMatchedBy(a));
		// a does not match dte(dependency term)
		assertFalse(dte.isMatchedBy(a));
		// a  matches te(evaluatable term)
		assertTrue(te.isMatchedBy(a));
		// a matches t(term)
		assertTrue(t.isMatchedBy(a));
		// [a : b] does not match x(resource variable)
		assertFalse(x.isMatchedBy(dep));
		// [a : b -> c] does not match x(resource variable)
		assertFalse(x.isMatchedBy(depTerm));
	}
	
	@Test
	void MetaResourceVariableMathcingWithConstantOrderEQ() {
		Resource a = new Resource("a", INT, 1);
		MetaResource x = new MetaResource(new Variable("x"), parse("0"));
		MetaResource y = new MetaResource(new Variable("y"), parse("1"));
		//a(1) does not match x(=0)
		assertFalse(x.isMatchedBy(a));
		//a(1) matches y(=1)
		assertTrue(y.isMatchedBy(a));
	}
	
	@Test
	void MetaResourceVariableMathcingWithConstantOrderLT() {
		Resource a = new Resource("a", INT, 1);
		MetaResource x = new MetaResource(new Variable("x"), OrderConstraint.LT, parse("0"));
		MetaResource y = new MetaResource(new Variable("y"), OrderConstraint.LT, parse("1"));
		MetaResource z = new MetaResource(new Variable("z"), OrderConstraint.LT, parse("2"));
		//a(1) does not match x(<0)
		assertFalse(x.isMatchedBy(a));
		//a(1) matches y(<1)
		assertFalse(y.isMatchedBy(a));
		//a(1) matches z(<2)
		assertTrue(z.isMatchedBy(a));
	}
	
	@Test
	void MetaResourceVariableMathcingWithConstantOrderLE() {
		Resource a = new Resource("a", INT, 1);
		MetaResource x = new MetaResource(new Variable("x"), OrderConstraint.LE, parse("0"));
		MetaResource y = new MetaResource(new Variable("y"), OrderConstraint.LE, parse("1"));
		MetaResource z = new MetaResource(new Variable("z"), OrderConstraint.LE, parse("2"));
		//a(1) does not match x(<=0)
		assertFalse(x.isMatchedBy(a));
		//a(1) matches y(<=1)
		assertTrue(y.isMatchedBy(a));
		//a(1) matches z(<=2)
		assertTrue(z.isMatchedBy(a));
	}
	
	@Test
	void MetaResourceVariableMathcingWithConstantOrderGT() {
		Resource a = new Resource("a", INT, 1);
		MetaResource x = new MetaResource(new Variable("x"), OrderConstraint.GT, parse("0"));
		MetaResource y = new MetaResource(new Variable("y"), OrderConstraint.GT, parse("1"));
		MetaResource z = new MetaResource(new Variable("z"), OrderConstraint.GT, parse("2"));
		//a(1) does not match x(>0)
		assertTrue(x.isMatchedBy(a));
		//a(1) matches y(>1)
		assertFalse(y.isMatchedBy(a));
		//a(1) matches z(>2)
		assertFalse(z.isMatchedBy(a));
	}
	
	@Test
	void MetaResourceVariableMathcingWithConstantOrderGE() {
		Resource a = new Resource("a", INT, 1);
		MetaResource x = new MetaResource(new Variable("x"), OrderConstraint.GE, parse("0"));
		MetaResource y = new MetaResource(new Variable("y"), OrderConstraint.GE, parse("1"));
		MetaResource z = new MetaResource(new Variable("z"), OrderConstraint.GE, parse("2"));
		//a(1) does not match x(>=0)
		assertTrue(x.isMatchedBy(a));
		//a(1) matches y(>=1)
		assertTrue(y.isMatchedBy(a));
		//a(1) matches z(>2)
		assertFalse(z.isMatchedBy(a));
	}
	
	@Test
	void MetaResourceVariableMathcingWithVariableOrderEq() {
		Resource a = new Resource("a", INT, 0);
		MetaResource x = new MetaResource(new Variable("x"), parse("x"));
		
		//a(0) matches x(=x)
		assertTrue(x.isMatchedBy(a));
	}
	
	@Test
	void MetaResourceVariableMathcingWithVariableOrderLT() {
		Resource a = new Resource("a", INT, 2);
		MetaResource x = new MetaResource(new Variable("x"), OrderConstraint.LT, parse("x"));
		
		//a(2) matches x(<x)
		assertTrue(x.isMatchedBy(a));
	}
	
	@Test
	void MetaResourceVariableMathcingWithVariableOrderLE() {
		Resource a = new Resource("a", INT, 2);
		MetaResource x = new MetaResource(new Variable("x"), OrderConstraint.LE, parse("x"));
		
		//a(2) matches x(<=x)
		assertTrue(x.isMatchedBy(a));
	}

	@Test
	void MetaResourceVariableMathcingWithVariableOrderGT() {
		Resource a = new Resource("a", INT, 2);
		MetaResource x = new MetaResource(new Variable("x"), OrderConstraint.GT, parse("x"));
		
		//a(2) matches x(>x)
		assertTrue(x.isMatchedBy(a));
	}

	@Test
	void MetaResourceVariableMathcingWithVariableOrderGE() {
		Resource a = new Resource("a", INT, 2);
		MetaResource x = new MetaResource(new Variable("x"), OrderConstraint.GE, parse("x"));
		
		//a(2) matches x(<x)
		assertTrue(x.isMatchedBy(a));
	}
	
}