FurnaceELK/FrameworkLocal/UIClient/CenterViews/Operations/RealTime/RealtimeProvider.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using DocumentFormat.OpenXml.Drawing;
using ExtendedGrid.Microsoft.Windows.Controls;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Device;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Utilities;
using MECF.Framework.UI.Client.CenterViews.DataLogs.ProcessHistory;
using MECF.Framework.UI.Client.ClientBase.Tree;
using OpenSEMI.ClientBase.ServiceProvider;
using SciChart.Core.Extensions;

namespace MECF.Framework.UI.Client.CenterViews.Operations.RealTime
{
    public class RealtimeProvider : IProvider
    {
        ObservableCollection<ParameterNode> _rootNode = new ObservableCollection<ParameterNode>();
        Dictionary<string, ParameterNode> _indexer = new Dictionary<string, ParameterNode>();

        public void Clear()
        {
            _indexer.Clear();
            _rootNode.Clear();
        }

        /// <summary>
        /// 使用字符串队列创建树结构的分支。
        /// </summary>
        /// <param name="branchString"></param>
        /// <param name="node"></param>
        private static TreeNode CreateTreeBranch(Queue<string> branchString, TreeNode node)
        {
            var rootNode = node;

            while (true)
            {
                if (branchString.Count <= 0)
                    return rootNode;

                var name = branchString.Dequeue();

                if (node == null)
                {
                    // 根节点
                    node = new TreeNode(name);
                    rootNode = node;
                }
                else
                {
                    if (node.Name == name)
                        continue;

                    // 向ChildNode插入
                    var subNode = node.ChildNodes.FirstOrDefault(x => x.Name == name);
                    if (subNode == null)
                    {
                        subNode = new TreeNode(name);
                        node.ChildNodes.Add(subNode);
                    }

                    node = subNode;
                }
            }
        }

        public void Create()
        {

        }

