/*========================================================================
        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 CLab.Data;
using CLab.Exceptions;

using Casper.Data;

using Iesi.Collections;

namespace CLab.CSP
{
    /// <summary>
    /// Class representing and making the layout of the CSP problem. 
    /// The class has mapping from the CLab <see cref="T:CLab.Data.CP"></see> representation to the CSP
    /// representation and vice versa.
    /// </summary>
    public class CSPLayout
    {
        private StringComparer stringComparer;
        private List<String> varIDToCPVar;
        private Hashtable cpVarToVarID;
        private List<String> varIDToTypeName;
        private Hashtable typeNameToIndex;
        private List<int> varIDToCasperVarDomIndex;
        private CP cp;
        private List<CSPType> types;
        private List<CasperVarDom> casperVarDoms;

        /// <summary>
        /// Initializes a new instance of the <see cref="T:CSPLayout"/> class.
        /// </summary>
        /// <param name="cp">The <see cref="T:CLab.Data.CP"></see> instance of the problem.</param>
        public CSPLayout(CP cp)
        {
            this.cp = cp;
            stringComparer = StringComparer.Create(System.Globalization.CultureInfo.CurrentCulture, true);
            varIDToCPVar = new List<String>();
            cpVarToVarID = new Hashtable(stringComparer);
            varIDToTypeName = new List<String>();
            typeNameToIndex = new Hashtable(stringComparer);
            varIDToCasperVarDomIndex = new List<int>();
            types = new List<CSPType>();
            casperVarDoms = new List<CasperVarDom>();
        }

        /// <summary>
        /// Makes the type mapping, from <see cref="T:CLab.Data.Type"></see>, to
        /// <see cref="T:CLab.CSP.CSPType"></see>. This method is for internal use of this class.
        /// </summary>
        private void MakeTypeMapping()
        {

            List<CLab.Data.Type> cpTypes = cp.Types;
            for (int i = 0; i < cpTypes.Count; i++)
            {
                typeNameToIndex[cpTypes[i].TypeName] = i;
                if (cpTypes[i].GetType() == typeof(TypeEnum))
                {
                    TypeEnum te = (TypeEnum)cpTypes[i];
                    CSPTypeEnum cspEnum = new CSPTypeEnum(te.TypeName);
                    for (int j = 0; j < te.EnumeratorsList.Count; j++)
                    {
                        cspEnum.AddConstant(te.EnumeratorsList[j]);
                    }
                    this.types.Add(cspEnum);
                }
                else //TypeRange
                {
                    TypeRange tr = (TypeRange)cpTypes[i];
                    CSPTypeRange cspRange = new CSPTypeRange(tr.TypeName, tr.StartOfRange, tr.EndOfRange);
                    this.types.Add(cspRange);
                }
            }
            this.types.Add(new CSPTypeBool("bool"));
            typeNameToIndex["bool"] = this.types.Count - 1;
        }

        /// <summary>
        /// Makes the casper variables with domain values, <see cref="T:Casper.Data.CasperVarDom"></see>,
        /// and the mapping from <see cref="T:CLab.Data.CP"></see> representation, to this representation.
        /// The method is for internal use of this class.
        /// </summary>
        /// <returns>List of casper variable and domain representation.</returns>
        public List<CasperVarDom> MakeCasperVarDoms()
        {
            MakeTypeMapping();

            List<CLab.Data.Variable> variables = cp.Variables;
 
            for (int i = 0; i < variables.Count; i++)
            {
                varIDToCPVar.Add(variables[i].VariableName);
                cpVarToVarID[variables[i].VariableName] = i;
                varIDToTypeName.Add(variables[i].TypeName);
                CSPType type = types[(int) typeNameToIndex[variables[i].TypeName]];
                
                List<int> casperDomVals = new List<int>();

                if (type.GetType() == typeof(CLab.CSP.CSPTypeRange))
                {
                    CSPTypeRange tr = (CSPTypeRange)type;
                    int j;
                    int end;
                
                    if (tr.Start < tr.End)
                    {
                        j = tr.Start;
                        end = tr.End;
                    }
                    else
                    {
                        j = tr.End;
                        end = tr.Start;
                    }
                    for (; j <= end; j++)
                    {
                        casperDomVals.Add(j);
                    }
                }
                else
                {
                    //enum and bool 
                    for (int j = 0; j <= type.End; j++)
                    {
                        casperDomVals.Add(j);
                    }
                }
                CasperVarDom var = new CasperVarDom(i, casperDomVals);
                casperVarDoms.Add(var);
                varIDToCasperVarDomIndex.Add(casperVarDoms.Count - 1);
            }
            return casperVarDoms;
        }

        /// <summary>
        /// Gets the <see cref="P:Casper.Data.CasperVarDom.VarID"></see> property 
        /// to the <see cref="P:CLab.Data.Variable.VariableName"></see> property mapping.
        /// </summary>
        public List<String> VarIDToCPVar
        {
            get { return varIDToCPVar; }
        }

        /// <summary>
        /// Gets the <see cref="P:CLab.Data.Variable.VariableName"></see> property
        /// to the <see cref="P:Casper.Data.CasperVarDom.VarID"></see> property mapping.
        /// </summary>
        public Hashtable CpVarToVarID
        {
            get { return cpVarToVarID; }
        }

        /// <summary>
        /// Gets the <see cref="P:Casper.Data.CasperVarDom.VarID"></see> property 
        /// to the <see cref="P:CLab.Data.Variable.TypeName"></see> property mapping.
        /// </summary>
        public List<String> VarIDToTypeName
        {
            get { return varIDToTypeName; }
        }

        /// <summary>
        /// Gets the <see cref="P:CLab.Data.Variable.TypeName"></see> property to the
        /// index of this type mapping.
        /// </summary>
        /// <value>The index of the type name to.</value>
        public Hashtable TypeNameToIndex
        {
            get { return typeNameToIndex; }
        }

        /// <summary>
        /// Gets the list of CSP types.
        /// </summary>
        /// <value>The types.</value>
        public List<CSPType> Types
        {
            get { return types; }
        }

        /// <summary>
        /// Gets the variable name, (<see cref="P:CLab.Data.Variable.VariableName"></see>),
        /// from the passed inn variable ID, (<see cref="P:Casper.Data.CasperVarDom.VarID"></see>).
        /// </summary>
        /// <param name="varID">The var ID.</param>
        /// <returns></returns>
        public String GetCPVarFromVarID(int varID)
        {
            return varIDToCPVar[varID];
        }


        /// <summary>
        /// Gets the variable ID, (<see cref="P:Casper.Data.CasperVarDom.VarID"></see>), 
        /// from the passed in variable name, (<see cref="P:CLab.Data.Variable.VariableName"></see>).
        /// </summary>
        /// <param name="cpVarName">Name of the cp var.</param>
        /// <returns></returns>
        public int GetVarIDFromCPVar(String cpVarName)
        {
            return (int) cpVarToVarID[cpVarName];
        }

        /// <summary>
        /// Gets the domain value's string representation.
        /// </summary>
        /// <param name="cpVarName">Name of the CLab variable.</param>
        /// <param name="domainInt">The domain int value.</param>
        /// <returns>The domain value's string representation.</returns>
        public String GetDomainStringFromDomainInt(String cpVarName, int domainInt)
        {
            String tName = GetTypeName(cpVarName);
            int typeIndex = (int) typeNameToIndex[tName];
            CSPType type = types[typeIndex];
            try
            {
                return type.GetStringRepOfDomainInt(domainInt);
            }
            catch (ClabException) { throw; }
        }

        /// <summary>
        /// Gets the domain value's int representation.
        /// </summary>
        /// <param name="cpVarName">Name of the CLab variable.</param>
        /// <param name="domainString">The domain string value.</param>
        /// <returns>The domain value's int representation.</returns>
        public int GetDomainIntFromDomainString(String cpVarName, String domainString)
        {
            String tName = GetTypeName(cpVarName);
            int typeIndex = (int)typeNameToIndex[tName];
            CSPType type = types[typeIndex];
            try
            {
                return type.GetIntRepOfDomainString(domainString);
            }
            catch (ClabException) { throw; }
        }

        /// <summary>
        /// Gets the name of the variable's type.
        /// </summary>
        /// <param name="varName">The CLab variable name.</param>
        /// <returns>The type name.</returns>
        public String GetTypeName(String varName) 
        {
            int varID = (int) cpVarToVarID[varName];
            return varIDToTypeName[varID];
        }
        
        /// <summary>
        /// Gets the type format. <see cref="F:CPTypes"></see>.
        /// </summary>
        /// <param name="typeName">Name of the type.</param>
        /// <returns>A constant representing the type format.</returns>
        public CPTypes GetTypeFormat(String typeName)
        {
            int index = (int) typeNameToIndex[typeName];
            CSPType cspT = types[index];
            return cspT.TypeFormat();
        }

        /// <summary>
        /// Gets the index of the <see cref="T:Casper.Data.CasperVarDom"></see> object with 
        /// the name "cpVarName".
        /// </summary>
        /// <param name="cpVarName">Name of the Clab variable.</param>
        /// <returns>The index.</returns>
        public int GetCasperVarDomIndex(String cpVarName)
        {
            return varIDToCasperVarDomIndex[GetVarIDFromCPVar(cpVarName)];
        }

        /// <summary>
        /// Returns a <see cref="T:System.String"></see> that represents the current <see cref="T:CLab.CSP.CSPLayout"></see>.
        /// </summary>
        /// <returns>
        /// A <see cref="T:System.String"></see> that represents the current <see cref="T:CLab.CSP.CSPLayout"></see>.
        /// </returns>
        public override string ToString()
        {
            String retur = "Type mapping: \n";
            IDictionaryEnumerator en = typeNameToIndex.GetEnumerator();
            retur += "typeNameToIndex: ";
            
            while (en.MoveNext())
            {
                retur += en.Key + " - " + en.Value + ", ";
            }
            retur += "\nTypes: ";

            for (int i = 0; i < types.Count; i++)
            {
                retur += i + " - " + types[i].TypeName + ", ";
            }
           
            retur += "\n\nVariable mapping: \n";
            retur += "VarIDToCPVar: ";
           
            for (int i = 0; i < varIDToCPVar.Count; i++)
            {
                retur += i + " - " + varIDToCPVar[i] + ", ";
            }
            retur += "\nvarIDToTypeName: ";
            
            for (int i = 0; i < varIDToTypeName.Count; i++)
            {
                retur += i + " - " + varIDToTypeName[i] + ", ";
            }
            return retur;
        }
    }
}