package tests;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.HashMap;

import org.junit.Test;

import models.algebra.Expression;
import models.algebra.Position;
import models.algebra.Term;
import models.algebra.Variable;
import models.dataConstraintModel.DataConstraintModel;
import models.dataConstraintModel.JsonType;
import models.dataFlowModel.DataTransferModel;
import parser.Parser;
import parser.Parser.TokenStream;
import parser.exceptions.ExpectedColon;
import parser.exceptions.ExpectedDoubleQuotation;
import parser.exceptions.ExpectedRightBracket;
import parser.exceptions.WrongJsonExpression;

public class InverseTest {
	@Test
	public void test() {
		DataTransferModel model = new DataTransferModel();
		try {
			String lhs = "y";
			String rhs = "(a * x + b) * c";
			
			TokenStream stream = new Parser.TokenStream();
			Parser parser = new Parser(stream);
			stream.addLine(rhs);				

			Expression rhsExp = parser.parseTerm(stream, model);
			System.out.println("=== solve{" + lhs + " = " + rhsExp + "} for a, b, d, x ===");

			HashMap<Position, Variable> rhsVars = rhsExp.getVariables();
			assertEquals(4, rhsVars.size());

			// Solve {y = (a * x + b) + c} for a, b, c, x
			Variable y = new Variable(lhs);
			for (Position vPos: rhsVars.keySet()) {
				Variable v = rhsVars.get(vPos);
				Expression inv = rhsExp.getInverseMap(y, vPos);		// inverse map to get v back from the output value y
				assertTrue(inv.contains(y));
				assertFalse(inv.contains(v));
				System.out.println(rhsVars.get(vPos) + " = " + inv);
			}
			
			// Extract an element in a tuple
			TokenStream stream2 = new Parser.TokenStream();
			Parser parser2 = new Parser(stream2);
			stream2.addLine("fst(tuple(x, y))");
			Expression tupleExp = parser2.parseTerm(stream2, model);
			stream2.addLine("snd(tuple(x, y))");
			Expression tupleExp2 = parser2.parseTerm(stream2, model);
			Expression reduced = ((Term) tupleExp).reduce();
			Expression reduced2 = ((Term) tupleExp2).reduce();
			Variable x = new Variable("x");
			assertEquals(reduced, x);
			assertEquals(reduced2, y);
			System.out.println("=== simplify ===");
			System.out.println(tupleExp + " = " + reduced);
			System.out.println(tupleExp2 + " = " + reduced2);
			
			// Solve {z = fst(x)} for x
			TokenStream stream3 = new Parser.TokenStream();
			Parser parser3 = new Parser(stream3);
			stream3.addLine("fst(x)");
			Expression rhsExp3 = parser3.parseTerm(stream3, model);
			Variable z = new Variable("z");
			System.out.println("=== solve{" + z + " = " + rhsExp3 + "} for x ===");
			HashMap<Position, Variable> rhsVars3 = rhsExp3.getVariables();
			for (Position vPos: rhsVars3.keySet()) {
				Variable v = rhsVars3.get(vPos);
				Expression inv = rhsExp3.getInverseMap(z, vPos);		// inverse map to get v back from the output value z
				if (inv instanceof Term) {
					inv = ((Term) inv).reduce();
				}
				assertTrue(inv.contains(z));
				assertFalse(inv.contains(v));
				System.out.println(rhsVars3.get(vPos) + " = " + inv);
			}			
			
			// Solve {z = x.id} for x
			TokenStream stream4 = new Parser.TokenStream();
			Parser parser4 = new Parser(stream4);
			stream4.addLine("x.id");
			Expression rhsExp4 = parser4.parseTerm(stream4, model);
			System.out.println("=== solve{" + z + " = " + rhsExp4 + "} for x ===");
			HashMap<Position, Variable> rhsVars4 = rhsExp4.getVariables();
			for (Position vPos: rhsVars4.keySet()) {
				Variable v = rhsVars4.get(vPos);
				if (x.getName().equals("x")) {
					JsonType jsonType = new JsonType("Json", new code.ast.ParameterizedType(new code.ast.SimpleType("HashMap")), DataConstraintModel.typeJson);
					jsonType.addMemberType("id", DataConstraintModel.typeInt);
					jsonType.addMemberType("name", DataConstraintModel.typeString);
					v.setType(jsonType);
				}
				Expression inv = rhsExp4.getInverseMap(z, vPos);		// inverse map to get v back from the output value z
				if (inv instanceof Term) {
					inv = ((Term) inv).reduce();
				}
				System.out.println(rhsVars4.get(vPos) + " = " + inv);
				assertTrue(inv.contains(z));
				assertFalse(inv.contains(v));
			}						
		} catch (ExpectedRightBracket | WrongJsonExpression | ExpectedColon | ExpectedDoubleQuotation e) {
			e.printStackTrace();
		}
	}
}