        public ObservableCollection<string> GetUserDefineParameters()
        {
            var typedContents = ((string)QueryDataClient.Instance.Service.GetTypedConfigContent("UserDefine", ""));
            ObservableCollection<string> dataList = new ObservableCollection<string>();
            if (typedContents != null)
            {
                var contentList = typedContents.Split(',').ToList();
                contentList.ForEach(x =>
                {
                    if (!string.IsNullOrEmpty(x)) dataList.Add($"{x}");
                });
            }

            return dataList;
        }
        public Dictionary<string, string> GetSystemDeviceNameDict()
        {


            return new Dictionary<string, string>()
            {
                {ModuleName.CarrierRobot.ToString(),ModuleName.Robot.ToString() },
                {ModuleName.WaferRobot.ToString(),ModuleName.Robot.ToString() },
                {ModuleName.FIMS.ToString(),ModuleName.FIMS.ToString() },
                {ModuleName.LP.ToString(),ModuleName.LP.ToString() },
                {ModuleName.Stocker.ToString(),ModuleName.Stocker.ToString() },

            };
        }
        /// <summary>
        /// 筛选数据库字段
        /// </summary>
        /// <param name="dataList"></param>
        /// <returns></returns>
        private Dictionary<string, string> FilterNumericDataList(List<string> dataList, Dictionary<string, string> displayXmlDict)
        {
            //这里包含了项目中注册到数据库中的所有字段，需要从中筛选出来有效字段并归类
            Dictionary<string, string> result = new Dictionary<string, string>();
            var effectiveDataList = dataList.Where(a => a.Split('.').Count() > 1);
            var pm1DataList = effectiveDataList.Where(a => a.StartsWith(ModuleName.PM1.ToString()) && !displayXmlDict.Keys.Contains(a)).ToDictionary(a => a, a => a);
            var systemDataList = effectiveDataList.Where(a => a.StartsWith(ModuleName.System.ToString()) && !displayXmlDict.Keys.Contains(a)).ToDictionary(a => a, a => a);
            result.AddRange(pm1DataList);
            result.AddRange(systemDataList);
            var systemDeviceNameDict = GetSystemDeviceNameDict();
            //  var NameKeyDict = QueryDataClient.Instance.Service.GetData("System.NameKeyDict") as Dictionary<string, List<string>>;

            foreach (var item in systemDeviceNameDict)
            {
                var data = effectiveDataList.Where(a => (a.StartsWith(item.Key))).ToDictionary(a => a, a => $"{item.Value}.{a}");

                result.AddRange(data);
            }


            return result;

        }
        /// <summary>
        /// 获取指定日期数据库PM/System table 列
        /// </summary>
        /// <param name="dbTableName"></param>
        /// <returns></returns>
        public List<string> GetDBCol(string dbTableName)
        {
            var columnsql = $"select column_name from information_schema.columns where table_name = '{dbTableName}'";
            var columnTable = QueryDataClient.Instance.Service.QueryData(columnsql);
            return columnTable.Rows.Cast<DataRow>().Select(x => x.ItemArray[0].ToString()).ToList();
        }
        /// <summary>
        /// 获取DataHistory 左侧树字典（既包含配置文件字段，也包含PM/System表字段）
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, string> GetTreeNameDict()
        {
            Dictionary<string, string> displayDic = QueryDataClient.Instance.Service.GetData("System.Display") as Dictionary<string, string>;
            List<string> dataList = (List<string>)QueryDataClient.Instance.Service.GetConfig("System.NumericDataList");
            var dataListDict = FilterNumericDataList(dataList, displayDic);
            displayDic.AddRange(dataListDict);
            return displayDic;
        }
        /// <summary>
        /// 获取ProcessHistory 左侧树结构（不包含PM/System,只根据配置文件字段生成）
        /// </summary>
        /// <param name="processDetailDisplayDic"></param>
        /// <param name="isSelected"></param>
        /// <returns></returns>
        public Dictionary<string, Dictionary<string, string>> GetProcessProcessDetailAttributeDict()
        {

            return QueryDataClient.Instance.Service.GetData("System.ProcessDetailInfoDict") as Dictionary<string, Dictionary<string, string>>;

        }
        public ObservableCollection<ParameterNode> GetParameters(out Dictionary<string, string> processDetailDisplayDic, bool isSelected = false)
        {
            processDetailDisplayDic = new Dictionary<string, string>();
            ObservableCollection<ParameterNode> rootNode = new ObservableCollection<ParameterNode>();
            try
            {
                Dictionary<string, string> displayDic = QueryDataClient.Instance.Service.GetData("System.ProcessDetailDisplay") as Dictionary<string, string>;

                if (displayDic == null)
                    return rootNode;

                List<string> dataList = new List<string>();
                foreach (var itemDisplay in displayDic)
                {
                    string[] keyItems = itemDisplay.Key.Split('.');
                    string[] valueItems = itemDisplay.Value.Split('.');
                    if (keyItems != null)
                    {
                        if (keyItems.Length == 2)
                        {
                            var key = $"{valueItems[1]}";
                            var keyValue = itemDisplay.Key;
                            if (!processDetailDisplayDic.ContainsKey(key))
                            {
                                processDetailDisplayDic.Add(key, keyValue);
                            }
                            dataList.Add($"{valueItems[0]}.{valueItems[1]}");
                        }
                        else if (keyItems.Length == 3)
                        {
                            var key = $"{valueItems[1]} {valueItems[2]}";
                            var keyValue = itemDisplay.Key;
                            if (!processDetailDisplayDic.ContainsKey(key))
                            {
                                processDetailDisplayDic.Add(key, keyValue);
                            }
                            dataList.Add($"{valueItems[0]}.{valueItems[1]}.{valueItems[2]}");
                        }
                    }
                }



                Dictionary<string, ParameterNode> indexer = new Dictionary<string, ParameterNode>();
                foreach (string dataName in dataList)
                {
                    string[] nodeName = dataName.Split('.');
                    ParameterNode parentNode = null;
                    string pathName = "";
                    for (int i = 0; i < nodeName.Length; i++)
                    {
                        pathName = (i == 0 || i == 1) ? nodeName[i] : (pathName + " " + nodeName[i]);

                        if (!indexer.ContainsKey(pathName))
                        {
                            indexer[pathName] = new ParameterNode() { Name = pathName, ChildNodes = new ObservableCollection<ParameterNode>(), ParentNode = parentNode };

                            if (parentNode == null)
                            {
                                rootNode.Add(indexer[pathName]);
                            }
                            else
                            {
                                parentNode.ChildNodes.Add(indexer[pathName]);
                            }
                        }

                        parentNode = indexer[pathName];
                    }
                }
                SortParameterNode(rootNode,
                    new Dictionary<string, int>() {
                    { "Heater",0},
                    { "MFC",1},
                    { "APC",2},
                    { "Boat",3},
                    { "Valve",4} },
                    isSelected);

            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }

            return rootNode;
        }
        /// <summary>
        /// 获取DataHistory 左侧树结构（既包含配置文件字段，也包含PM/System表字段）
        /// </summary>
        /// <returns></returns>
        public List<TreeNode> GetTreeNodeParameters()
        {
            var root = new List<TreeNode>();
            try
            {
                var displayDic = GetTreeNameDict();

                foreach (var dataName in displayDic.Values)
                {
                    var nodeName = new Queue<string>(dataName.Split('.'));
                    if (nodeName.Count <= 0)
                        continue;

                    // 开始创建Tree分支
                    var rootNode = root.FirstOrDefault(x => x.Name == nodeName.Peek());
                    var node = CreateTreeBranch(nodeName, rootNode);
                    if (rootNode == null)
                    {
                        root.Add(node);
                    }
                }

                SortParameterNode(root, "PM1", 0);
                SortParameterNode(root, "System", 1);
                SortParameterNode(root, "Heater", 2);
                SortParameterNode(root, "MFC", 3);
                SortParameterNode(root, "APC", 4);
                SortParameterNode(root, "Boat", 5);
                SortParameterNode(root, "Valve", 6);
                foreach (var rootNodes in root)
                {
                    var childNode = rootNodes.ChildNodes.ToList();
                    childNode.Sort(new NameComparer());
                    for (int i = 0; i < childNode.Count; i++)
                    {
                        rootNodes.ChildNodes.Move(rootNodes.ChildNodes.IndexOf(childNode[i]), i);
                    }
                }

            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }

            return root;

        }
        #region Sort 排序

