//******************************************************************************************************
//  BooleanExpression.cs - Gbtc
//
//  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  02/12/2016 - Stephen C. Wills
//       Generated original version of source code.
//
//******************************************************************************************************

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using GSF.Collections;

namespace GSF.Parsing
{
    /// <summary>
    /// Represents a boolean expression that can be parsed and executed at runtime.
    /// </summary>
    /// <remarks>
    /// Binary operators have the same level of precedence and are evaluated from right to left.
    /// </remarks>
    public class BooleanExpression
    {
        #region [ Members ]

        // Nested Types

        /// <summary>
        /// Represents a variable that can be tweaked at runtime.
        /// </summary>
        public class Variable
        {
            /// <summary>
            /// The identifier used to refer to the variable.
            /// </summary>
            public readonly string Identifier;

            /// <summary>
            /// The value of the variable.
            /// </summary>
            public bool Value;

            /// <summary>
            /// Creates a new instance of the <see cref="Variable"/> class.
            /// </summary>
            /// <param name="identifier">The identifier used to refer to the variable.</param>
            public Variable(string identifier)
            {
                Identifier = identifier;
            }
        }

        // Fields
        private Dictionary<string, Variable> m_variables;
        private Func<bool> m_evaluate;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new instance of the <see cref="BooleanExpression"/> class.
        /// </summary>
        /// <param name="expressionText">The expression text to be parsed as a boolean expression.</param>
        /// <remarks>
        /// The default comparer for identifiers is <see cref="StringComparer.OrdinalIgnoreCase"/>.
        /// </remarks>
        public BooleanExpression(string expressionText)
            : this(expressionText, StringComparer.OrdinalIgnoreCase)
        {
        }

        /// <summary>
        /// Creates a new instance of the <see cref="BooleanExpression"/> class.
        /// </summary>
        /// <param name="expressionText">The expression text to be parsed as a boolean expression.</param>
        /// <param name="identifierComparer">Comparer used to compare identifiers.</param>
        public BooleanExpression(string expressionText, IEqualityComparer<string> identifierComparer)
        {
            StringBuilder builder;
            Expression expression;

            m_variables = new Dictionary<string, Variable>(StringComparer.OrdinalIgnoreCase);
            builder = new StringBuilder(expressionText);
            expression = ParseExpression(builder);

            if (builder.Length > 0)
                throw new FormatException($"Unexpected character '{builder[0]}' in expression. Expected end of expression.");

            m_evaluate = Expression.Lambda<Func<bool>>(expression).Compile();
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets the list of variables found while parsing the boolean expression.
        /// </summary>
        public List<Variable> Variables
        {
            get
            {
                return m_variables.Values.ToList();
            }
        }

        /// <summary>
        /// Gets the variable identified by the given identifier.
        /// </summary>
        /// <param name="identifier">The identifier used to refer to the variable.</param>
        /// <returns>The variable identified by the given identifier.</returns>
        public Variable this[string identifier]
        {
            get
            {
                return m_variables[identifier];
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Evaluates the expression using the
        /// current values of the variables.
        /// </summary>
        /// <returns>The result of the evalulation.</returns>
        public bool Evaluate()
        {
            return m_evaluate();
        }
        
        /// <summary>
        /// Attempts to get the variable identified by the given identifier.
        /// </summary>
        /// <param name="identifier">The identifier used to refer to the variable.</param>
        /// <param name="variable">The variable identified by the given identifier.</param>
        /// <returns>True if the variable is present in the expression; false otherwise.</returns>
        public bool TryGetVariable(string identifier, out Variable variable)
        {
            return m_variables.TryGetValue(identifier, out variable);
        }

        private Expression ParseExpression(StringBuilder builder)
        {
            Expression subexpression;
            char binaryOp;

            subexpression = ParseSubexpression(builder);
            ShedWhitespace(builder);

            if (builder.Length > 0)
            {
                binaryOp = builder[0];

                if (binaryOp == ')')
                    return subexpression;

                builder.Remove(0, 1);
                ShedWhitespace(builder);

                switch (binaryOp)
                {
                    case '&':
                        return Expression.And(subexpression, ParseExpression(builder));

                    case '|':
                        return Expression.Or(subexpression, ParseExpression(builder));

                    case '^':
                        return Expression.ExclusiveOr(subexpression, ParseExpression(builder));

                    default:
                        throw new FormatException($"Unexpected character '{binaryOp}' in expression. Expected: '&', '|', or '^'.");
                }
            }

            return subexpression;
        }

        private Expression ParseSubexpression(StringBuilder builder)
        {
            Expression expression;

            ShedWhitespace(builder);

            if (builder.Length == 0)
                throw new FormatException($"Unexpected end of expression. Expected: '(', '!', '~', or identifier.");

            switch (builder[0])
            {
                case '(':
                    builder.Remove(0, 1);
                    expression = ParseExpression(builder);

                    if (builder.Length == 0)
                        throw new FormatException($"Unexpected end of expression. Expected: ')'.");

                    if (builder[0] != ')')
                        throw new FormatException($"Unexpected character '{builder[0]}' in expression. Expected: ')'.");

                    builder.Remove(0, 1);

                    return expression;

                case '!':
                case '~':
                    builder.Remove(0, 1);
                    return Expression.Not(ParseSubexpression(builder));
            }

            return ParseIdentifier(builder);
        }

        private Expression ParseIdentifier(StringBuilder builder)
        {
            Variable identifier;
            StringBuilder nameBuilder = new StringBuilder();
            string name;

            while (builder.Length > 0 && char.IsLetterOrDigit(builder[0]))
            {
                nameBuilder.Append(builder[0]);
                builder.Remove(0, 1);
            }

            if (nameBuilder.Length == 0)
                throw new FormatException($"Unexpected character '{builder[0]}' in expression. Expected identifier.");

            name = nameBuilder.ToString();
            identifier = m_variables.GetOrAdd(name, key => new Variable(key));

            return ((Expression<Func<bool>>)(() => identifier.Value)).Body;
        }

        private void ShedWhitespace(StringBuilder builder)
        {
            while (builder.Length > 0 && char.IsWhiteSpace(builder[0]))
                builder.Remove(0, 1);
        }

        #endregion
    }
}