/*========================================================================
        Copyright (C) 2006 by Geir-Tore Lindsve, Torbjørn Meistad 
        and Yngve Raudberget, hereby refered to as "the authors".
                        All rights reserved

    Permission is hereby granted, without written agreement and without
    license or royalty fees, to use, reproduce, prepare derivative
    works, distribute, and display this software and its documentation
    for NONCOMMERCIAL RESEARCH AND EDUCATIONAL PURPOSES, provided 
    that (1) the above copyright notice and the following two paragraphs 
    appear in all copies of the source code and (2) redistributions, 
    including without limitation binaries, reproduce these notices in 
    the supporting documentation. 

    IN NO EVENT SHALL THE AUTHORS, OR DISTRIBUTORS OF THIS SOFTWARE 
    BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, 
    OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE 
    AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE ABOVE 
    PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    THE AUTHORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
    BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
    FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
    ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO
    OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
    MODIFICATIONS.
========================================================================*/

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
using Iesi.Collections;

using Casper.Exceptions;
using Casper.Data;

namespace Casper.Algorithm
{
    /// <summary>
    /// CaSPers default implementation of the IConsistent interface
    /// </summary>
    public class Consistent
    {
        private List<CSPExprWrapper> rules;
        private LookAheadVarDom currAss;
        private LookAheadVarDom nextAss;
        private Hashtable assignedVars;

        /// <summary>
        /// Initializes a new instance of the <see cref="T:ConsistentImpl"/> class.
        /// </summary>
        /// <param name="expressions">The expressions to be used as rules.</param>
        public Consistent(CSPExpressions expressions)
        {
            this.rules = expressions.WrappedExprList;
        }

        /// <summary>
        /// Verifies whether the assigned variables contains all the variables in the rule or not
        /// </summary>
        /// <param name="vars">Set of variables in the current rule</param>
        /// <returns><c>true</c> if assigned variables contains all variables in "vars"; otherwise, <c>false</c>.</returns>
        public Boolean AssignedVarsContainsAll(Set vars)
        {
            foreach (int varID in vars)
            {
                if (!assignedVars.Contains(varID)) return false;
            }
            return true;
        }

        /// <summary>
        /// Main method for Consistency checks
        /// </summary>
        /// <param name="allAssignedVars">All assigned variables, including currAss and nextAss. Hashtable of LookAheadVarDom objects</param>
        /// <param name="currAss">Current assignment</param>
        /// <param name="nextAss">Next assignment</param>
        /// <returns><c>true</c> if consistent; otherwise, <c>false</c>.</returns>
        /// <exception cref="CasperException"/>
        public Boolean IsConsistent(Hashtable allAssignedVars, LookAheadVarDom currAss, LookAheadVarDom nextAss)
        {
            this.currAss = currAss;
            this.nextAss = nextAss;
            this.assignedVars = allAssignedVars;
            
            for (int i = 0; i < rules.Count; i++)
            {
                /* Checks to make sure that the assigned variables consists of at least all variables for the current rule expression,
                 * and that the current rule either contains nextAss or is a unary constraint which restricts currAss.
                 * If not, skip to the next rule expression */
                if (AssignedVarsContainsAll(rules[i].VariablesInExpr) && (rules[i].VariablesInExpr.Contains(nextAss.VarID) || ((rules[i].VariablesInExpr.Count == 1) && (rules[i].VariablesInExpr.Contains(currAss.VarID)))))
                {
                    try
                    {
                        if (rules[i].RuleExpression.ConsistentCheckExpression(this) == 0) return false;
                    }
                    catch (Exception e) //Makes sure that we handle unknown exceptions as a result of the expression checking (divide-by-zero, etc.)
                    {
                        throw new CasperException("Unknown exception while running consistency check", e);
                    }
                }
            }
            return true;
        }

        /// <summary>
        /// Returns the currently selected value for the variable associated in the expression
        /// </summary>
        /// <param name="rule">Current expression</param>
        /// <returns>Integer value</returns>
        /// <exception cref="CasperException"/>
        public int ConsistentCheckExpression(CSPExprVarInt rule)
        {
            LookAheadVarDom var = (LookAheadVarDom) assignedVars[rule.VarID];
            if(var==null) throw new CasperException("Encountered an unassigned variable during consistency check");
            return (int)var.SelectedValue;
        }

        /// <summary>
        /// Returns the currently selected value for the variable associated in the expression
        /// </summary>
        /// <param name="rule">Current expression</param>
        /// <returns>Integer value</returns>
        /// <exception cref="CasperException"/>
        public int ConsistentCheckExpression(CSPExprVarBool rule)
        {
            LookAheadVarDom var = (LookAheadVarDom)assignedVars[rule.VarID];
            if (var == null) throw new CasperException("Encountered an unassigned variable during consistency check");
            return (int)var.SelectedValue;
        }

        /// <summary>
        /// Returns the currently selected value for the variable associated in the expression
        /// </summary>
        /// <param name="rule">Current expression</param>
        /// <returns>Integer value</returns>
        /// <exception cref="CasperException"/>
        public int ConsistentCheckExpression(CSPExprVarEnum rule)
        {
            LookAheadVarDom var = (LookAheadVarDom)assignedVars[rule.VarID];
            if (var == null) throw new CasperException("Encountered an unassigned variable during consistency check");
            return (int)var.SelectedValue;
        }