        void SortParameterNode(List<TreeNode> rootNode, string Name, int Index)
        {
            if (Index >= rootNode.Count)
            {
                return;
            }

            for (int i = 0; i < rootNode.Count; i++)
            {
                if (rootNode[i].Name == Name && i != Index)
                {
                    TreeNode node = rootNode[i];
                    rootNode.RemoveAt(i);
                    rootNode.Insert(Index, node);
                    break;
                }
            }

            // Recursively sort children

        }

        void SortParameterNode(ObservableCollection<ParameterNode> rootNode, Dictionary<string, int> sortDict, bool isSelectd = false)
        {
            foreach (var item in sortDict)
            {
                SortParameterNode(rootNode, item.Key, item.Value, isSelectd);
            }
        }
        void SortParameterNode(ObservableCollection<ParameterNode> rootNode, string Name, int Index, bool isSelectd = false)
        {
            if (Index >= rootNode.Count)
            {
                return;
            }
            if (rootNode[Index].Name != Name)
            {
                for (int i = 0; i < rootNode.Count; i++)
                {
                    rootNode[i].Selected = isSelectd;
                    if (rootNode[i].Name == Name)
                    {
                        ParameterNode node = rootNode[i];
                        rootNode.RemoveAt(i);
                        rootNode.Insert(Index, node);
                    }
                }
            }
        }
        #endregion

