/**
  *
  *                      OOAS Compiler
  *
  *       Copyright 2015, AIT Austrian Institute of Technology.
  * This code is based on the C# Version of the OOAS Compiler, which is
  * copyright 2015 by the Institute of Software Technology, Graz University
  * of Technology with portions copyright by the AIT Austrian Institute of
  * Technology. All rights reserved.
  *
  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.
  *
  * If you modify the file please update the list of contributors below to in-
  * clude your name. Please also stick to the coding convention of using TABs
  * to do the basic (block-level) indentation and spaces for anything after
  * that. (Enable the display of special chars and it should be pretty obvious
  * what this means.) Also, remove all trailing whitespace.
  *
  * Contributors:
  *               Willibald Krenn (AIT)
  *               Stephan Zimmerer (AIT)
  *               Markus Demetz (AIT)
  *               Christoph Czurda (AIT)
  *
  */


package org.momut.ooas.math;

import org.momut.ooas.ast.expressions.ExpressionKind;
import org.momut.ooas.utils.exceptions.ArgumentException;
import org.momut.ooas.utils.exceptions.NotImplementedException;

public class Operations<T> extends AbstractOperations
{
	public static class BasicOps<T> {
		public T unMinus(T input) {throw new NotImplementedException();}

		public T minus(T inputA, T inputB) {throw new NotImplementedException();}
		public T plus(T inputA, T inputB) {throw new NotImplementedException();}
		public T div(T inputA, T inputB) {throw new NotImplementedException();}
		public T pow(T inputA, T inputB) {throw new NotImplementedException();}
		public T prod(T inputA, T inputB) {throw new NotImplementedException();}
		public T mod(T inputA, T inputB) {throw new NotImplementedException();}

		public boolean equal(T inputA, T intputB) {throw new NotImplementedException();}
		public boolean smaller(T inputA, T intputB) {throw new NotImplementedException();}
		public boolean greater(T inputA, T intputB){throw new NotImplementedException();}

		public T getDefaultValue() {throw new NotImplementedException();}
	}

	protected final BasicOps<T> m_basicOperations;


	@SuppressWarnings("unchecked")
	@Override
	public AbstractRange GenericArithmeticCover(AbstractRange type1, AbstractRange type2, ExpressionKind op)
	{
		final Range<T> a = (Range<T>) type1;
		final Range<T> b = (Range<T>) type2;

//		Range<T> a = type1 as Range<T>;
//		Range<T> b = type2 as Range<T>;

		if (a == null || b == null)
			throw new ArgumentException();

		return GenericArithmeticCover(a, b, op);
	}

	public Range<T> GenericArithmeticCover(Range<T> type1, Range<T> type2, ExpressionKind op)
	{
		final T defaultValue = m_basicOperations.getDefaultValue();
		final Range<T> result = type1.Create(defaultValue, defaultValue);

		switch (op)
		{
			case unminus:
				result.min = m_basicOperations.unMinus(type1.max);
				result.max = m_basicOperations.unMinus(type1.min);
				break;
			case unplus:
				break;

			case minus:
				assert(type2 != null);
				// we do some sort of resulttype = type1 - type2
				// hence, do the unminus stuff with type 2
				final T spare = type2.max;
				type2.max = m_basicOperations.unMinus(type2.min);
				type2.min = m_basicOperations.unMinus(spare);
				// now it's the same as with sum.. but c# does not let us fall through..
				result.min = m_basicOperations.plus(type1.min, type2.min);
				result.max = m_basicOperations.plus(type1.max, type2.max);
				break;
			case sum:
				assert(type2 != null);
				result.min = m_basicOperations.plus(type1.min, type2.min);
				result.max = m_basicOperations.plus(type1.max, type2.max);
				break;
			case idiv:
			case div:
				// get the closest values to 0 for the divisor.
				assert(type2 != null);
				final Range<T> closestToZero = type2.Create(defaultValue, defaultValue);
				if (m_basicOperations.greater(type2.max, defaultValue) && (m_basicOperations.greater(type2.min, defaultValue) || m_basicOperations.equal(type2.min, defaultValue))) {
					// divisor range [X...0+]
					closestToZero.max = m_basicOperations.equal(type2.min, defaultValue) ? type2.precision : type2.min; // type2.min or type2.precision if that was 0
					closestToZero.min = closestToZero.max;
				} else if (m_basicOperations.smaller(type2.max, defaultValue) && (m_basicOperations.smaller(type2.min, defaultValue) || m_basicOperations.equal(type2.min, defaultValue))) {
					// divisor range [0-...-X]
					closestToZero.max = m_basicOperations.equal(type2.min, defaultValue) ? m_basicOperations.unMinus(type2.precision) : type2.min; // type2.min or -type2.precision if that was 0
					closestToZero.min = closestToZero.max;
				} else {
					// divisor range [Y ... -X]
					closestToZero.max = type2.precision;
					closestToZero.min = m_basicOperations.unMinus(type2.precision);
				}

				result.max = m_basicOperations.div(type1.min, closestToZero.min);
				result.min = result.max;

				T tmp = m_basicOperations.div(type1.max, closestToZero.min);
				result.max = m_basicOperations.smaller(result.max, tmp) ? tmp : result.max;
				result.min = m_basicOperations.greater(result.min, tmp) ? tmp : result.min;

				tmp = m_basicOperations.div(type1.min, closestToZero.max);
				result.max = m_basicOperations.smaller(result.max, tmp) ? tmp : result.max;
				result.min = m_basicOperations.greater(result.min, tmp) ? tmp : result.min;

				tmp = m_basicOperations.div(type1.max, closestToZero.max);
				result.max = m_basicOperations.smaller(result.max, tmp) ? tmp : result.max;
				result.min = m_basicOperations.greater(result.min, tmp) ? tmp : result.min;
				break;
			case mod:
				throw new ArgumentException(); // do this one level up
			case pow:
				// ok, this is bad. - just give up here
				result.max = result.typemax;
				result.min = result.typemin;
				break;
			case prod:
				// hmm, brute force.. is there some formula?
				result.max = m_basicOperations.prod(type1.min, type2.min);
				result.min = result.max;

				tmp = m_basicOperations.prod(type1.max, type2.min);
				result.max = m_basicOperations.smaller(result.max, tmp) ? tmp : result.max;
				result.min = m_basicOperations.greater(result.min, tmp) ? tmp : result.min;

				tmp = m_basicOperations.prod(type1.min, type2.max);
				result.max = m_basicOperations.smaller(result.max, tmp) ? tmp : result.max;
				result.min = m_basicOperations.greater(result.min, tmp) ? tmp : result.min;

				tmp = m_basicOperations.prod(type1.max, type2.max);
				result.max = m_basicOperations.smaller(result.max, tmp) ? tmp : result.max;
				result.min = m_basicOperations.greater(result.min, tmp) ? tmp : result.min;
				break;

			default:
				throw new NotImplementedException();
		}
		return result;
	}


	public Operations()
	{
		m_basicOperations = new BasicOps<T>();
	}

	public Operations(BasicOps<T> basicOperations)
	{
		m_basicOperations = basicOperations;
	}
}