using System;
using System.Collections;
using System.Configuration;
using Abp.Dependency;
using Abp.Runtime.Caching;
using Abp.UI;
using IwbZero.Expr;
using IwbZero.IwbBase;
using IwbZero.IwbDataQuery;
using IwbZero.ToolCommon;
using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;
using WeEngine.ComponentInfo;
using WeEngine.Components.InterfaceFactory;
using WeEngine.Packages;

namespace WeEngine.Components
{

    /// <summary>
    /// 事务运行器
    /// </summary>
    public class ComponentRunner : ISingletonDependency
    {
        #region 属性
        /// <summary>
        /// 当前运行节点
        /// </summary>
        public NodeBase CurrentNode { get; set; }

        public ICacheManager CacheManager { get; }
        public IIocManager IocManager { get; }
        private int Depth { get; set; }
        public EngineComponent Component { get; set; }
        public string ParameterMapping { get; set; }
        public Hashtable Variables { get; set; }
        public Hashtable DataSources { get; }
        public Hashtable FilterFields { get; }
        public string ProcessInstanceId => GetValue(CompStmtType.CompInstanceId.VariableName);

        public string ProcessMessage
        {
            get => GetValue(CompStmtType.CompMessage.VariableName);
            set => SetValue(CompStmtType.CompMessage.VariableName, value);
        }

        public bool ProcessResult => (GetValue(CompStmtType.CompResult.VariableName).ValI() != 0); 
        #endregion
        public ComponentRunner(ICacheManager cacheManager, IIocManager iocManager)
        {
            CacheManager = cacheManager;
            IocManager = iocManager;
            Variables = new Hashtable();
            DataSources = new Hashtable();
            FilterFields = new Hashtable();
        }
        
        /// <summary>
        /// 运行事务组件
        /// </summary>
        /// <param name="cId"></param>
        /// <param name="mapping"></param>
        /// <returns></returns>
        public bool Run(string cId, string mapping="")
        {
            var flag = false;
            var component = LoadComponentById(cId);
            if (component != null)
            {
                flag =  Run(component, mapping);
            }
            return flag;
        }

        /// <summary>
        /// 运行事务组件
        /// </summary>
        /// <param name="component"></param>
        /// <param name="mapping"></param>
        /// <returns></returns>
        public bool Run(EngineComponent component,string mapping="")
        {
            DataSources.Clear();
            FilterFields.Clear();
            //Variables.Clear();
            Component = component;
            ParameterMapping = mapping;
            InitializeVariables();
            if (Component.ComponentScript != "")
            {
                var xml = component.ComponentScript;
                IwbXmlNode node = IwbXmlNode.ParseGenericXml(xml);
                if (node != null)
                {
                    foreach (ComponentParameter parameter in ParseComponentParameter(component.Parameters))
                    {
                        FilterFields.Add(IwbVariableType.Global + parameter.Id.UAndT(), "");
                    }
                    if (mapping != "")
                    {
                        ArrayList list2 = mapping.MappingToArrayList();
                        if (list2 != null)
                        {
                            foreach (IwbIdName name in list2)
                            {
                                SetValue(IwbVariableType.Global + name.Id, name.Name);
                            }
                        }
                    }

                    RunStatements(node.Nodes);
                }
            }
            else
            {
                IComponentRunner runner = IocManager.Resolve<IComponentRunner>(Component.RegisterKey);
                if (!runner.Run(Component, mapping))
                {
                    typeof(ComponentRunner).LogError(runner.ErrorMessage);
                }
                //object obj2 = AssemblyHelper.CreateInstance(Component.ProcessClass, Component.ProcessLib);

                //if (obj2 == null)
                //{
                //    typeof(ComponentRunner).LogError(
                //        $"Unable to create static process runner at {Component.ProcessClass}.");
                //    //AbortProcessWithMessage(string.Format("Unable to create static process runner at {0}.", _Process.ProcessClass));
                //}
                //else if (!(obj2 is IComponentRunner))
                //{
                //    typeof(ComponentRunner).LogError($"The process runner, {Component.ProcessClass}, is invalid.");
                //    //AbortProcessWithMessage(string.Format("The process runner, {0}, is invalid.", _Process.ProcessClass));
                //}
                //else
                //{
                //    IComponentRunner runner = (IComponentRunner)obj2;
                //    if (!runner.Run(Component, pcParameterMappings))
                //    {
                //        typeof(ComponentRunner).LogError(runner.ErrorMessage);
                //        //AbortProcessWithMessage(runner.ErrorMessage);
                //    }
                //}
            }

            return true;
        }

