/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt VS Tools.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;

namespace QtVsTools.SyntaxAnalysis
{
    public abstract partial class RegExpr
    {
        [Flags]
        public enum Delimiter { None, Left, Right }

        [Flags]
        public enum Operand { None, Left, Right }

        public interface IProductionRule
        {
            int Priority { get; }
            RuleCallback.Selector Selector { get; }
            RuleCallback.PreCondition PreCondition { get; }
            Token Token { get; set; }
            Delimiter Delimiters { get; }
            Operand Operands { get; }
            object Execute(ParseTree.Node node);
        }

        public abstract class ProductionRule<T> : IProductionRule, IEnumerable
        {
            public int Priority { get; protected set; }
            public RuleCallback.Selector Selector { get; set; }
            public RuleCallback.PreCondition PreCondition { get; set; }

            public Token Token { get; set; }
            public virtual Delimiter Delimiters { get { return Delimiter.None; } }
            public virtual Operand Operands { get { return Operand.None; } }

            protected List<IRuleAction<T>> Actions = new List<IRuleAction<T>>();

            protected void Init(
                int priority, RuleCallback.Selector select, RuleCallback.PreCondition pre)
            {
                Priority = priority;
                Selector = select;
                PreCondition = pre;
            }

            public void Add(IRuleAction<T> action)
            {
                Actions.Add(action);
            }

            protected abstract object[] FetchOperands(Stack<ParseTree.Node> operandStack);

            protected virtual T DefaultProduction(
                string capturedValue,
                Stack<ParseTree.Node> operandStack,
                ProductionObjects productions)
            {
                return CreateInstance();
            }

            protected virtual bool TestPreCondition(
                ParseTree.Node node,
                string capturedValue,
                Stack<ParseTree.Node> operandStack,
                ProductionObjects productions)
            {
                if (PreCondition == null)
                    return true;
                return PreCondition(node);
            }

            public object Execute(ParseTree.Node node)
            {
                if (PreCondition != null && !PreCondition(node))
                    throw new ParseErrorException();

                if (node.Parent == null)
                    return null;

                var operandStack = node.Parent.OperandStack;
                var capturedValue = node.Value;
                var productions = node.ChildProductions;

                // pop-out rule operands from operand stack
                object[] ruleOperands = FetchOperands(operandStack);

                // calculate order of actions taking child productions into account
                var actionScheduling = ScheduleActions(productions);

                // run actions in the calculated order
                T production = default(T);
                foreach (var actionSchedule in actionScheduling) {
                    var a = actionSchedule.Action;
                    var childProduction = actionSchedule.Production;

                    // if production is null and action is update, init with default production
                    if (production == null && a.ActionInfo.ReturnType == typeof(void))
                        production = DefaultProduction(capturedValue, operandStack, productions);

                    // if action uses child production, use it as input instead of the rule operands
                    if (childProduction != null)
                        a.Execute(ref production, capturedValue, childProduction);
                    else
                        a.Execute(ref production, capturedValue, ruleOperands);
                }

                // if no production was created by rule actions, create default production
                if (production == null)
                    production = DefaultProduction(capturedValue, operandStack, productions);

                return production;
            }

            class ActionSchedule
            {
                public IRuleAction<T> Action { get; set; }
                public int ActionIndex { get; set; }
                public object Production { get; set; }
                public int ProductionIndex { get; set; }
            }

            IEnumerable<ActionSchedule> ScheduleActions(ProductionObjects childProductions)
            {
                // actions with order of definition
                var actionsOrder = Actions
                    .Select((a, aIdx) => new
                    {
                        Self = a,
                        Index = aIdx,
                        a.SourceTokenId
                    });
                var dependentActions = actionsOrder
                    .Where(a => !string.IsNullOrEmpty(a.SourceTokenId));
                var independentActions = actionsOrder
                    .Where(a => string.IsNullOrEmpty(a.SourceTokenId));

                // child productions with order of creation
                var productionsOrder = childProductions
                    .Select((p, pIdx) => new
                    {
                        Self = p.Value,
                        Index = pIdx,
                        TokenId = p.Key
                    });

                // schedule actions that depend on child production:
                //  * actions x productions
                //  * sorted by production creation order (inverted)
                //  * and then by action definition order (inverted)
                var dependentActionSchedules = dependentActions
                    .Join(productionsOrder,
                    a => a.SourceTokenId, p => p.TokenId,
                    (a, p) => new ActionSchedule
                    {
                        Action = a.Self,
                        ActionIndex = a.Index,
                        Production = p.Self,
                        ProductionIndex = p.Index,
                    })
                    .OrderByDescending(ap => ap.ProductionIndex)
                    .ThenByDescending(ap => ap.ActionIndex);

                // insert independent actions in the right order
                var scheduled = new Stack<ActionSchedule>();
                IEnumerable<ActionSchedule> toSchedule = dependentActionSchedules;
                foreach (var a in independentActions.OrderByDescending(a => a.Index)) {
                    var scheduleAfter = toSchedule
                        .TakeWhile(ap => ap.ActionIndex > a.Index);
                    foreach (var ap in scheduleAfter)
                        scheduled.Push(ap);
                    scheduled.Push(new ActionSchedule { Action = a.Self });

                    toSchedule = toSchedule.Skip(scheduleAfter.Count());
                }
                if (toSchedule.Any()) {
                    foreach (var ap in toSchedule)
                        scheduled.Push(ap);
                }

                return scheduled;
            }

