package inference;
import java.util.Map;

import exceptions.IllegalTypeException;
import lombok.Getter;
import models.algebra.Constant;
import models.algebra.Expression;
import models.algebra.Variable;
import models.terms.meta.OrderConstraint;
import models.terms.meta.OrderVariableConstraint;

@Getter
public class InferenceOrderConstraint {
	
	private final Variable leftSideHandVariable;
	private final int leftSideHandConstant;
	private final OrderConstraint operator;
	private final Variable rightSideHandVariable;
	private final int rightSideHandConstant;
	
	public InferenceOrderConstraint(Expression left, OrderConstraint operator, Expression right) {
		if ((left instanceof Constant) && (right instanceof Constant)) {
			throw new IllegalTypeException("Both left and right can't be Constant");
		}
		if (left instanceof Constant) {
			leftSideHandConstant = Integer.parseInt(((Constant) left).toString());
			leftSideHandVariable = null;
		} else if (left instanceof Variable) {
			leftSideHandConstant = -1;
			leftSideHandVariable = (Variable) left;
		} else {
			throw new IllegalTypeException("Left must be Constant or Variable");
		}
		
		this.operator = operator;
		
		if (right instanceof Constant) {
			rightSideHandConstant = Integer.parseInt(((Constant) right).toString());
			rightSideHandVariable = null;
		} else if (right instanceof Variable) {
			rightSideHandConstant = -1;
			rightSideHandVariable = (Variable) right;
		} else {
			throw new IllegalTypeException("Right must be Constant or Variable");
		}
	}
	
	public boolean check(Map<Variable, OrderVariableConstraint> orderConstraints) {
		switch(this.operator) {
		case EQ:
			return getLeftValue(orderConstraints) == getRightValue(orderConstraints);
		case GE:
			return getLeftValue(orderConstraints) >= getRightValue(orderConstraints);
		case GT:
			return getLeftValue(orderConstraints) > getRightValue(orderConstraints);
		case LE:
			return getLeftValue(orderConstraints) <= getRightValue(orderConstraints);
		case LT:
			return getLeftValue(orderConstraints) < getRightValue(orderConstraints);
		default:
			return false;
		}
	}
	
	private int getLeftValue(Map<Variable, OrderVariableConstraint> orderConstraints) {
		if (this.leftSideHandVariable != null) {
			OrderVariableConstraint constraint = orderConstraints.get(this.leftSideHandVariable);
			return constraint.getLower();
		} else {
			return this.leftSideHandConstant;
		}
	}
	
	private int getRightValue(Map<Variable, OrderVariableConstraint> orderConstraints) {
		if (this.rightSideHandVariable != null) {
			OrderVariableConstraint constraint = orderConstraints.get(this.rightSideHandVariable);
			return constraint.getLower();
		} else {
			return this.rightSideHandConstant;
		}
	}
	
	
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		if (this.leftSideHandVariable != null) {
			sb.append(this.leftSideHandVariable.toString());
		} else {
			sb.append(this.leftSideHandConstant);
		}
		sb.append(" ");
		sb.append(operator.getOperator());
		sb.append(" ");
		if (this.rightSideHandVariable != null) {
			sb.append(this.rightSideHandVariable.toString());
		} else {
			sb.append(this.rightSideHandConstant);
		}
		
		return sb.toString();
		
	}
	
}