        /// <summary>
        /// Returns the Int/Const value of the terminal expression
        /// </summary>
        /// <param name="rule">Current expression</param>
        /// <returns>Integer value</returns>
        public int ConsistentCheckExpression(CSPExprValue rule)
        {
            return rule.Value;
        }

        /// <summary>
        /// Returns the result of the negation.
        /// </summary>
        /// <param name="rule">Current expression</param>
        /// <returns>Integer value</returns>
        public int ConsistentCheckExpression(CSPExprNeg rule)
        {
            return Neg(rule.Left.ConsistentCheckExpression(this));
       }

        /// <summary>
        /// Returns the result of the inversion.
        /// </summary>
        /// <param name="rule">Current expression</param>
        /// <returns>Integer value</returns>
        public int ConsistentCheckExpression(CSPExprNot rule)
        {
            return Not(rule.Left.ConsistentCheckExpression(this));
        }

        /// <summary>
        /// Returns the result of binary expressions
        /// </summary>
        /// <param name="rule">Current expression</param>
        /// <returns>Integer value</returns>
        /// <exception cref="CasperException"/>
        public int ConsistentCheckExpression(CSPExprBin rule)
        {
            switch (rule.Oper)
            {
                case StaticData.Operators.and:
                    return And(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.div:
                    return Div(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.eq:
                    return Equal(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.gt:
                    return GreaterThan(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.gte:
                    return GreaterThanEqual(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.impl:
                    return Impl(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.lt:
                    return LessThan(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.lte:
                    return LessThanEqual(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.minus:
                    return Minus(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.mod:
                    return Mod(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.ne:
                    return NotEqual(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.or:
                    return Or(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.plus:
                    return Add(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                case StaticData.Operators.times:
                    return Times(rule.Left.ConsistentCheckExpression(this), rule.Right.ConsistentCheckExpression(this));
                default:
                    throw new CasperException("Encountered an unhandled operator type during consistency check: " + rule.Oper.ToString());
            }
        }

        /*
         *
         * OPERATOR METHODS
         *
         */

        /// <summary>
        /// Imply.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 >> in2</c></returns>
        private int Impl(int in1, int in2)
        {
            if (in1 != 0 && in2 == 0) return 0;
            return 1;
        }

        /// <summary>
        /// Greater Than.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 > in2</c></returns>
        private int GreaterThan(int in1, int in2)
        {
            if (in1 > in2) return 1;
            return 0;
        }

        /// <summary>
        /// Greater Than Or Equal.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 >= in2</c></returns>
        private int GreaterThanEqual(int in1, int in2)
        {
            if (in1 >= in2) return 1;
            return 0;
        }

        /// <summary>
        /// Less Than.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 &lt; in2</c></returns>
        private int LessThan(int in1, int in2)
        {
            if (in1 < in2) return 1;
            return 0;
        }

        /// <summary>
        /// Less Than Or Equal.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 &lt;= in2</c></returns>
        private int LessThanEqual(int in1, int in2)
        {
            if (in1 <= in2) return 1;
            return 0;
        }

        /// <summary>
        /// Equal.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 = in2</c></returns>
        private int Equal(int in1, int in2)
        {
            if (in1 != in2) return 0;
            return 1;
        }

        /// <summary>
        /// Not Equal.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 != in2</c></returns>
        private int NotEqual(int in1, int in2)
        {
            if (in1 != in2) return 1;
            return 0;
        }

        /// <summary>
        /// Addition.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 + in2</c></returns>
        private int Add(int in1, int in2)
        {
            return in1 + in2;
        }

        /// <summary>
        /// Subtraction.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 - in2</c></returns>
        private int Minus(int in1, int in2)
        {
            return in1 - in2;
        }

        /// <summary>
        /// Multiplication.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 > in2</c></returns>
        private int Times(int in1, int in2)
        {
            return in1 * in2;
        }

        /// <summary>
        /// Negation.
        /// </summary>
        /// <param name="in1">Integer value to negate.</param>
        /// <returns><c>-in1</c></returns>
        private int Neg(int in1)
        {
            return in1 * -1;
        }

        /// <summary>
        /// Inversion.
        /// </summary>
        /// <param name="in1">Integer value to invert.</param>
        /// <returns><c>!in1</c></returns>
        private int Not(int in1)
        {
            if (in1 == 0) return 1;
            else return 0;
        }

        /// <summary>
        /// Division.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 / in2</c></returns>
        private int Div(int in1, int in2)
        {
            return in1 / in2;
        }

        /// <summary>
        /// Modulo.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 % in2</c></returns>
        private int Mod(int in1, int in2)
        {
            return in1 % in2;
        }

        /// <summary>
        /// Boolean Or.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 OR in2</c></returns>
        private int Or(int in1, int in2)
        {
            if (in1 + in2 == 0) return 0;
            return 1;
        }

        /// <summary>
        /// Boolean And.
        /// </summary>
        /// <param name="in1">First value.</param>
        /// <param name="in2">Second value.</param>
        /// <returns>Result of <c>in1 AND in2</c></returns>
        private int And(int in1, int in2)
        {
            if (in1 + in2 >= 2) return 1;
            return 0;
        }

        /// <summary>
        /// Converts integers to boolean values
        /// </summary>
        /// <param name="i">Integer value to convert to bool.</param>
        /// <returns>Boolean representation of <c>in1</c></returns>
        private int Int2Bool(int i)
        {
            if (i == 0) return 0;
            return 1;
        }
    }
}