Sic.Framework-Nanjing-Baishi/MECF.Framework.Common/Aitex/Core/RT/IOCore/Interlock/InterlockManagerBase.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.ServiceModel.Configuration;
using System.Text;
using System.Xml;
using Aitex.Core.RT.IOCore.Interlock.DataProvider;
using Aitex.Core.RT.IOCore.Interlock.Limits;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.Equipment;

namespace Aitex.Core.RT.IOCore.Interlock;

public abstract class InterlockManagerBase<TAction>
    where TAction : IInterlockAction
{
    #region Variables

    private static List<IIOAccessor> _diMap;
    private static List<IIOAccessor> _doMap;
    private static List<IIOAccessor> _aiMap;
    private static List<IIOAccessor> _aoMap;

    protected string RootNodeName;
    
    protected readonly List<TAction> _lstActions;

    /// <summary>
    /// 每个Limit对应的DoAction集合。
    /// </summary>
    protected readonly Dictionary<IInterlockLimit, List<IInterlockAction>> _dicLimitToActionMap;
    
    /// <summary>
    /// 每个Module对应的DoAction集合。
    /// </summary>
    protected readonly Dictionary<ModuleName, List<TAction>> _dicActionsPerModule;
    
    /// <summary>
    /// 每个Module对应的Limit集合。
    /// </summary>
    protected readonly Dictionary<ModuleName, List<IInterlockLimit>> _dicLimitsPerModule;

    #endregion

    #region Constructors

    /// <summary>
    /// 互锁管理器的构造函数。
    /// </summary>
    protected InterlockManagerBase()
    {
        _lstActions = new();
        _dicActionsPerModule = new();
        _dicLimitToActionMap = new ();
        _dicLimitsPerModule = new ();
    }

    #endregion

    #region Methods

    /// <summary>
    /// 初始化互锁管理器。
    /// </summary>
    /// <param name="configFile">互锁配置文件。</param>
    /// <param name="doMap">DO点表。</param>
    /// <param name="diMap">DI点表。</param>
    /// <param name="aoMap">AO点表。</param>
    /// <param name="aiMap">AI点表。</param>
    /// <param name="reason">初始化失败原因。</param>
    /// <returns></returns>
    public virtual bool Initialize(string configFile,
        Dictionary<string, DOAccessor> doMap,
        Dictionary<string, DIAccessor> diMap,
        Dictionary<string, AIAccessor> aiMap,
        Dictionary<string, AOAccessor> aoMap,
        out string reason)
    {
        reason = "";

        if (string.IsNullOrEmpty(configFile))
        {
            reason = "interlock daemon config file does not specified";
            return false;
        }

        if (!File.Exists(configFile))
        {
            reason = $"interlock daemon config file {configFile} does not exist";
            return false;
        }

        _doMap = doMap.Values.Cast<IIOAccessor>().ToList();
        _diMap = diMap.Values.Cast<IIOAccessor>().ToList();
        _aiMap = aiMap.Values.Cast<IIOAccessor>().ToList();
        _aoMap = aoMap.Values.Cast<IIOAccessor>().ToList();

        var sbReason = new StringBuilder();
        try
        {
            var doc = new XmlDocument();
            doc.Load(configFile);
            var xmlNode = doc.SelectSingleNode(RootNodeName);

            if (xmlNode == null) // 如果Interlock节点不存在
            {
                var err =
                    $"Failed to load interlock daemon file, the node 'Daemon' is not found in file {configFile}.";
                sbReason.AppendLine(err);
                LOG.Error(err);
                return false;
            }

            foreach (XmlNode childNode in xmlNode.ChildNodes)
            {
                // 遍历'Action'节点

                if (!CheckIsXmlElement(childNode, out var actionNode))
                    continue;

                if (actionNode.Name != "Action")
                {
                    if (actionNode.NodeType != XmlNodeType.Comment)
                        LOG.Write("interlock daemon file contains no comments content, " + actionNode.InnerXml);

                    continue;
                }

                // Action节点仅支持对DO进行配置
                if (!actionNode.HasAttribute("do") || !actionNode.HasAttribute("value"))
                {
                    sbReason.AppendLine("action node has no [do] or [value] attribute");
                    continue;
                }

                var doName = actionNode.GetAttribute("do");
                var doValue = Convert.ToBoolean(actionNode.GetAttribute("value"));
                var tip = string.Empty;
                var dicTips = new Dictionary<string, string>();
                if (!doMap.ContainsKey(doName))
                {
                    sbReason.AppendLine("action node " + doName + " no such DO defined");
                    continue;
                }

                // 获取DO实例
                var targetDo = doMap[doName];
                if (targetDo == null)
                {
                    // 如果DO不存在，则读取下一个Action节点
                    sbReason.AppendLine("action node " + doName + " no such DO defined");
                    continue;
                }

                if (actionNode.HasAttribute("tip"))
                    tip = actionNode.GetAttribute("tip");

                if (actionNode.HasAttribute("tip.zh-CN"))
                    dicTips["zh-CN"] = actionNode.GetAttribute("tip.zh-CN");

                if (actionNode.HasAttribute("tip.en-US"))
                    dicTips["en-US"] = actionNode.GetAttribute("tip.en-US");

                var moduleName = GetModuleFromIo(targetDo.Name);
                if (!_dicActionsPerModule.ContainsKey(moduleName))
                    _dicActionsPerModule[moduleName] = new List<TAction>();

                // 创建InterlockAction对象

                var action = (TAction)Activator.CreateInstance(typeof(TAction), moduleName.ToString(),
                    targetDo, doValue, tip, dicTips);

                // 遍历Action下的Limit节点，并创建InterlockLimit对象。
                foreach (XmlNode limitNode in actionNode.ChildNodes)
                {
                    if (!CheckIsXmlElement(limitNode, out var node))
                        continue;

                    if (node.Name.ToLower() == "or")
                    {
                        var groupOr = CreateOrLimitGroup(node, out var err0);
                        action.AddLogicOrGroup(groupOr);
                    }
                    else
                    {
                        // 获取InterlockLimit对象。
                        var limit = CreateInterlockLimit(node, out var err);
                        if (limit != null)
                            action.AddLimit(limit);
                        else
                            sbReason.AppendLine(err);
                    }
                }

                _dicActionsPerModule[moduleName].Add(action);
                _lstActions.Add(action);

                
                foreach (var limit in action.Limits)
                {
                    // 创建以Limit分组的Action字典
                    if (!_dicLimitToActionMap.ContainsKey(limit))
                        _dicLimitToActionMap[limit] = new List<IInterlockAction>();
                    
                    _dicLimitToActionMap[limit].Add(action);
                }
            }
            
            Debug.Assert(!_dicActionsPerModule.ContainsKey(ModuleName.UnDefined),
                $"InterlockManager {nameof(_dicActionsPerModule)} contains key {ModuleName.UnDefined}");
                
            Debug.Assert(!_dicLimitsPerModule.ContainsKey(ModuleName.UnDefined),
                $"InterlockManager {nameof(_dicLimitsPerModule)} contains key {ModuleName.UnDefined}");
        }
        catch (Exception ex)
        {
            sbReason.AppendLine(ex.Message);
        }
        finally
        {
            if (sbReason.Length > 0)
                reason = sbReason.ToString().TrimEnd('\n', '\r');
        }

        return sbReason.Length == 0;
    }

    /// <summary>
    /// 背景扫描线程执行的任务。
    /// </summary>
    public abstract void Monitor();

    /// <summary>
    /// 通过XML配置创建互锁限制条件对象。
    /// </summary>
    /// <param name="limitNode">包含Limit定义的Xml节点。</param>
    /// <param name="reason">创建失败并返回null的原因。</param>
    /// <returns></returns>
    private IInterlockLimit CreateInterlockLimit(XmlElement limitNode, out string reason)
    {
        reason = "";

        // 检查节点名称是否为Limit
        if (limitNode.Name != "Limit") // 节点名称不是Limit
        {
            reason = "the name of xml node is not 'Limit'";
            if (limitNode.NodeType != XmlNodeType.Comment)
            {
                reason = "interlock config file contains no comments content, " + limitNode.InnerXml;
                LOG.Write(reason);
            }

            return null;
        }

        string limitValue;
        if (limitNode.HasAttribute("value"))
            limitValue = limitNode.GetAttribute("value");
        else
        {
            reason = "limit node lack of value attribute";
            return null;
        }

        var tip = string.Empty;
        var dicLimitTips = new Dictionary<string, string>();
        if (limitNode.HasAttribute("tip"))
            tip = limitNode.GetAttribute("tip");

        if (limitNode.HasAttribute("tip.zh-CN"))
        {
            dicLimitTips["zh-CN"] = limitNode.GetAttribute("tip.zh-CN");
            if (string.IsNullOrEmpty(tip))
                tip = dicLimitTips["zh-CN"];

        }

        if (limitNode.HasAttribute("tip.en-US"))
        {
            dicLimitTips["en-US"] = limitNode.GetAttribute("tip.en-US");
            if (string.IsNullOrEmpty(tip))
                tip = dicLimitTips["en-US"];
        }

        // 节点不包含‘di’、‘do’、‘ai’、‘ao’，或者不包含‘value’属性
        IInterlockLimit limit;
        if (limitNode.HasAttribute("di"))
        {
            var limitName = limitNode.GetAttribute("di");
            var io = GetIoByIoType(IOType.DI, limitName);
            var provider = new DiValueProvider((DIAccessor)io);
            limit = new DiLimit(provider, limitValue, tip, dicLimitTips);
        }
        else if (limitNode.HasAttribute("do"))
        {
            var limitName = limitNode.GetAttribute("do");
            var io = GetIoByIoType(IOType.DO, limitName);
            var provider = new DoValueProvider((DOAccessor)io);
            limit = new DoLimit(provider, limitValue, tip, dicLimitTips);
        }
        else if (limitNode.HasAttribute("ai"))
        {
            var limitName = limitNode.GetAttribute("ai");
            var io = GetIoByIoType(IOType.AI, limitName);
            var provider = new AiValueProvider((AIAccessor)io);
            limit = new AiLimit(provider, limitValue, tip, dicLimitTips);
        }
        else if (limitNode.HasAttribute("ao"))
        {
            var limitName = limitNode.GetAttribute("ao");
            var io = GetIoByIoType(IOType.AO, limitName);
            var provider = new AoValueProvider((AOAccessor)io);
            limit = new AoLimit(provider, limitValue, tip, dicLimitTips);
        }
        else if (limitNode.HasAttribute("polldouble"))
        {
            var limitName = limitNode.GetAttribute("polldouble");
            var provider = new DoubleDataPollProvider(limitName);
            limit = new DoubleDataPollLimit(provider, limitValue, tip, dicLimitTips);
        }
        else if (limitNode.HasAttribute("pollbool"))
        {
            var limitName = limitNode.GetAttribute("pollbool");
            var provider = new BoolDataPollProvider(limitName);
            limit = new BoolDataPollLimit(provider, limitValue, tip, dicLimitTips);
        }
        else
        {
            reason = "limit node lack of di/do/ai/ao/io/pollbool/polldouble attribute";
            return null;
        }

        // 从_dicLimitsPerModule字典中查找当前创建的Limit是否已经存在；
        // 如果存在，直接返回已存在的Limit实例；
        // 否则，将当前创建的Limit放到字典中，然后返回实例；
        var moduleName = GetModuleFromIo(limit.Name);
        if (_dicLimitsPerModule.TryGetValue(moduleName, out var list))
        {
            var existLimit = list.FirstOrDefault(x => x.UniqueId == limit.UniqueId);
            if(existLimit != null)
                limit = existLimit; // 返回字典中的Limit实例
            else
                list.Add(limit); // 将当前Limit加入字典
        }
        else
        {
            // 在字典中创建Module，并将Limit实例放入字典
            _dicLimitsPerModule[moduleName] = new List<IInterlockLimit>(new[] { limit });
        }

        return limit;
    }

    /// <summary>
    /// 创建“OR”定义的Limit组。
    /// </summary>
    /// <param name="xmlNodeOr"></param>
    /// <param name="reason"></param>
    /// <returns></returns>
    private List<IInterlockLimit> CreateOrLimitGroup(XmlNode xmlNodeOr, out string reason)
    {
        reason = "";
        var limitList = new List<IInterlockLimit>();
        foreach (XmlNode childNode in xmlNodeOr.ChildNodes)
        {
            if (!CheckIsXmlElement(childNode, out var node))
                continue;

            var limit = CreateInterlockLimit(node, out reason);
            if (limit != null)
                limitList.Add(limit);
            else
                return null;
        }

        return limitList;
    }

    /// <summary>
    /// 根据给定的IO类型和IO名称，从IO列表中获取IO对象实例。
    /// </summary>
    /// <param name="type">IO类型，请参考<see cref="IOType"/>。</param>
    /// <param name="ioName">IO名称。</param>
    /// <returns></returns>
    /// <exception cref="InvalidIoTypeExeption">无效的IO类型。</exception>
    /// <exception cref="IoNotFoundException">未找到IO。</exception>
    private static IIOAccessor GetIoByIoType(IOType type, string ioName)
    {
        List<IIOAccessor> dictMap;
        switch (type)
        {
            case IOType.DI:
                dictMap = _diMap;
                break;

            case IOType.DO:
                dictMap = _doMap;
                break;

            case IOType.AI:
                dictMap = _aiMap;
                break;

            case IOType.AO:
                dictMap = _aoMap;
                break;

            default:
                throw new InvalidIoTypeExeption();
        }

        var io = dictMap.FirstOrDefault(x => x.Name == ioName);
        if (io != null)
            return io;

        throw new IoNotFoundException(type, ioName);
    }

    /// <summary>
    /// 从指定的IO中解析该IO所属的模组。
    /// </summary>
    /// <param name="ioName"></param>
    /// <returns></returns>
    protected static ModuleName GetModuleFromIo(string ioName)
    {
        Debug.Assert(!string.IsNullOrEmpty(ioName), "the IO name can not be empty.");
        if (string.IsNullOrEmpty(ioName))
        {
            LOG.Error($"InterlockManager GetModuleFromIo failed, the parameter ioName is empty");
            return ModuleName.UnDefined;
        }

        // Simulator中TM的Io表配置中没有"TM."前缀；
        // 为兼容此问题，如果没有找到Module前缀，则用System代替
        var posDot = ioName.IndexOf('.');
        if (posDot <= 0)
            return ModuleName.System;

        var moduleName = ioName.Substring(0, posDot);
        return ModuleHelper.Converter(moduleName);
    }

    /// <summary>
    /// 检查制定的XmlNode是否为XmlElement.
    /// </summary>
    /// <param name="node"></param>
    /// <param name="element"></param>
    /// <returns></returns>
    private static bool CheckIsXmlElement(XmlNode node, out XmlElement element)
    {
        element = null;
        if (node.NodeType != XmlNodeType.Comment && node is XmlElement)
        {
            element = (XmlElement)node;
            return true;
        }

        return false;
    }

    #endregion
}