            public IEnumerator GetEnumerator()
            {
                return Actions.GetEnumerator();
            }

            protected T CreateInstance()
            {
                var type = typeof(T);

                if (type.IsValueType)
                    return default(T);

                if (type == typeof(string))
                    return (T)(object)string.Empty;

                if (!type.IsClass)
                    throw new InvalidOperationException("Not a class: " + type.Name);

                if (type.IsAbstract)
                    throw new InvalidOperationException("Abstract class: " + type.Name);

                if (type.ContainsGenericParameters)
                    throw new InvalidOperationException("Generic class: " + type.Name);

                var ctorInfo = ((TypeInfo)type).DeclaredConstructors
                    .Where(x => x.GetParameters().Length == 0)
                    .FirstOrDefault();

                if (ctorInfo == null)
                    throw new InvalidOperationException("No default constructor: " + type.Name);

                return (T)ctorInfo.Invoke(new object[0]);
            }
        }

        public class Rule<T> : ProductionRule<T>
        {
            public Rule(
                int priority = int.MaxValue,
                RuleCallback.Selector select = null,
                RuleCallback.PreCondition pre = null)
            {
                Init(priority, select, pre);
            }

            protected override object[] FetchOperands(Stack<ParseTree.Node> operandStack)
            {
                return new object[] { };
            }
        }

        public class PrefixRule<TOperand, T> : ProductionRule<T>
        {
            public override Operand Operands { get { return Operand.Right; } }

            public PrefixRule(
                int priority = 0,
                RuleCallback.Selector select = null,
                RuleCallback.PreCondition pre = null)
            {
                Init(priority, select, pre);
            }

            protected override object[] FetchOperands(Stack<ParseTree.Node> operandStack)
            {
                if (operandStack.Count < 1)
                    throw new ParseErrorException();

                var operand = operandStack.Pop();
                if (!(operand.Production is TOperand))
                    throw new ParseErrorException();

                return new object[] { operand.Production };
            }
        }

        public class PostfixRule<TOperand, T> : ProductionRule<T>
        {
            public override Operand Operands { get { return Operand.Left; } }

            public PostfixRule(
                int priority = 0,
                RuleCallback.Selector select = null,
                RuleCallback.PreCondition pre = null)
            {
                Init(priority, select, pre);
            }

            protected override object[] FetchOperands(Stack<ParseTree.Node> operandStack)
            {
                if (operandStack.Count < 1)
                    throw new ParseErrorException();

                var operand = operandStack.Pop();
                if (!(operand.Production is TOperand))
                    throw new ParseErrorException();

                return new object[] { operand.Production };
            }
        }

        public class InfixRule<TLeftOperand, TRightOperand, T> : ProductionRule<T>
        {
            public override Operand Operands { get { return Operand.Left | Operand.Right; } }

            public InfixRule(
                int priority = 0,
                RuleCallback.Selector select = null,
                RuleCallback.PreCondition pre = null)
            {
                Init(priority, select, pre);
            }

            protected override object[] FetchOperands(Stack<ParseTree.Node> operandStack)
            {
                if (operandStack.Count < 2)
                    throw new ParseErrorException();

                var rightOperand = operandStack.Pop();
                if (!(rightOperand.Production is TRightOperand))
                    throw new ParseErrorException();

                var leftOperand = operandStack.Pop();
                if (!(leftOperand.Production is TLeftOperand))
                    throw new ParseErrorException();

                return new object[] { leftOperand.Production, rightOperand.Production };
            }
        }

        public class LeftDelimiterRule<T> : ProductionRule<T>
        {
            public override Delimiter Delimiters { get { return Delimiter.Left; } }

            public LeftDelimiterRule(
                int priority = int.MinValue,
                RuleCallback.Selector select = null,
                RuleCallback.PreCondition pre = null)
            {
                Init(priority, select, pre);
            }

            protected override object[] FetchOperands(Stack<ParseTree.Node> operandStack)
            {
                return new object[] { };
            }
        }

        public class RightDelimiterRule<TLeftDelim, TExpr, T> : ProductionRule<T>
        {
            public override Delimiter Delimiters { get { return Delimiter.Right; } }

            public RightDelimiterRule(
                int priority = int.MaxValue,
                RuleCallback.Selector select = null,
                RuleCallback.PreCondition pre = null)
            {
                Init(priority, select, pre);
            }

            protected override T DefaultProduction(
                string capturedValue,
                Stack<ParseTree.Node> operandStack,
                ProductionObjects productions)
            {
                throw new ParseErrorException();
            }

            protected override object[] FetchOperands(Stack<ParseTree.Node> operandStack)
            {
                if (operandStack.Count < 2)
                    throw new ParseErrorException();

                var delimitedExpr = operandStack.Pop();
                if (!(delimitedExpr.Production is TExpr))
                    throw new ParseErrorException();

                var leftDelimiter = operandStack.Pop();
                if (!(leftDelimiter.Production is TLeftDelim))
                    throw new ParseErrorException();

                return new object[] { leftDelimiter.Production, delimitedExpr.Production };
            }
        }

        public static class RuleCallback
        {
            public delegate bool Selector(ITokenCapture token);
            public delegate bool PreCondition(IOperatorCapture capture);
        }

        public const RuleCallback.Selector Default = null;
    }
}