fg_yida_2/YiDa_WinForm/Service/FormulaBusinessService.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
using YiDa_WinForm.Service;

namespace YiDa_WinForm.Business
{
    /// <summary>
    /// 配方业务服务类
    /// </summary>
    public class FormulaBusinessService
    {
        #region 依赖注入与缓存
        // 依赖数据库操作服务
        private readonly ButtonOperationService _buttonOperationService;

        // 配方缓存（全局复用，避免重复查询数据库）
        public DataTable OriginalFormula { get; private set; } // 原始完整配方表
        public DataTable UniqueFormula { get; private set; } // 去重后配方表（用于下拉框）
        public DataTable MqttDic { get; private set; } // MQTT参数字典表

        // 选中的配方缓存（供外部调用）
        public List<DataRow> SelectedFormula1 { get; private set; } // 设备1选中配方
        public List<DataRow> SelectedFormula2 { get; private set; } // 设备2选中配方
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数（注入数据库操作服务）
        /// </summary>
        /// <param name="buttonOperationService">数据库操作服务实例</param>
        public FormulaBusinessService(ButtonOperationService buttonOperationService)
        {
            _buttonOperationService = buttonOperationService ?? throw new ArgumentNullException(nameof(buttonOperationService));
            OriginalFormula = new DataTable();
            UniqueFormula = new DataTable();
            MqttDic = new DataTable();
            SelectedFormula1 = new List<DataRow>();
            SelectedFormula2 = new List<DataRow>();
        }
        #endregion

        #region 公开方法（供MainForm调用，封装配方核心业务）
        /// <summary>
        /// 加载配方数据（从数据库查询并去重，供下拉框绑定）
        /// </summary>
        public async Task LoadFormulaAsync()
        {
            // 1. 从数据库查询原始配方
            DataTable dt = await _buttonOperationService.QueryFormulaAsync();
            if (dt == null || dt.Rows.Count == 0)
            {
                OriginalFormula = new DataTable();
                UniqueFormula = new DataTable();
                return;
            }

            // 2. 新增拼接列（part_number|part_name）
            if (!dt.Columns.Contains("part_number_name"))
            {
                dt.Columns.Add("part_number_name", typeof(string));
            }

            foreach (DataRow row in dt.Rows)
            {
                row["part_number_name"] = $"{row["part_number"]}|{row["part_name"]}";
            }

            // 3. 配方去重（按 part_number_name 分组）
            var uniqueParts = dt.AsEnumerable()
                .GroupBy(r => r["part_number_name"].ToString())
                .Select(g => g.First())
                .ToList();

            // 4. 构建去重后的数据表（添加空白行供下拉框默认选择）
            DataTable dtUnique = dt.Clone();
            foreach (var row in uniqueParts)
            {
                dtUnique.ImportRow(row);
            }

            // 新增空白行（索引0）
            DataRow blankRow = dtUnique.NewRow();
            blankRow["id"] = -1;
            blankRow["part_number_name"] = string.Empty;
            dtUnique.Rows.InsertAt(blankRow, 0);

            // 5. 更新缓存
            OriginalFormula = dt;
            UniqueFormula = dtUnique;
        }

        /// <summary>
        /// 加载MQTT参数字典（用于参数名中文映射）
        /// </summary>
        public async Task LoadMqttDicAsync()
        {
            DataTable dt = await _buttonOperationService.InitMqttDic();
            MqttDic = dt ?? new DataTable();
        }

        /// <summary>
        /// 刷新选中的配方（根据下拉框选择值筛选）
        /// </summary>
        /// <param name="selectedPart1">设备1下拉框选中的 part_number_name</param>
        /// <param name="selectedPart2">设备2下拉框选中的 part_number_name</param>
        public void RefreshSelectedFormula(string selectedPart1, string selectedPart2)
        {
            // 筛选设备1配方
            SelectedFormula1 = FilterFormulaBySelectedPart(selectedPart1);

            // 筛选设备2配方
            SelectedFormula2 = FilterFormulaBySelectedPart(selectedPart2);
        }

        /// <summary>
        /// 映射MQTT参数名（英文 → 中文，从字典表匹配）
        /// </summary>
        /// <param name="paramCode">MQTT原始参数编码（英文）</param>
        /// <returns>映射后的中文参数名（无匹配则返回原始编码）</returns>
        public string MapMqttParamName(string paramCode)
        {
            if (string.IsNullOrEmpty(paramCode) || MqttDic.Rows.Count == 0)
            {
                return paramCode;
            }

            try
            {
                DataRow[] drs = MqttDic.Select($"param_code = '{paramCode}'");
                return drs != null && drs.Length > 0 ? drs[0]["param_name"].ToString() : paramCode;
            }
            catch (Exception)
            {
                return paramCode;
            }
        }

        /// <summary>
        /// 根据参数名匹配配方中的对应行
        /// </summary>
        /// <param name="formulaList">目标配方列表</param>
        /// <param name="paramName">参数名（中文）</param>
        /// <returns>匹配到的配方行（无匹配返回null）</returns>
        public DataRow MatchFormulaByParamName(List<DataRow> formulaList, string paramName)
        {
            if (formulaList == null || formulaList.Count == 0 || string.IsNullOrEmpty(paramName))
            {
                return null;
            }

            return formulaList.FirstOrDefault(r => r.Field<string>("parameter_name") == paramName);
        }
        #endregion

        #region 内部辅助方法（私有，封装核心筛选逻辑）
        /// <summary>
        /// 根据下拉框选中值筛选对应的配方列表
        /// </summary>
        /// <param name="selectedPart">下拉框选中的 part_number_name</param>
        /// <returns>筛选后的配方列表</returns>
        private List<DataRow> FilterFormulaBySelectedPart(string selectedPart)
        {
            if (string.IsNullOrEmpty(selectedPart) || selectedPart == "-1" || OriginalFormula.Rows.Count == 0)
            {
                return new List<DataRow>();
            }

            // 拆分 part_number|part_name
            string[] partArr = selectedPart.Split('|');
            if (partArr.Length != 2)
            {
                return new List<DataRow>();
            }

            string partNumber = partArr[0];
            string partName = partArr[1];

            // 筛选匹配的配方行
            return OriginalFormula.AsEnumerable()
                .Where(r => r.Field<string>("part_number") == partNumber
                            && r.Field<string>("part_name") == partName)
                .ToList();
        }
        #endregion
    }
}