        #region 私有方法

        /// <summary>
        /// 解析参数
        /// </summary>
        /// <param name="pcParameter"></param>
        /// <returns></returns>
        private ArrayList ParseComponentParameter(string pcParameter)
        {
            ArrayList list = new ArrayList();
            foreach (string str in pcParameter.StrToArray())
            {
                if (str.IndexOf(":", StringComparison.Ordinal) != -1)
                {
                    string pcStr = str.Substring(0, str.IndexOf(":", StringComparison.Ordinal));
                    ComponentParameter parameter = new ComponentParameter(str.Substring(str.IndexOf(":", StringComparison.Ordinal) + 1, (str.Length - str.IndexOf(":", StringComparison.Ordinal)) - 1), ParameterTypeFromStr(pcStr));
                    list.Add(parameter);
                }
            }
            return list;
        }
        /// <summary>
        /// 转换参数类型
        /// </summary>
        /// <param name="pcStr"></param>
        /// <returns></returns>
        private ComponentParameterType ParameterTypeFromStr(string pcStr)
        {
            ComponentParameterType filterField = ComponentParameterType.Variable;
            string str = pcStr;
            if (str.IsEmpty())
            {
                return filterField;
            }
            str = string.IsInterned(str);
            if (str == "FilterField")
            {
                return ComponentParameterType.FilterField;
            }
            if (str == "File")
            {
                return ComponentParameterType.File;
            }
            if (str == "Folder")
            {
                return ComponentParameterType.Folder;
            }
            if (str != "PrinterSetting")
            {
                return filterField;
            }
            return ComponentParameterType.PrinterSetting;
        }
        /// <summary>
        /// 变量初始化
        /// </summary>
        private void InitializeVariables()
        {
            CreateVariable(CompStmtType.CompMessage.VariableName, CompStmtType.CompMessage.VariableType,false);
            CreateVariable(CompStmtType.CompInstanceId.VariableName, CompStmtType.CompInstanceId.VariableType, false);
            CreateVariable(CompStmtType.CompResult.VariableName, CompStmtType.CompResult.VariableType, false);
            SetValue(CompStmtType.CompMessage.VariableName, "");
            SetValue(CompStmtType.CompInstanceId.VariableName, "0");
            SetValue(CompStmtType.CompResult.VariableName, "1");
        }
     
        /// <summary>
        /// 转换表达式变量
        /// </summary>
        /// <param name="poRoot"></param>
        private void TransComponentVariables(ExprObject poRoot)
        {
            foreach (ExprObject expr in poRoot.ChildNodes)
            {
                if (expr.ElementType == ExprElements.Variable)
                {
                    if (expr.Expr.Trim() != "")
                    {
                        expr.Expr = GetValue(expr.Expr);
                        expr.ElementType = ExprElements.Value;
                    }
                }
                else if ((expr.ElementType == ExprElements.Expression) || (expr.ElementType == ExprElements.Function))
                {
                    TransComponentVariables(expr);
                }
            }
        }
     
