/*========================================================================
        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.Text;
using System.IO;

using CLab.Data;
using CLab.BDD;
using CLab.CSP;
using CLab.Exceptions;

namespace CLab
{
    /// <summary>
    /// The interface class for the library. The library is designed in such way, that 
    /// everything should be done through this class.
    /// </summary>
    public class Clab
    {

        private CLabModus modus;
        private Casper.CspVariableOrdering cspVariableOrdering = Casper.CspVariableOrdering.vo_static;
        private BddCompileMethod bddCompileMethod = BddCompileMethod.cm_static;
        private String inputFileName;
        private CP cp;
        private Symbols symbols;
        private ClabCSP clabCSP;
        private ClabBDD clabBDD;
        private int statusUpdateCount = 0;
        private int initbddnodes = Common.INITBDDNODES;
        private int initdbcache = Common.BDDINITDBCACHE;
        private int maxincrease = Common.BDDMAXINCREASE;

        /// <summary>
        /// Delegate for updating status information during search.
        /// </summary>
        /// <param name="value">The new status information.</param>
        public delegate void StatusEventHandler(int value);

        /// <summary>
        /// Initializes a new instance of the <see cref="T:Clab"/> class.
        /// </summary>
        /// <param name="fileName">Name of the csp problem file.</param>
        /// <exception cref="T:CLab.Exceptions.ClabException">Thrown when an error occurs during initialization.</exception>
        public Clab(String fileName)
        {
            try
            {
				this.inputFileName = fileName;
                cp = new CP(inputFileName);
                symbols = new Symbols(cp);

                for (int i = 0; i < cp.Rules.Count; i++)
                {
                    symbols.CheckExpressionType(cp.Rules[i]);
                }
            }
            catch (ClabSymbolException e)
            {
                throw new ClabException(e.Message, e);
            }
            catch (Exception e)
            {
                throw new ClabException(e.Message, e);
            }
        }


        /// <summary>
        /// Initializes a new instance of the <see cref="T:Clab"/> class.
        /// </summary>
        /// <param name="xmlStream">The cp file stream.</param>
        /// <exception cref="T:CLab.Exceptions.ClabException">Thrown when an error occurs during initialization.</exception>
        public Clab(Stream xmlStream)
        {
            try
            {
                cp = new CP(xmlStream);
                symbols = new Symbols(cp);

                for (int i = 0; i < cp.Rules.Count; i++)
                {
                    symbols.CheckExpressionType(cp.Rules[i]);
                }
            }
            catch (ClabXMLParserException e)
            {
                throw new ClabException(e.Message, e);
            }
            catch (ClabSymbolException e)
            {
                throw new ClabException(e.Message, e);
            }
            catch (Exception e)
            {
                throw new ClabException(e.Message, e);
            }
        }

        /// <summary>
        /// Initializes the specified modus, BDD if modus = 0 or CSP if modus = 1.
        /// </summary>
        /// <param name="modus">The modus.</param>
        /// <returns>The initial domain values, before the rules are applied.</returns>
        /// <exception cref="T:CLab.Exceptions.ClabException">Thrown when an error occurs during initialization.</exception>
        public ValidDomains InitializeProblemSolver(CLabModus modus)
        {
            try
            {
                this.modus = modus;
                if (modus.Equals(CLabModus.bdd_modus))
                {
                    clabBDD = new ClabBDD(this, cp, symbols, initdbcache, initbddnodes, maxincrease);
                }
                else if (modus.Equals(CLabModus.csp_modus))
                {
                    clabCSP = new ClabCSP(this, cp, symbols);
                    clabCSP.SetVariableOrdering(cspVariableOrdering);
                }
                else throw new ClabException("Invalid modus, Clab.cs"); 
            }
            catch (ClabException)
            {
                throw;
            }
            ValidDomains vDomains = new ValidDomains();
            try
            {
                if (modus == CLabModus.bdd_modus)
                {
                    vDomains = clabBDD.GetValidDomains();
                }
                else if (modus == CLabModus.csp_modus)
                {
                    vDomains = clabCSP.GetValidDomains();
                }
                else throw new ClabException("Invalid modus");
            }
            catch (ClabException e)
            {
                throw new ClabException("Error getting original problem domains", e);
            }
            return vDomains;
         }

        /// <summary>
        /// Event for updating status information out of the library.
        /// </summary>
        public event StatusEventHandler StatusEvent;

        /// <summary>
        /// Gets the <see cref="T:CLab.Data.CP"></see> problem instance.
        /// </summary>
        /// <value>The current <see cref="T:CLab.Data.CP"></see> instance.</value>
        public CP Cp
        {
            get { return cp; }
        }

        /// <summary>
        /// Sets the CSP variable ordering. <see cref="F:CspVariableOrdering"></see>
        /// </summary>
        /// <param name="varOrdering">The variable ordering.</param>
        public void SetCSPVariableOrdering(CspVariableOrdering varOrdering)
        {
            if (varOrdering == CspVariableOrdering.vo_static) this.cspVariableOrdering = Casper.CspVariableOrdering.vo_static;
            else this.cspVariableOrdering = Casper.CspVariableOrdering.vo_minwidth;

            if (clabCSP != null)
            {
                clabCSP.SetVariableOrdering(cspVariableOrdering);
            }
        }

        /// <summary>
        /// Sets the BDD compile method.
        /// </summary>
        /// <param name="compileMethod"></param>
        public void SetBddCompileMethod(BddCompileMethod compileMethod)
        {
            this.bddCompileMethod = compileMethod;
        }

        /// <summary>
        /// Gets the valid domains for the constraint problem.
        /// </summary>
        /// <returns>Valid domains.</returns>
        /// <exception cref="T:CLab.Exceptions.ClabException"/>
        public ValidDomains GetValidDomains()
        {
            try
            {
                ValidDomains vDomains = new ValidDomains();
                if (modus == CLabModus.bdd_modus)
                {
                    clabBDD.CompileAllExpressions(bddCompileMethod);
                    vDomains = clabBDD.GetValidDomains();
                }
                else if (modus == CLabModus.csp_modus)
                {
                    clabCSP.RunCSPSearch();
                    vDomains = clabCSP.GetValidDomains();
                }
                else throw new ClabException("Invalid modus");
                return vDomains;
            }
            catch (ClabException e)
            {
                throw new ClabException("Could not get valid domains", e);
            }
        }

        /// <summary>
        /// Gets the valid domains for extra rule added by the user. The 
        /// rule in this case is a chosen domain value for a single variable.
        /// </summary>
        /// <param name="variable">The variable that has been assigned a domain value by the user.</param>
        /// <param name="selectedDomain">The selected domain value for the variable.</param>
        /// <returns>The valid domains after search with the extra rule added.</returns>
        /// <exception cref="T:CLab.Exceptions.ClabException"/>
        public ValidDomains GetValidDomainsExtraRule(String variable, String selectedDomain)
        {
            try
            {
                ValidDomains vDomains = new ValidDomains();
                if (modus == CLabModus.bdd_modus)
                {
                    clabBDD.UpdateResultBDDUserChoice(variable, selectedDomain);
                    vDomains = clabBDD.GetValidDomains();
                }
                else if (modus == CLabModus.csp_modus)
                { 
                    clabCSP.RunCSPSearchUserChoice(variable, selectedDomain);
                    vDomains = clabCSP.GetValidDomains();
                }
                else throw new ClabException("Invalid modus");
                return vDomains;
            }
            catch (ClabException e)
            {
                throw new ClabException("Could not get valid domains, user select", e);
            }
        }

        /// <summary>
        /// Gets the valid domains for an extra rule. The rule can be any expression.
        /// </summary>
        /// <param name="expr">The added expression.</param>
        /// <returns>The valid domains after search with the extra rule added.</returns>
        /// <exception cref="T:CLab.Exceptions.ClabException"/>
        public ValidDomains GetValidDomainsExtraRule(Expression expr)
        {
            try
            {
                ValidDomains vDomains = new ValidDomains();
                if (modus == CLabModus.bdd_modus)
                {
                    clabBDD.UpdateResultBddExpr(expr);
                    vDomains = clabBDD.GetValidDomains();
                }
                else if (modus == CLabModus.csp_modus)
                {
                    symbols.CheckExpressionType(expr);
                    clabCSP.AddExtraRule(expr);
                    clabCSP.RunCSPSearch();
                    vDomains = clabCSP.GetValidDomains();
                }
                else throw new ClabException("Invalid modus");
                return vDomains;
            }
            catch (ClabException e)
            {
                throw new ClabException("Could not get valid domains for extra rule", e);
            }
            catch (ClabSymbolException e)
            {
                throw new ClabException("Could not get valid domains for extra rule", e);
            }
        }

        /// <summary>
        /// Updates the status of the currently checked value.
        /// </summary>
        /// <param name="value">The currently checked value.</param>
        internal void UpdateStatus(int value)
        {
            if(StatusEvent!=null)
                StatusEvent(value);
        }

        /// <summary>
        /// Returns the number of variables.
        /// </summary>
        /// <returns>The number of variables.</returns>
        public int VariableCount()
        {
            return cp.Variables.Count;
        }

        /// <summary>
        /// Method which return the maximal number of calls to the 
        /// status event for a search, depending on which modus 
        /// is chosen.
        /// Can be used to set the max value of a progress bar.
        /// </summary>
        /// <returns>Number of status messages.</returns>
        public int StatusUpdateCount()
        {
            return statusUpdateCount;
        }

        /// <summary>
        /// Sets the status update count, which is
        /// the maximum number of status updates for
        /// a specific search. Can be used to set
        /// the maximum value of a progress bar.
        /// </summary>
        /// <param name="suc">The suc.</param>
        internal void SetStatusUpdateCount(int suc)
        {
            this.statusUpdateCount = suc;
        }

        /// <summary>
        /// Gets the unsatisfiable rule, if BDD modus is chosen.
        /// This information is not possible to retrive in CSP modus.
        /// </summary>
        /// <returns></returns>
        public String GetUnsatisfiableRule()
        {
            if (modus == 0)
            {
                return clabBDD.UnsatisfiableRule;
            }
            else return "";
        }

        /// <summary>
        /// Gets or sets the initial number of bdd nodes.
        /// </summary>
        /// <value>The initbddnodes.</value>
        public int Initbddnodes
        {
            get { return initbddnodes; }
            set { initbddnodes = value; }
        }

        /// <summary>
        /// Gets or sets the initial size of db cache.
        /// </summary>
        /// <value>The initdbcache.</value>
        public int Initdbcache
        {
            get { return initdbcache; }
            set { initdbcache = value; }
        }

        /// <summary>
        /// Gets or sets the BDD max increase number.
        /// </summary>
        /// <value>The maxincrease.</value>
        public int Maxincrease
        {
            get { return maxincrease; }
            set { maxincrease = value; }
        }
    }
}