        public ObservableCollection<ParameterNode> GetParameterNodeParameters()
        {
            try
            {
                List<string> dataList =
                    (List<string>)QueryDataClient.Instance.Service.GetConfig("System.NumericDataList");
                var typedContents = ((string)QueryDataClient.Instance.Service.GetTypedConfigContent("UserDefine", ""));
                for (int i = 0; i < dataList.Count; i++)
                {
                    if (dataList[i].StartsWith("SMIF"))
                        dataList[i] = $"SMIFs.{dataList[i]}";
                    if (dataList[i].StartsWith("Stocker"))
                        dataList[i] = $"Stockers.{dataList[i]}";
                    if (dataList[i].StartsWith("Stage"))
                        dataList[i] = $"Stages.{dataList[i]}";
                    dataList[i] = dataList[i].Replace("PM1", "Tube");
                }

                if (string.IsNullOrEmpty(typedContents))
                {
                    dataList.Add($"UserDefine");
                }
                else
                {
                    var contentList = typedContents.Split(',').ToList();
                    contentList.ForEach(x =>
                    {
                        if (!string.IsNullOrEmpty(x)) dataList.Add($"UserDefine.{x}");
                    });
                }

                dataList.Sort();
                //List<string> removeList = _indexer.Keys.ToList();
                foreach (string dataName in dataList)
                {
                    string[] nodeName = dataName.Split('.');
                    ParameterNode parentNode = null;
                    string pathName = "";
                    for (int i = 0; i < nodeName.Length; i++)
                    {
                        pathName = (i == 0) ? nodeName[i] : (pathName + "." + nodeName[i]);

                        //removeList.Remove(pathName);

                        if (!_indexer.ContainsKey(pathName))
                        {
                            _indexer[pathName] = new ParameterNode()
                            {
                                Name = pathName.Replace("UserDefine.", "").Replace("SMIFs.", "").Replace("Stages.", "")
                                    .Replace("Stockers.", ""),
                                ChildNodes = new ObservableCollection<ParameterNode>(),
                                ParentNode = parentNode
                            };

                            if (parentNode == null)
                            {
                                _rootNode.Add(_indexer[pathName]);
                            }
                            else
                            {
                                parentNode.ChildNodes.Add(_indexer[pathName]);
                            }
                        }

                        parentNode = _indexer[pathName];

                        //removeList.Remove(pathName);
                    }
                }

                //foreach (var key in removeList)
                //{
                //    if (_indexer[key].ParentNode == null)
                //        _rootNode.Remove(_indexer[key]);
                //    else
                //    {
                //        _indexer[key].ParentNode.ChildNodes.Remove(_indexer[key]);
                //    }
                //}

                return _rootNode;
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
            #region Test code
            ObservableCollection<ParameterNode> result = new ObservableCollection<ParameterNode>();

            ParameterNode node1 = new ParameterNode() { Name = "Para Node 1", Selected = false, ChildNodes = new ObservableCollection<ParameterNode>() };
            ParameterNode node2 = new ParameterNode() { Name = "Para Node 2", Selected = false, ChildNodes = new ObservableCollection<ParameterNode>() };
            ParameterNode node3 = new ParameterNode() { Name = "Para Node 3", Selected = false, ChildNodes = new ObservableCollection<ParameterNode>() };

            for (int i = 0; i < 5; i++)
            {
                ParameterNode node = new ParameterNode() { Name = node1.Name + "_" + i.ToString(), Selected = false, ChildNodes = new ObservableCollection<ParameterNode>() };
                node1.ChildNodes.Add(node);
            }

            for (int i = 0; i < 3; i++)
            {
                ParameterNode node = new ParameterNode() { Name = node2.Name + "_" + i.ToString(), Selected = false, ChildNodes = new ObservableCollection<ParameterNode>() };
                node2.ChildNodes.Add(node);
            }

            for (int i = 0; i < 4; i++)
            {
                ParameterNode node = new ParameterNode() { Name = node3.Name + "_" + i.ToString(), Selected = false, ChildNodes = new ObservableCollection<ParameterNode>() };
                node3.ChildNodes.Add(node);
            }

            result.Add(node1);
            result.Add(node2);
            result.Add(node3);
            return result;
            #endregion
        }
    }
    public class NameComparer : IComparer<TreeNode>
    {
        public int Compare(TreeNode x, TreeNode y)
        {
            if (x == null || y == null)
                throw new ArgumentException("Parameters can't be null");
            string fileA = x.DisplayName;
            string fileB = y.DisplayName;
            char[] arr1 = fileA.ToCharArray();
            char[] arr2 = fileB.ToCharArray();
            int i = 0, j = 0;
            while (i < arr1.Length && j < arr2.Length)
            {
                if (char.IsDigit(arr1[i]) && char.IsDigit(arr2[j]))
                {
                    string s1 = "", s2 = "";
                    while (i < arr1.Length && char.IsDigit(arr1[i]))
                    {
                        s1 += arr1[i];
                        i++;
                    }
                    while (j < arr2.Length && char.IsDigit(arr2[j]))
                    {
                        s2 += arr2[j];
                        j++;
                    }
                    if (int.Parse(s1) > int.Parse(s2))
                    {
                        return 1;
                    }
                    if (int.Parse(s1) < int.Parse(s2))
                    {
                        return -1;
                    }
                }
                else
                {
                    if (arr1[i] > arr2[j])
                    {
                        return 1;
                    }
                    if (arr1[i] < arr2[j])
                    {
                        return -1;
                    }
                    i++;
                    j++;
                }
            }
            if (arr1.Length == arr2.Length)
            {
                return 0;
            }
            else
            {
                return arr1.Length > arr2.Length ? 1 : -1;
            }
        }
    }
}