        /// <summary>
        /// 加载组件
        /// </summary>
        /// <param name="cId"></param>
        /// <returns></returns>
        private EngineComponent LoadComponentById(string cId)
        {
            var packageId = CurrentNode?.CurPackageInfo?.Id ?? "";
            EngineComponent component = null;
            if (packageId.IsNotEmpty()) component = CacheManager.GetEngineComponent(packageId, cId);
            
            if (component == null)
            {
                try
                {
                    string url = $"{ConfigurationManager.AppSettings["DataCenter.Engine.Component"]}";
                    string authKey = ConfigurationManager.AppSettings["DataCenter.Engine.AuthKey"];
                    var result = url.RequestPost(new { Id = cId }.Obj2String(),authKey);
                    var obj = result.Str2Obj<EngineComponent>();
                    return obj;
                }
                catch (Exception e)
                {
                    throw new UserFriendlyException($"没有找到Id为{cId}的引擎组件！{e.Message}");
                }
            }
            
            return component;
        }
        public  string TransMappingWithRunner( string pcMapping)
        {
            string pcSource = "";
            foreach (IwbIdName name in pcMapping.MappingToArrayList())
            {
                string str2 = Evaluate(name.Name);
                if (str2 != "")
                {
                    pcSource = pcSource.AddStr($"{name.Id}={str2}");
                }
            }
            return pcSource;
        }

        #endregion

        #region 事务

        /// <summary>
        /// 运行事务
        /// </summary>
        /// <param name="poStatement"></param>
        /// <returns></returns>
        public bool RunOneStatement(IwbXmlNode poStatement)
        {
            IStatementRunner StatementRunner = null;
            try
            {
                StatementRunner = IocManager.Resolve<IStatementRunnerFactory>().Create(poStatement.Name);
            }
            catch (Exception e)
            {
                this.LogError(e);
            }
            return StatementRunner?.Run(this, poStatement) ?? false;
        }

        /// <summary>
        /// 运行事务
        /// </summary>
        /// <param name="poStatements"></param>
        /// <returns></returns>
        public bool RunStatements(ArrayList poStatements)
        {
            bool flag = true;
            Depth++;
            int count = poStatements.Count;
            for (int i = 0; i < count; i++)
            {
                var poStatement = (IwbXmlNode)poStatements[i];
                string childValue = poStatement.GetChildValue("Comment");
                //ShowStepInfo(count, i + 1, childValue);
                string processMessage = ProcessMessage;
                try
                {
                    bool flag2 = poStatement.GetChildValue("RunWhenFail").StrToBool();
                    bool processResult = ProcessResult;
                    if (childValue != "")
                    {
                        typeof(ComponentRunner).LogInfo("\r\n\r\n");
                        typeof(ComponentRunner).LogInfo(childValue);
                        typeof(ComponentRunner).LogInfo($"Process Result: {processResult}");
                        typeof(ComponentRunner).LogInfo($"RunWhenFail option: {(flag2 ? "On" : "Off")}");
                    }
                    if (processResult || flag2)
                    {
                        flag = RunOneStatement(poStatement);
                    }
                }
                catch (Exception e)
                {
                    typeof(ComponentRunner).LogError(e);
                    // AbortProcessWithMessage(exception.Message);
                }
                if (!ProcessResult)
                {
                    flag = false;
                }
                if (ProcessMessage != processMessage)
                {
                    typeof(ComponentRunner).LogInfo(processMessage);

                }
            }
            Depth--;
            return flag;
        }

        /// <summary>
        /// 创建变量
        /// </summary>
        /// <param name="pcVariableId"></param>
        /// <param name="pcVariableType"></param>
        /// <param name="save2node"></param>
        public void CreateVariable(string pcVariableId, string pcVariableType,bool save2node=true)
        {
            pcVariableId = pcVariableId.UAndT();
            var variable = new IwbRtVariable(pcVariableId, pcVariableType);
            Variables[pcVariableId] = variable;
            if(save2node && CurrentNode != null && !CurrentNode.Variables.ContainsKey(pcVariableId))
            {
                CurrentNode.Variables[pcVariableId] = variable;
            }
        }

        /// <summary>
        /// 设置变量值
        /// </summary>
        /// <param name="pcIdentifier"></param>
        /// <param name="pcExpression"></param>
        /// <param name="plToEvaluate"></param>
        public void SetValue(string pcIdentifier, string pcExpression, bool plToEvaluate = false)
        {
            pcIdentifier = pcIdentifier.UAndT();
            string pcValue = pcExpression;
            if (plToEvaluate)
            {
                pcValue = Evaluate(pcExpression);
            }
            if (pcIdentifier.IndexOf(IwbVariableType.Global, StringComparison.Ordinal) == 0)
            {
                if (FilterFields.ContainsKey(pcIdentifier))
                {
                    FilterFields[pcIdentifier] = pcValue;
                }
                //else
                //{
                //    UserSession.SetSessionVariable(pcIdentifier, pcValue);
                //}
            }
            else if (Variables.ContainsKey(pcIdentifier))
            {
                var variable = (IwbRtVariable)Variables[pcIdentifier];
                variable.VarValue = pcValue;
                CurrentNode.Variables[pcIdentifier] = variable;
            }
            else
            {
                Array array = pcIdentifier.StrToArrayEx("$");
                if (array.Length == 2)
                {
                    string pcDataSourceId = array.GetValue(0).ToString();
                    string name = array.GetValue(1).ToString();
                    IwbDataSource dataSource = GetDataSource(pcDataSourceId);
                    if (dataSource?.Data != null && (dataSource.Data.IsOpened))
                    {
                        dataSource.Data.SetField(name, pcValue);
                    }
                }
                else
                {
                    var variable = new IwbRtVariable(pcIdentifier.UAndT()).SetValue(pcValue);
                    CurrentNode.Variables[pcIdentifier] = variable;
                }
            }

        }

        /// <summary>
        /// 查询变量值
        /// </summary>
        /// <param name="pcIdentity"></param>
        /// <returns></returns>
        public string GetValue(string pcIdentity)
        {
            string str = pcIdentity;
            pcIdentity = pcIdentity.UAndT();
            if (pcIdentity.IndexOf(IwbVariableType.Global, StringComparison.Ordinal) == 0)
            {
                if (FilterFields.ContainsKey(pcIdentity))
                {
                    return FilterFields[pcIdentity].ToString();
                }
                //return UserSession.GetSessionVariableValue(pcIdentity);
            }
            if (Variables.ContainsKey(pcIdentity))
            {
                var variable = (IwbRtVariable)Variables[pcIdentity];
                return variable.GetStringValue();
            }
            Array array = pcIdentity.StrToArrayEx(CompStmtType.Separator);
            if (array.Length == 2)
            {
                string pcDataSourceId = array.GetValue(0).ToString();
                string name = array.GetValue(1).ToString();
                var dataSource = GetDataSource(pcDataSourceId);
                if (dataSource?.Data != null && dataSource.Data.IsOpened)
                {
                    str = dataSource.Data.GetString(name);
                }
            }
            return str;
        }

        /// <summary>
        /// 计算表达式
        /// </summary>
        /// <param name="pcExpression"></param>
        /// <returns></returns>
        public string Evaluate(string pcExpression)
        {
            string str = "";
            var poRoot = new ExprObject(pcExpression);
            if (EvalExpr.Parse(poRoot, true))
            {
                TransComponentVariables(poRoot);
                str = EvalExpr.Evaluate(poRoot);
            }
            return str;
        }

        /// <summary>
        ///  计算表达式
        /// </summary>
        /// <param name="pcExpression"></param>
        /// <returns></returns>
        public bool EvaluateBool(string pcExpression)
        {
            bool flag = true;
            if (pcExpression != "")
            {
                flag = Evaluate(pcExpression).ValB();
            }
            return flag;
        }

        /// <summary>
        /// 查询数据源
        /// </summary>
        /// <param name="pcDataSourceId"></param>
        /// <returns></returns>
        public IwbDataSource GetDataSource(string pcDataSourceId)
        {
            IwbDataSource source = null;
            pcDataSourceId = pcDataSourceId.UAndT();
            if (DataSources.ContainsKey(pcDataSourceId))
            {
                source = (IwbDataSource)DataSources[pcDataSourceId];
            }
            return source;
        }

        #endregion
    }
}