Display_D_HP/TeamAAS-VM/Services/ConfigService.cs

using Cognex.VisionPro;
using Cognex.VisionPro.ToolBlock;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using TeamAAS_VP.Core;
using TeamAAS_VP.Core.Robots;
using TeamAAS_VP.Data; // for ISystemDatabaseService (if used)
using TeamAAS_VP.Enums;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Models.Calibration;
using TeamAAS_VP.Models.Feeder;
using TeamAAS_VP.Models.Lights;
using TeamAAS_VP.Models.PLC;
using TeamAAS_VP.Models.ScrewDriver;
using TeamAAS_VP.Models.Torque;
using TeamAAS_VP.Resources.Languages;
using WPFLocalizeExtension.Engine;

namespace TeamAAS_VP.Services
{
    /// <summary>
    /// 锟斤拷锟矫诧拷锟斤拷锟斤拷锟斤拷实锟斤拷锟洁。
    /// 锟竭程帮拷全锟斤拷锟节诧拷使锟斤拷私锟斤拷锟斤拷锟街讹拷 <see cref="_sync"/> 锟斤拷锟斤拷锟斤拷锟斤拷锟节存集锟较的诧拷锟斤拷锟斤拷锟绞★拷
    /// 锟街久伙拷锟斤拷锟皆硷拷锟较碉拷锟睫改伙拷写锟截碉拷锟斤拷应锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷路锟斤拷锟斤拷锟节诧拷锟斤拷态锟斤拷 <see cref="ConfigPaths"/> 锟斤拷锟藉）锟斤拷
    /// </summary>
    public class ConfigService : IConfigService
    {
        private static class ConfigPaths
        {
            // 锟斤拷路锟斤拷锟斤拷锟叫癸拷锟斤拷锟节憋拷锟洁，锟斤拷前使锟斤拷锟斤拷锟斤拷 FilePath 值锟皆憋拷锟街硷拷锟斤拷
            public static readonly string CamerasConfigurationPath = "..//Config//CameraConfiguration.cfg";
            public static readonly string RobotsConfigurationPath = "..//Config//RobotsConfiguration.cfg";
            public static readonly string FeedersConfigurationPath = "..//Config//FeedersConfiguration.cfg";
            public static readonly string PlcConfigurationPath = "..//Config//PlcConfiguration.cfg";
            public static readonly string BgTcpIpConfigurationPath = "..//Config//BgTcpIpConfiguration.cfg";
            public static readonly string BgModbusTcpConfigurationPath = "..//Config//BgModbusTcpConfiguration.cfg";
            public static readonly string SystemConfigurationPath = "..//Config//SystemConfiguration.cfg";
            public static readonly string DeviceInfoConfigurationPath = "..//Config//DeviceInfo.cfg";
            // Feeder锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷路锟斤拷
            public static readonly string FeederClearanceTasksConfigurationPath = "..//Config//FeederClearanceTasksConfiguration.cfg";
            // 锟斤拷源锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷路锟斤拷
            public static readonly string LightControllersConfigurationPath = "..//Config//LightControllersConfiguration.cfg";
            // 锟斤拷锟斤拷锟斤拷锟斤拷路锟斤拷锟斤拷锟斤拷锟借备锟斤拷
            public static readonly string ScrewDriverConfigurationPath = "..//Config//ScrewDriverConfiguration.cfg";
            // 锟斤拷丝锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较ｏ拷锟斤拷锟斤拷路锟斤拷
            public static readonly string ScrewFeedersConfigurationPath = "..//Config//ScrewFeedersConfiguration.cfg";
            // 刷锟斤拷锟斤拷锟斤拷锟斤拷路锟斤拷
            public static readonly string CardReaderConfigurationPath = "..//Config//CardReaderConfiguration.cfg";
            // 锟斤拷锟斤拷锟斤拷锟斤拷路锟斤拷
            public static readonly string TorqueReaderConfigurationPath = "..//Config//TorqueReaderConfiguration.cfg";
            public static readonly string DataConfigurationPath = "..//Config//DataConfiguration.cfg";
        }

        private readonly object _sync = new object();
        private ObservableCollection<CameraInfo> Cameras { get; set; }
        private ObservableCollection<RobotInfo> Robots { get; set; }
        private ObservableCollection<FeederInfo> Feeders { get; set; }
        // 锟斤拷丝锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较ｏ拷锟斤拷锟斤拷
        private ObservableCollection<ScrewFeederInfo> ScrewFeeders { get; set; }
        private ObservableCollection<PlcInfo> Plcs { get; set; }
        private BgTcpIP BgCommunicate { get; set; }
        private BgModbusTcp BgModbusCommunicate { get; set; }
        private ObservableCollection<FeederClearWork> FeederClearanceTasks { get; set; }
        // 锟斤拷源锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
        private ObservableCollection<LightControllerConfig> LightControllers { get; set; }

        // Device info - 鏀�寔澶氳�澶?
        private List<DeviceInfo> _deviceInfoList;
        public CTQ_Data CtqData { get; set; }

        private PlcAddressConfig PlcAddressConfig { get; set; }
        // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
        private TeamAAS_VP.Models.ScrewDriver.ScrewDriverConfig _screwDriverConfig;
        public TeamAAS_VP.Models.ScrewDriver.ScrewDriverConfig ScrewDriverConfig { get { lock (_sync) { return _screwDriverConfig; } } }

        private ISystemDatabaseService _systemDatabaseService;

        // 刷锟斤拷锟斤拷锟斤拷锟斤拷
        private SerialPortConfig _cardReaderConfig;

        private TorqueSerialPortConfig _torqueReaderConfig;

        /// <summary>
        /// 注锟斤拷系统锟斤拷锟捷匡拷锟斤拷瘢ǹ锟窖★拷锟斤拷锟斤拷锟斤拷诩锟铰硷拷锟剿匡拷锟斤拷伪锟斤拷锟饺硷拷录锟斤拷
        /// </summary>
        /// <param name="svc"></param>
        public void SetSystemDatabaseService(ISystemDatabaseService svc)
        {
            lock (_sync)
            {
                _systemDatabaseService = svc;
            }
        }

        /// <summary>
        /// 锟斤拷始锟斤拷一锟斤拷锟铰碉拷 <see cref="ConfigService"/> 实锟斤拷锟斤拷
        /// 锟斤拷锟届函锟斤拷锟斤拷锟斤拷锟皆讹拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷锟斤拷锟节癸拷锟斤拷锟节硷拷锟斤拷锟?I/O 锟斤拷锟斤拷锟斤拷锟斤拷锟缴碉拷锟斤拷 <see cref="LoadAll"/> 锟斤拷 <see cref="LoadAllAsync"/> 锟斤拷式锟斤拷锟截★拷
        /// </summary>
        public ConfigService()
        {

            //LoadAll();
        }

        /// <summary>
        /// 同锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟节存（锟斤拷锟斤拷应锟侥硷拷锟斤拷锟斤拷锟节ｏ拷锟斤拷锟斤拷锟斤拷默锟较空硷拷锟斤拷/锟斤拷锟斤拷写锟斤拷锟侥硷拷锟斤拷锟斤拷
        /// 锟竭程帮拷全锟斤拷锟斤拷锟斤拷锟节诧拷锟皆癸拷锟斤拷锟斤拷源使锟斤拷 <see cref="_sync"/> 锟斤拷锟斤拷锟斤拷
        /// </summary>
        public void LoadAll()
        {
            lock (_sync)
            {
                // 锟斤拷取锟斤拷锟斤拷锟矫ｏ拷锟斤拷锟斤拷募锟斤拷锟斤拷锟斤拷冢锟斤拷虮３锟?DeviceConfig 默锟斤拷值
                if (File.Exists(ConfigPaths.CamerasConfigurationPath))
                    Cameras = FileHelper.ReadJsonFile<ObservableCollection<CameraInfo>>(ConfigPaths.CamerasConfigurationPath);
                else
                {
                    Cameras = new ObservableCollection<CameraInfo>();
                    FileHelper.WriteJsonFile(Cameras, ConfigPaths.CamerasConfigurationPath);
                }
                if (File.Exists(ConfigPaths.RobotsConfigurationPath))
                    Robots = FileHelper.ReadJsonFile<ObservableCollection<RobotInfo>>(ConfigPaths.RobotsConfigurationPath);
                else
                {
                    Robots = new ObservableCollection<RobotInfo>();
                    FileHelper.WriteJsonFile(Robots, ConfigPaths.RobotsConfigurationPath);
                }
                if (File.Exists(ConfigPaths.FeedersConfigurationPath))
                    Feeders = FileHelper.ReadJsonFile<ObservableCollection<FeederInfo>>(ConfigPaths.FeedersConfigurationPath);
                else
                {
                    Feeders = new ObservableCollection<FeederInfo>();
                    FileHelper.WriteJsonFile(Feeders, ConfigPaths.FeedersConfigurationPath);
                }

                // load screw feeders (material) configuration
                if (File.Exists(ConfigPaths.ScrewFeedersConfigurationPath))
                    ScrewFeeders = FileHelper.ReadJsonFile<ObservableCollection<ScrewFeederInfo>>(ConfigPaths.ScrewFeedersConfigurationPath);
                else
                {
                    ScrewFeeders = new ObservableCollection<ScrewFeederInfo>();
                    FileHelper.WriteJsonFile(ScrewFeeders, ConfigPaths.ScrewFeedersConfigurationPath);
                }

                if (File.Exists(ConfigPaths.PlcConfigurationPath))
                    Plcs = FileHelper.ReadJsonFile<ObservableCollection<PlcInfo>>(ConfigPaths.PlcConfigurationPath);
                else
                {
                    Plcs = new ObservableCollection<PlcInfo>();
                    FileHelper.WriteJsonFile(Plcs, ConfigPaths.PlcConfigurationPath);
                }
                if (File.Exists(ConfigPaths.BgTcpIpConfigurationPath))
                    BgCommunicate = FileHelper.ReadJsonFile<BgTcpIP>(ConfigPaths.BgTcpIpConfigurationPath);
                else
                {
                    BgCommunicate = new BgTcpIP();
                    FileHelper.WriteJsonFile(BgCommunicate, ConfigPaths.BgTcpIpConfigurationPath);
                }
                if (File.Exists(ConfigPaths.BgModbusTcpConfigurationPath))
                    BgModbusCommunicate = FileHelper.ReadJsonFile<BgModbusTcp>(ConfigPaths.BgModbusTcpConfigurationPath);
                else
                {
                    BgModbusCommunicate = new BgModbusTcp();
                    FileHelper.WriteJsonFile(BgModbusCommunicate, ConfigPaths.BgModbusTcpConfigurationPath);
                }
                if (!File.Exists(ConfigPaths.FeederClearanceTasksConfigurationPath))
                {
                    FeederClearanceTasks = new ObservableCollection<FeederClearWork>();
                    FileHelper.WriteJsonFile(FeederClearanceTasks, ConfigPaths.FeederClearanceTasksConfigurationPath);
                }
                else
                {
                    // 锟斤拷取 Feeder锟斤拷锟斤拷锟斤拷锟斤拷 锟斤拷锟斤拷
                    FeederClearanceTasks = FileHelper.ReadJsonFile<ObservableCollection<FeederClearWork>>(ConfigPaths.FeederClearanceTasksConfigurationPath);
                }

                // 锟斤拷取锟斤拷源锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
                if (!File.Exists(ConfigPaths.LightControllersConfigurationPath))
                {
                    LightControllers = new ObservableCollection<LightControllerConfig>();
                    FileHelper.WriteJsonFile(LightControllers, ConfigPaths.LightControllersConfigurationPath);
                }
                else
                {
                    LightControllers = FileHelper.ReadJsonFile<ObservableCollection<LightControllerConfig>>(ConfigPaths.LightControllersConfigurationPath);
                }
                // load plc addresses
                var plcAddressPath = "..//Config//PlcAddressConfiguration.cfg";
                if (File.Exists(plcAddressPath))
                    PlcAddressConfig = FileHelper.ReadJsonFile<PlcAddressConfig>(plcAddressPath);
                else
                {
                    PlcAddressConfig = new PlcAddressConfig();
                    PlcAddressConfig.SetDefaultValue();
                    FileHelper.WriteJsonFile(PlcAddressConfig, plcAddressPath);
                }

                // load screw driver config (single device)
                if (File.Exists(ConfigPaths.ScrewDriverConfigurationPath))
                    _screwDriverConfig = FileHelper.ReadJsonFile<TeamAAS_VP.Models.ScrewDriver.ScrewDriverConfig>(ConfigPaths.ScrewDriverConfigurationPath);
                else
                {
                    _screwDriverConfig = new TeamAAS_VP.Models.ScrewDriver.ScrewDriverConfig();
                    FileHelper.WriteJsonFile(_screwDriverConfig, ConfigPaths.ScrewDriverConfigurationPath);
                }

                // load device info list (鏀�寔澶氳�澶?
                if (File.Exists(ConfigPaths.DeviceInfoConfigurationPath))
                {
                    try
                    {
                        // 灏濊瘯浣滀负鍒楄〃璇诲彇
                        _deviceInfoList = FileHelper.ReadJsonFile<List<DeviceInfo>>(ConfigPaths.DeviceInfoConfigurationPath);
                    }
                    catch
                    {
                        // 鍏煎�鏃х増鍗曚釜 DeviceInfo锛屽皢鍏惰浆鎹�负鍒楄〃
                        var singleDevice = FileHelper.ReadJsonFile<DeviceInfo>(ConfigPaths.DeviceInfoConfigurationPath);
                        if (singleDevice != null)
                        {
                            singleDevice.DeviceNo = 0;
                            _deviceInfoList = new List<DeviceInfo> { singleDevice };
                        }
                        else
                        {
                            _deviceInfoList = new List<DeviceInfo> { new DeviceInfo { DeviceNo = 0 } };
                        }
                        FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
                    }
                }
                else
                {
                    _deviceInfoList = new List<DeviceInfo> { new DeviceInfo { DeviceNo = 0 } };
                    FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
                }

                // load card reader configuration
                if (File.Exists(ConfigPaths.CardReaderConfigurationPath))
                    _cardReaderConfig = FileHelper.ReadJsonFile<SerialPortConfig>(ConfigPaths.CardReaderConfigurationPath);
                else
                {
                    _cardReaderConfig = new SerialPortConfig();
                    FileHelper.WriteJsonFile(_cardReaderConfig, ConfigPaths.CardReaderConfigurationPath);
                }
            }
        }

        /// <summary>
        /// 锟届步执锟斤拷 <see cref="LoadAll"/> 锟斤拷锟斤拷锟斤拷
        /// </summary>
        /// <returns>锟斤拷示锟届步锟斤拷锟截诧拷锟斤拷锟斤拷锟斤拷锟斤拷</returns>
        public Task LoadAllAsync()
        {
            return Task.Run(() => LoadAll());
        }

        /// <summary>
        /// 锟斤拷锟节达拷锟叫碉拷锟斤拷锟斤拷锟斤拷锟斤拷写锟截碉拷锟斤拷应锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// 锟竭程帮拷全锟斤拷锟斤拷锟斤拷锟节诧拷锟斤拷写锟斤拷锟斤拷锟绞癸拷锟?<see cref="_sync"/> 锟斤拷锟斤拷锟斤拷
        /// </summary>
        public void SaveAll()
        {
            lock (_sync)
            {
                FileHelper.WriteJsonFile(Cameras, ConfigPaths.CamerasConfigurationPath);
                FileHelper.WriteJsonFile(Robots, ConfigPaths.RobotsConfigurationPath);
                FileHelper.WriteJsonFile(Feeders, ConfigPaths.FeedersConfigurationPath);
                FileHelper.WriteJsonFile(Plcs, ConfigPaths.PlcConfigurationPath);
                FileHelper.WriteJsonFile(BgCommunicate, ConfigPaths.BgTcpIpConfigurationPath);
                FileHelper.WriteJsonFile(BgModbusCommunicate, ConfigPaths.BgModbusTcpConfigurationPath);
                FileHelper.WriteJsonFile(FeederClearanceTasks, ConfigPaths.FeederClearanceTasksConfigurationPath);
                FileHelper.WriteJsonFile(LightControllers, ConfigPaths.LightControllersConfigurationPath);
                // save screw driver config
                if (_screwDriverConfig != null)
                    FileHelper.WriteJsonFile(_screwDriverConfig, ConfigPaths.ScrewDriverConfigurationPath);
                // save screw feeders
                if (ScrewFeeders != null)
                    FileHelper.WriteJsonFile(ScrewFeeders, ConfigPaths.ScrewFeedersConfigurationPath);
                // save plc addresses
                //FileHelper.WriteJsonFile(PlcAddressConfig, "..//Config//PlcAddressConfiguration.cfg");
                // save device info list (鏀�寔澶氳�澶?
                if (_deviceInfoList != null)
                    FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
                // save card reader config
                if (_cardReaderConfig != null)
                    FileHelper.WriteJsonFile(_cardReaderConfig, ConfigPaths.CardReaderConfigurationPath);
            }
        }

        /// <summary>
        /// 锟届步执锟斤拷 <see cref="SaveAll"/> 锟斤拷锟斤拷锟斤拷
        /// </summary>
        /// <returns>锟斤拷示锟届步锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟?/returns>
        public Task SaveAllAsync()
        {
            return Task.Run(() => SaveAll());
        }

        #region Cameras
        /// <summary>
        /// 锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷玫锟街伙拷锟斤拷锟斤拷稀锟?
        /// 锟竭程帮拷全锟斤拷锟斤拷锟节诧拷锟斤拷锟斤拷锟皆憋拷证锟斤拷锟斤拷锟斤拷取锟斤拷一锟斤拷锟皆★拷
        /// </summary>
        /// <returns>锟斤拷锟斤拷锟斤拷玫锟街伙拷锟斤拷锟斤拷稀锟?/returns>
        public IReadOnlyCollection<CameraInfo> GetAllCameras()
        {
            lock (_sync) { return Cameras.ToList().AsReadOnly(); }
        }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较�拷锟?
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟?Guid 锟斤拷识锟斤拷</param>
        /// <returns>锟揭碉拷锟津返回讹拷应锟斤拷 <see cref="CameraInfo"/>锟斤拷锟斤拷锟津返伙拷 <c>null</c>锟斤拷</returns>
        public CameraInfo GetCamera(Guid id)
        {
            lock (_sync) { return Cameras.FirstOrDefault(c => c.Id == id); }
        }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// - 锟斤拷锟斤拷锟斤拷 <paramref name="camera"/> 为 <c>null</c> 锟斤拷锟斤拷 <c>null</c>锟斤拷
        /// - 锟斤拷 Id 锟窖达拷锟斤拷锟斤拷锟芥换锟斤拷锟斤拷锟斤拷追锟接诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 CameraNo 锟斤拷拧锟?
        /// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷峤�拷锟斤拷锟斤拷锟较持久伙拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// </summary>
        /// <param name="camera">要锟斤拷锟接伙拷锟斤拷碌锟斤拷锟斤拷锟斤拷锟矫★拷</param>
        /// <returns>锟斤拷锟斤拷锟接伙拷锟斤拷碌锟?<see cref="CameraInfo"/>锟斤拷锟斤拷锟斤拷为 <c>null</c> 时锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        public CameraInfo AddOrUpdateCamera(CameraInfo camera)
        {
            if (camera == null) return null;
            lock (_sync)
            {
                var exist = Cameras.FirstOrDefault(c => c.Id == camera.Id);
                if (exist != null)
                {
                    var idx = Cameras.IndexOf(exist);
                    Cameras[idx] = camera;
                }
                else
                {
                    camera.CameraNo = Cameras.Count + 1;
                    Cameras.Add(camera);
                }
            }
            FileHelper.WriteJsonFile(Cameras, ConfigPaths.CamerasConfigurationPath);
            return camera;
        }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟狡筹拷锟斤拷锟斤拷锟斤拷貌锟斤拷锟斤拷卤锟斤拷剩锟斤拷锟斤拷锟斤拷锟?CameraNo锟斤拷
        /// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷峤�拷锟斤拷锟斤拷锟较持久伙拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// </summary>
        /// <param name="id">要锟狡筹拷锟斤拷锟斤拷锟?Guid锟斤拷</param>
        /// <returns>锟斤拷锟揭碉拷锟斤拷锟缴癸拷锟狡筹拷锟斤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool RemoveCamera(Guid id)
        {
            bool result = false;
            lock (_sync)
            {
                var exist = Cameras.FirstOrDefault(c => c.Id == id);
                if (exist != null) result = Cameras.Remove(exist);
                //锟斤拷锟铰憋拷锟?
                int no = 1;
                //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟紺ameraNo锟斤拷锟斤拷
                var sortedCameras = Cameras.OrderBy(c => c.CameraNo).ToList();
                foreach (var cam in sortedCameras)
                {
                    cam.CameraNo = no;
                    no++;
                }
                Cameras.Clear();
                foreach (var cam in sortedCameras)
                {
                    Cameras.Add(cam);
                }
            }
            FileHelper.WriteJsonFile(Cameras, ConfigPaths.CamerasConfigurationPath);
            return result;
        }

        /// <summary>
        /// 锟斤拷锟斤拷欠锟斤拷锟斤拷指锟斤拷 Id 锟斤拷锟斤拷锟斤拷锟斤拷谩锟?
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟?Guid锟斤拷</param>
        /// <returns>锟斤拷锟节凤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool ContainsCamera(Guid id) { lock (_sync) { return Cameras.Any(c => c.Id == id); } }
        #endregion

        #region DeviceInfo
        /// <summary>
        /// 鑾峰彇鎵€鏈夎�澶囦俊鎭�厤缃�垪琛?
        /// </summary>
        /// <returns>璁惧�淇℃伅鍒楄〃鐨勫彧璇婚泦鍚?/returns>
        public IReadOnlyCollection<DeviceInfo> GetAllDeviceInfos()
        {
            lock (_sync)
            {
                if (_deviceInfoList == null)
                {
                    if (File.Exists(ConfigPaths.DeviceInfoConfigurationPath))
                    {
                        try
                        {
                            _deviceInfoList = FileHelper.ReadJsonFile<List<DeviceInfo>>(ConfigPaths.DeviceInfoConfigurationPath);
                        }
                        catch
                        {
                            // 鍏煎�鏃х増鍗曚釜 DeviceInfo
                            var singleDevice = FileHelper.ReadJsonFile<DeviceInfo>(ConfigPaths.DeviceInfoConfigurationPath);
                            if (singleDevice != null)
                            {
                                singleDevice.DeviceNo = 0;
                                _deviceInfoList = new List<DeviceInfo> { singleDevice };
                            }
                            else
                            {
                                _deviceInfoList = new List<DeviceInfo> { new DeviceInfo { DeviceNo = 0 } };
                            }
                            FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
                        }
                    }
                    else
                    {
                        _deviceInfoList = new List<DeviceInfo> { new DeviceInfo { DeviceNo = 0 } };
                        FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
                    }
                }
                return _deviceInfoList.AsReadOnly();
            }
        }

        /// <summary>
        /// 鏍规嵁璁惧�缂栧彿鑾峰彇璁惧�淇℃伅锛堝吋瀹规棫API锛岃繑鍥炵�涓€涓��澶囷級
        /// </summary>
        /// <returns>璁惧�淇℃伅锛岃嫢涓嶅瓨鍦ㄥ垯鍒涘缓榛樿�璁惧�</returns>
        public DeviceInfo GetDeviceInfo()
        {
            return GetDeviceInfo(0);
        }

        /// <summary>
        /// 鏍规嵁璁惧�缂栧彿鑾峰彇璁惧�淇℃伅
        /// </summary>
        /// <param name="deviceNo">璁惧�缂栧彿</param>
        /// <returns>璁惧�淇℃伅锛岃嫢涓嶅瓨鍦ㄥ垯杩斿洖 null</returns>
        public DeviceInfo GetDeviceInfo(int deviceNo)
        {
            lock (_sync)
            {
                var allDevices = GetAllDeviceInfos();
                return allDevices.FirstOrDefault(d => d.DeviceNo == deviceNo);
            }
        }

        /// <summary>
        /// 娣诲姞鎴栨洿鏂拌�澶囦俊鎭?
        /// </summary>
        /// <param name="deviceInfo">璁惧�淇℃伅瀵硅薄</param>
        public void SaveDeviceInfo(DeviceInfo deviceInfo)
        {
            if (deviceInfo == null) return;
            lock (_sync)
            {
                // 纭�繚鍒楄〃宸插垵濮嬪寲
                if (_deviceInfoList == null)
                {
                    _deviceInfoList = new List<DeviceInfo>();
                }

                // 鏌ユ壘鏄�惁宸插瓨鍦ㄧ浉鍚岃�澶囩紪鍙风殑璁惧�
                var existing = _deviceInfoList.FirstOrDefault(d => d.DeviceNo == deviceInfo.DeviceNo);
                if (existing != null)
                {
                    // 鏇存柊鐜版湁璁惧�
                    var index = _deviceInfoList.IndexOf(existing);
                    _deviceInfoList[index] = deviceInfo;
                }
                else
                {
                    // 娣诲姞鏂拌�澶?
                    _deviceInfoList.Add(deviceInfo);
                }
                // 鎸夎�澶囩紪鍙锋帓搴?
                _deviceInfoList = _deviceInfoList.OrderBy(d => d.DeviceNo).ToList();
                FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
            }
        }

        /// <summary>
        /// 淇濆瓨鎵€鏈夎�澶囦俊鎭�垪琛?
        /// </summary>
        /// <param name="deviceInfoList">璁惧�淇℃伅鍒楄〃</param>
        public void SaveAllDeviceInfos(IEnumerable<DeviceInfo> deviceInfoList)
        {
            if (deviceInfoList == null) return;
            lock (_sync)
            {
                _deviceInfoList = deviceInfoList.OrderBy(d => d.DeviceNo).ToList();
                FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
            }
        }

        /// <summary>
        /// 娣诲姞鏂拌�澶?
        /// </summary>
        /// <returns>鏂版坊鍔犵殑璁惧�</returns>
        public DeviceInfo AddDeviceInfo()
        {
            lock (_sync)
            {
                if (_deviceInfoList == null)
                {
                    _deviceInfoList = new List<DeviceInfo>();
                }

                // 璁＄畻鏂拌�澶囩紪鍙?
                int newDeviceNo = _deviceInfoList.Count > 0 ? _deviceInfoList.Max(d => d.DeviceNo) + 1 : 0;
                var newDevice = new DeviceInfo { DeviceNo = newDeviceNo };
                _deviceInfoList.Add(newDevice);
                FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
                return newDevice;
            }
        }

        /// <summary>
        /// 鍒犻櫎璁惧�
        /// </summary>
        /// <param name="deviceNo">璁惧�缂栧彿</param>
        /// <returns>鏄�惁鍒犻櫎鎴愬姛</returns>
        public bool RemoveDeviceInfo(int deviceNo)
        {
            lock (_sync)
            {
                if (_deviceInfoList == null) return false;
                var device = _deviceInfoList.FirstOrDefault(d => d.DeviceNo == deviceNo);
                if (device != null)
                {
                    _deviceInfoList.Remove(device);
                    FileHelper.WriteJsonFile(_deviceInfoList, ConfigPaths.DeviceInfoConfigurationPath);
                    return true;
                }
                return false;
            }
        }
        #endregion

        #region Robots
        /// <summary>
        /// 锟斤拷取锟斤拷锟叫伙拷锟斤拷锟斤拷锟斤拷锟矫碉拷只锟斤拷锟斤拷锟较★拷
        /// </summary>
        /// <returns>锟斤拷锟斤拷锟斤拷锟斤拷锟矫碉拷只锟斤拷锟斤拷锟较★拷</returns>
        public IReadOnlyCollection<RobotInfo> GetAllRobots() { lock (_sync) { return Robots.ToList().AsReadOnly(); } }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟剿碉拷 Guid 锟斤拷识锟斤拷</param>
        /// <returns>锟揭碉拷锟津返回讹拷应锟斤拷 <see cref="RobotInfo"/>锟斤拷锟斤拷锟津返伙拷 <c>null</c>锟斤拷</returns>
        public RobotInfo GetRobot(Guid id) { lock (_sync) { return Robots.FirstOrDefault(r => r.Id == id); } }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷禄锟斤拷锟斤拷锟斤拷锟斤拷茫锟斤拷锟斤拷锟斤拷锟街久伙拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// 锟斤拷锟斤拷时为锟斤拷锟斤拷锟剿凤拷锟斤拷锟斤拷锟斤拷锟斤拷 RobotNo 锟斤拷拧锟?
        /// </summary>
        /// <param name="robot">要锟斤拷锟接伙拷锟斤拷碌幕锟斤拷锟斤拷锟斤拷锟斤拷谩锟?/param>
        /// <returns>锟斤拷锟斤拷锟接伙拷锟斤拷碌锟?<see cref="RobotInfo"/>锟斤拷锟斤拷锟斤拷为 <c>null</c> 时锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        public RobotInfo AddOrUpdateRobot(RobotInfo robot)
        {
            if (robot == null) return null;
            lock (_sync)
            {
                EnsureRobotPlcAxisParameters(robot);
                var exist = Robots.FirstOrDefault(r => r.Id == robot.Id);
                if (exist != null)
                {
                    var idx = Robots.IndexOf(exist);
                    Robots[idx] = robot;
                }
                else
                {
                    robot.RobotNo = Robots.Count + 1;
                    Robots.Add(robot);
                }

            }
            FileHelper.WriteJsonFile(Robots, ConfigPaths.RobotsConfigurationPath);
            return robot;
        }


        private static void EnsureRobotPlcAxisParameters(RobotInfo robot)
        {
            var axisNames = GetRobotAxisNames(robot.RobotBrand);
            if (axisNames == null) return;

            if (robot.PlcRobotParameter == null)
                robot.PlcRobotParameter = new PlcRobotParameter();

            var existingAxes = robot.PlcRobotParameter.AxixList ?? new List<Axis>();
            var axes = new List<Axis>();
            for (var i = 0; i < axisNames.Length; i++)
            {
                var axisName = axisNames[i];
                var defaultIndex = i + 1;
                var existingAxis = existingAxes.FirstOrDefault(a => string.Equals(a.Name, axisName, StringComparison.OrdinalIgnoreCase))
                                   ?? existingAxes.FirstOrDefault(a => a.Index == defaultIndex);
                var axisIndex = existingAxis != null && existingAxis.Index > 0 ? existingAxis.Index : defaultIndex;
                axes.Add(CreatePlcAxis(axisName, axisIndex));
            }

            robot.PlcRobotParameter.AxixList = axes;
        }

        private static string[] GetRobotAxisNames(RobotBrand robotBrand)
        {
            switch (robotBrand)
            {
                case RobotBrand.XYZ_Platform:
                    return new[] { "X", "Y", "Z" };
                case RobotBrand.XYZU_Platform:
                    return new[] { "X", "Y", "Z", "U" };
                case RobotBrand.XYZUR_Platform:
                    return new[] { "X", "Y", "Z", "U", "R" };
                case RobotBrand.XYZURWV_Platform:
                    return new[] { "X", "Y", "Z", "U", "R", "W", "V" };
                default:
                    return null;
            }
        }

        private static Axis CreatePlcAxis(string name, int index)
        {
            var axisPath = $"ns=4;s=DB_DriveControl|AxisCtrl[{index}]";
            return new Axis
            {
                Name = name,
                Index = index,
                Command = new AxisCommand
                {
                    PowerNode = $"{axisPath}.Cmd.Power",
                    StopNode = $"{axisPath}.Cmd.Stop",
                    ManuToHomeNode = $"{axisPath}.Cmd.ManuToHome",
                    AutoToHomeNode = $"{axisPath}.Cmd.AutoToHome",
                    ManuJogFowardNode = $"{axisPath}.Cmd.ManuJogFoward",
                    ManuJogBackwardNode = $"{axisPath}.Cmd.ManuJogBackward",
                    VelocityControlNode = $"{axisPath}.Cmd.VelocityControl",
                    VelocityChangeNode = $"{axisPath}.Cmd.VelocityChange",
                    AutoINCNode = $"{axisPath}.Cmd.AutoINC",
                    AutoABSNode = $"{axisPath}.Cmd.AutoABS",
                    TorqueNode = $"{axisPath}.Cmd.TeachOn",
                    PointSelectNode = $"{axisPath}.Cmd.PointSelect",
                    TeachOnNode = $"{axisPath}.Cmd.TeachOn",
                    TeachNode = $"{axisPath}.Cmd.Teach",
                    ManuPointNode = $"{axisPath}.Cmd.ManuPoint",
                    ManuPositionNode = $"{axisPath}.Cmd.ManuPosition"
                },
                Parameter = new AxisParameter
                {
                    ManuPositionNode = $"{axisPath}.Parm.ManuPosition",
                    ManuVelocityNode = $"{axisPath}.Parm.ManuVelocity",
                    VelModeVelocityNode = $"{axisPath}.Parm.VelModeVelocity",
                    CommentNode = $"{axisPath}.Parm.Comment"
                },
                State = new AxisState
                {
                    PowerOnNode = $"{axisPath}.Status.PowerON",
                    BusyNode = $"{axisPath}.Status.Busy",
                    PosOKNode = $"{axisPath}.Status.PosOK",
                    InitialedNode = $"{axisPath}.Status.Intialed",
                    PausedNode = $"{axisPath}.Status.Paused",
                    PosiNode = $"{axisPath}.Status.Posi",
                    NegaNode = $"{axisPath}.Status.Nega",
                    ErrorNode = $"{axisPath}.Status.Error",
                    ErrorIdNode = $"{axisPath}.Status.ErrorID",
                    ActPositionNode = $"{axisPath}.Status.ActPosition",
                    ActVelocityNode = $"{axisPath}.Status.ActVelocity",
                    ActTorqueNode = $"{axisPath}.Status.ActTorque",
                    StopPositionNode = $"{axisPath}.Status.StopPositon",
                    HmiPositionNode = $"{axisPath}.Status.HmiPosition",
                    SpTimeNode = $"{axisPath}.Status.SpTime",
                    StateNode = $"{axisPath}.Status.State"
                }
            };
        }


        /// <summary>
        /// 锟斤拷锟捷憋拷识锟狡筹拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫诧拷锟斤拷锟铰憋拷锟绞ｏ拷锟斤拷锟斤拷锟剿★拷
        /// 锟斤拷锟斤拷锟斤拷志没锟斤拷锟斤拷锟斤拷募锟斤拷锟?
        /// </summary>
        /// <param name="id">要锟狡筹拷锟侥伙拷锟斤拷锟斤拷 Guid锟斤拷</param>
        /// <returns>锟狡筹拷锟缴癸拷锟斤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool RemoveRobot(Guid id)
        {
            bool result = false;
            lock (_sync)
            {
                var e = Robots.FirstOrDefault(r => r.Id == id);
                if (e != null)
                    result = Robots.Remove(e);
                //锟斤拷锟铰憋拷锟?
                int no = 1;
                //锟斤拷锟斤拷锟叫伙拷锟斤拷锟剿帮拷RobotNo锟斤拷锟斤拷
                var sortedRobots = Robots.OrderBy(r => r.RobotNo).ToList();
                foreach (var r in sortedRobots)
                {
                    r.RobotNo = no;
                    no++;
                }
                Robots.Clear();
                foreach (var r in sortedRobots)
                {
                    Robots.Add(r);
                }
            }
            FileHelper.WriteJsonFile(Robots, ConfigPaths.RobotsConfigurationPath);
            return result;
        }

        /// <summary>
        /// 锟叫讹拷锟角凤拷锟斤拷锟街革拷锟?Id 锟侥伙拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟剿碉拷 Guid锟斤拷</param>
        /// <returns>锟斤拷锟节凤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool ContainsRobot(Guid id) { lock (_sync) { return Robots.Any(r => r.Id == id); } }

        /// <summary>
        /// 锟睫革拷指锟斤拷锟斤拷锟斤拷锟斤拷 Id锟侥诧拷锟斤拷锟斤拷锟诫并锟街久伙拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟斤拷唯一锟斤拷识锟斤拷锟斤拷</param>
        /// <param name="stepDistance">锟斤拷锟斤拷锟斤拷锟诫。</param>
        /// <returns>锟斤拷锟铰成癸拷锟斤拷锟斤拷 <c>true</c>锟斤拷锟揭诧拷锟斤拷锟斤拷锟斤拷锟剿凤拷锟斤拷 <c>false</c>锟斤拷</returns>
        public bool UpdateRobotStepDistance(Guid id, double stepDistance)
        {
            lock (_sync)
            {
                var robot = Robots.FirstOrDefault(r => r.Id == id);
                if (robot != null)
                {
                    robot.StepDistance = stepDistance;
                    FileHelper.WriteJsonFile(Robots, ConfigPaths.RobotsConfigurationPath);
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// 锟斤拷取指锟斤拷锟斤拷锟斤拷锟斤拷 Id 锟侥诧拷锟斤拷锟斤拷锟诫。
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟斤拷 Guid锟斤拷</param>
        /// <returns>锟斤拷锟揭碉拷锟津返回讹拷应锟侥诧拷锟斤拷锟斤拷锟诫，锟斤拷锟津返伙拷默锟斤拷值 1.0锟斤拷</returns>
        public double GetRobotStepDistance(Guid id)
        {
            lock (_sync)
            {
                var robot = Robots.FirstOrDefault(r => r.Id == id);
                if (robot != null)
                {
                    return robot.StepDistance;
                }
                else
                {
                    return 1.0;
                }
            }

        }

        #endregion

        #region Feeders
        /// <summary>
        /// 锟斤拷取锟斤拷锟叫癸拷锟斤拷锟斤拷锟斤拷锟矫碉拷只锟斤拷锟斤拷锟较★拷
        /// </summary>
        /// <returns>锟斤拷锟斤拷锟斤拷锟斤拷锟矫碉拷只锟斤拷锟斤拷锟较★拷</returns>
        public IReadOnlyCollection<FeederInfo> GetAllFeeders() { lock (_sync) { return Feeders.ToList().AsReadOnly(); } }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟斤拷锟斤拷 Guid 锟斤拷识锟斤拷</param>
        /// <returns>锟揭碉拷锟津返回讹拷应锟斤拷 <see cref="FeederInfo"/>锟斤拷锟斤拷锟津返伙拷 <c>null</c>锟斤拷</returns>
        public FeederInfo GetFeeder(Guid id) { lock (_sync) { return Feeders.FirstOrDefault(f => f.Id == id); } }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷鹿锟斤拷锟斤拷锟斤拷锟斤拷茫锟斤拷锟斤拷锟斤拷锟街久伙拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// 锟斤拷锟斤拷时为锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 FeederNo 锟斤拷拧锟?
        /// </summary>
        /// <param name="feeder">要锟斤拷锟接伙拷锟斤拷碌墓锟斤拷锟斤拷锟斤拷锟斤拷谩锟?/param>
        /// <returns>锟斤拷锟斤拷锟接伙拷锟斤拷碌锟?<see cref="FeederInfo"/>锟斤拷锟斤拷锟斤拷为 <c>null</c> 时锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        public FeederInfo AddOrUpdateFeeder(FeederInfo feeder)
        {
            if (feeder == null) return null;
            lock (_sync)
            {
                var exist = Feeders.FirstOrDefault(f => f.Id == feeder.Id);
                if (exist != null)
                {
                    var idx = Feeders.IndexOf(exist);
                    Feeders[idx] = feeder;
                }
                else
                {
                    feeder.FeederNo = Feeders.Count + 1;
                    Feeders.Add(feeder);
                }
            }
            FileHelper.WriteJsonFile(Feeders, ConfigPaths.FeedersConfigurationPath);
            return feeder;
        }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟狡筹拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫诧拷锟斤拷锟铰憋拷锟绞ｏ拷喙╋拷锟斤拷锟斤拷锟?
        /// 锟斤拷锟斤拷锟斤拷志没锟斤拷锟斤拷锟斤拷募锟斤拷锟?
        /// </summary>
        /// <param name="id">要锟狡筹拷锟侥癸拷锟斤拷锟斤拷 Guid锟斤拷</param>
        /// <returns>锟狡筹拷锟缴癸拷锟斤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool RemoveFeeder(Guid id)
        {
            bool result = false;
            lock (_sync)
            {
                var e = Feeders.FirstOrDefault(f => f.Id == id);
                if (e != null) result = Feeders.Remove(e);
                //锟斤拷锟铰憋拷锟?
                int no = 1;
                //锟斤拷锟斤拷锟叫癸拷锟斤拷锟斤拷锟斤拷FeederNo锟斤拷锟斤拷
                var sortedFeeders = Feeders.OrderBy(f => f.FeederNo).ToList();
                foreach (var f in sortedFeeders)
                {
                    f.FeederNo = no;
                    no++;
                }
                Feeders.Clear();
                foreach (var f in sortedFeeders)
                {
                    Feeders.Add(f);
                }

            }
            FileHelper.WriteJsonFile(Feeders, ConfigPaths.FeedersConfigurationPath);
            return result;
        }

        /// <summary>
        /// 锟叫讹拷锟角凤拷锟斤拷锟街革拷锟?Id 锟侥癸拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟斤拷 Guid锟斤拷</param>
        /// <returns>锟斤拷锟节凤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool ContainsFeeder(Guid id) { lock (_sync) { return Feeders.Any(f => f.Id == id); } }
        #endregion

        #region PLC
        /// <summary>
        /// 锟斤拷取锟斤拷锟斤拷 PLC 锟斤拷锟矫碉拷只锟斤拷锟斤拷锟较★拷
        /// </summary>
        /// <returns>PLC 锟斤拷锟矫碉拷只锟斤拷锟斤拷锟较★拷</returns>
        public IReadOnlyCollection<PlcInfo> GetAllPlcs() { lock (_sync) { return Plcs.ToList().AsReadOnly(); } }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟斤拷取锟斤拷锟斤拷 PLC 锟斤拷锟矫★拷
        /// </summary>
        /// <param name="id">PLC 锟斤拷 Guid 锟斤拷识锟斤拷</param>
        /// <returns>匹锟斤拷锟?<see cref="PlcInfo"/> 实锟斤拷锟斤拷锟揭诧拷锟斤拷锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        public PlcInfo GetPlc(Guid id) { lock (_sync) { return Plcs.FirstOrDefault(p => p.Id == id); } }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷锟?PLC 锟斤拷锟矫ｏ拷锟斤拷锟斤拷锟斤拷志没锟斤拷锟斤拷锟斤拷锟斤拷募锟斤拷锟斤拷锟斤拷锟绞憋拷锟斤拷锟斤拷锟斤拷锟?PlcNo 锟斤拷拧锟?
        /// </summary>
        /// <param name="plc">要锟斤拷锟接伙拷锟斤拷碌锟?PLC 锟斤拷锟矫★拷</param>
        /// <returns>锟斤拷锟斤拷锟接伙拷锟斤拷碌锟?<see cref="PlcInfo"/>锟斤拷锟斤拷锟斤拷为 <c>null</c> 时锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        public PlcInfo AddOrUpdatePlc(PlcInfo plc)
        {
            if (plc == null) return null;
            lock (_sync)
            {
                var exist = Plcs.FirstOrDefault(p => p.Id == plc.Id);
                if (exist != null)
                {
                    var idx = Plcs.IndexOf(exist);
                    Plcs[idx] = plc;
                }
                else
                {
                    plc.PlcNo = Plcs.Count + 1;
                    Plcs.Add(plc);
                }
            }
            FileHelper.WriteJsonFile(Plcs, ConfigPaths.PlcConfigurationPath);
            return plc;
        }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟狡筹拷 PLC 锟斤拷锟矫诧拷锟斤拷锟铰憋拷锟绞ｏ拷锟?PLC锟斤拷
        /// 锟斤拷锟斤拷锟斤拷志没锟斤拷锟斤拷锟斤拷募锟斤拷锟?
        /// </summary>
        /// <param name="id">要锟狡筹拷锟斤拷 PLC Guid锟斤拷</param>
        /// <returns>锟狡筹拷锟缴癸拷锟斤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool RemovePlc(Guid id)
        {
            bool result = false;
            lock (_sync)
            {
                var e = Plcs.FirstOrDefault(p => p.Id == id);
                if (e != null) result = Plcs.Remove(e);
                //锟斤拷锟铰憋拷锟?
                int no = 1;
                //锟斤拷锟斤拷锟斤拷PLC锟斤拷PlcNo锟斤拷锟斤拷
                var sortedPlcs = Plcs.OrderBy(p => p.PlcNo).ToList();
                foreach (var p in sortedPlcs)
                {
                    p.PlcNo = no;
                    no++;
                }
                Plcs.Clear();
                foreach (var p in sortedPlcs)
                {
                    Plcs.Add(p);
                }

            }
            FileHelper.WriteJsonFile(Plcs, ConfigPaths.PlcConfigurationPath);
            return result;
        }

        /// <summary>
        /// 锟叫讹拷锟角凤拷锟斤拷锟街革拷锟?Id 锟斤拷 PLC 锟斤拷锟矫★拷
        /// </summary>
        /// <param name="id">PLC 锟斤拷 Guid锟斤拷</param>
        /// <returns>锟斤拷锟节凤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool ContainsPlc(Guid id) { lock (_sync) { return Plcs.Any(p => p.Id == id); } }
        #endregion

        #region BgTcp
        /// <summary>
        /// 锟斤拷取 BG TCP/IP 通锟斤拷锟斤拷锟矫ｏ拷锟节达拷锟斤拷螅�锟斤拷锟轿?null锟斤拷锟斤拷
        /// </summary>
        /// <returns>锟斤拷前锟斤拷 <see cref="BgTcpIP"/> 锟斤拷锟矫讹拷锟斤拷</returns>
        public BgTcpIP GetBgTcp() { lock (_sync) { return BgCommunicate; } }

        /// <summary>
        /// 锟斤拷锟斤拷 BG TCP/IP 通锟斤拷锟斤拷锟矫ｏ拷锟斤拷锟斤拷锟斤拷锟节达拷锟斤拷螅�锟斤拷锟斤拷远锟斤拷志没锟斤拷锟斤拷锟?
        /// 锟斤拷锟斤拷志没锟斤拷锟斤拷锟斤拷 <see cref="SaveBgTcp"/>锟斤拷
        /// </summary>
        /// <param name="cfg">锟铰碉拷 <see cref="BgTcpIP"/> 锟斤拷锟矫讹拷锟斤拷</param>
        public void SetBgTcp(BgTcpIP cfg) { lock (_sync) { BgCommunicate = cfg; } }

        /// <summary>
        /// 锟斤拷锟斤拷前锟节达拷锟叫碉拷 BG TCP/IP 锟斤拷锟矫持久伙拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// </summary>
        public void SaveBgTcp() { lock (_sync) { FileHelper.WriteJsonFile(BgCommunicate, ConfigPaths.BgTcpIpConfigurationPath); } }
        #endregion

        #region BgModbus
        /// <summary>
        /// 锟斤拷取 BG Modbus TCP 通锟斤拷锟斤拷锟矫ｏ拷锟节达拷锟斤拷螅�锟?
        /// </summary>
        /// <returns>锟斤拷前锟斤拷 <see cref="BgModbusTcp"/> 锟斤拷锟矫讹拷锟斤拷</returns>
        public BgModbusTcp GetBgModbusTcp() { lock (_sync) { return BgModbusCommunicate; } }

        /// <summary>
        /// 锟斤拷锟斤拷 BG Modbus TCP 通锟斤拷锟斤拷锟矫ｏ拷锟斤拷锟斤拷锟斤拷锟节达拷锟斤拷螅�锟斤拷锟斤拷远锟斤拷志没锟斤拷锟斤拷锟?
        /// </summary>
        /// <param name="cfg">锟铰碉拷 <see cref="BgModbusTcp"/> 锟斤拷锟矫讹拷锟斤拷</param>
        public void SetBgModbusTcp(BgModbusTcp cfg) { lock (_sync) { BgModbusCommunicate = cfg; } }

        /// <summary>
        /// 锟斤拷锟斤拷前锟节达拷锟叫碉拷 BG Modbus TCP 锟斤拷锟矫持久伙拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// </summary>
        public void SaveBgModbusTcp() { lock (_sync) { FileHelper.WriteJsonFile(BgModbusCommunicate, ConfigPaths.BgModbusTcpConfigurationPath); } }
        #endregion

        #region CTQData
        /// <summary>
        /// 鑾峰彇CTQ淇℃伅閰嶇疆
        /// </summary>
        public CTQ_Data GetCTQDataInfo()
        {
            lock (_sync)
            {
                if (CtqData == null)
                {
                    if (File.Exists(ConfigPaths.DataConfigurationPath))
                        CtqData = FileHelper.ReadJsonFile<CTQ_Data>(ConfigPaths.DataConfigurationPath);
                    else
                    {
                        CtqData = new CTQ_Data();
                        FileHelper.WriteJsonFile(CtqData, ConfigPaths.DataConfigurationPath);
                    }
                }
                return CtqData;
            }
        }

        /// <summary>
        /// 淇濆瓨CTQ淇℃伅
        /// </summary>
        public void SaveCTQDataInfo(CTQ_Data cd)
        {
            if (cd == null) return;
            lock (_sync)
            {
                CtqData = cd;
                FileHelper.WriteJsonFile(CtqData, ConfigPaths.DataConfigurationPath);
            }
        }
        #endregion

        #region 系统锟斤拷锟斤拷
        /// <summary>
        /// 锟斤拷取系统锟斤拷锟矫ｏ拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷取锟斤拷锟斤拷
        /// 锟竭程帮拷全锟斤拷锟斤拷锟斤拷锟节诧拷锟斤拷锟斤拷锟皆憋拷证锟斤拷取一锟斤拷锟皆★拷
        /// </summary>
        /// <returns>锟斤拷取锟斤拷锟斤拷 <see cref="SystemConfiguration"/> 锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷锟斤拷锟津返伙拷默锟较碉拷锟斤拷实锟斤拷锟斤拷</returns>
        public SystemConfiguration GetSystemConfiguration()
        {
            lock (_sync)
            {
                var config = new SystemConfiguration();
                if (File.Exists(ConfigPaths.SystemConfigurationPath))
                {
                    config = FileHelper.ReadJsonFile<SystemConfiguration>(ConfigPaths.SystemConfigurationPath);
                }
                FileHelper.WriteJsonFile(config, ConfigPaths.SystemConfigurationPath);
                return config;
            }
        }

        /// <summary>
        /// 锟斤拷锟斤拷系统锟斤拷锟矫碉拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟结覆锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷
        /// </summary>
        /// <param name="systemConfiguration">要锟斤拷锟斤拷锟较低筹拷锟斤拷枚锟斤拷锟?/param>
        public void SaveSystemConfiguration(SystemConfiguration systemConfiguration)
        {
            lock (_sync)
            {
                FileHelper.WriteJsonFile(systemConfiguration, ConfigPaths.SystemConfigurationPath);
            }
        }

        /// <summary>
        /// 锟斤拷取锟斤拷前锟斤拷锟斤拷
        /// </summary>
        /// <returns></returns>
        public Language GetCurrentLanguage()
        {
            lock (_sync)
            {
                var config = GetSystemConfiguration();
                return config.CurrentLanguage;
            }
        }

        /// <summary>
        /// 锟斤拷锟矫碉拷前锟斤拷锟斤拷
        /// </summary>
        /// <param name="language"></param>
        public void SetCurrentLanguage(Language language)
        {
            lock (_sync)
            {
                var config = GetSystemConfiguration();
                config.CurrentLanguage = language;
                if (language == Enums.Language.ChineseSimplified)
                {
                    var culture = new CultureInfo("zh-CN");
                    App.Current.Dispatcher.Thread.CurrentCulture = culture;
                    App.Current.Dispatcher.Thread.CurrentUICulture = culture;
                    LocalizeDictionary.Instance.Culture = culture;
                    Lang.Culture = culture;
                    System.Windows.Application.Current.Resources["DefaultFont"] = new System.Windows.Media.FontFamily("Microsoft YaHei");
                }
                else if (language == Enums.Language.ChineseTraditional)
                {
                    var culture = new CultureInfo("zh-TW");
                    App.Current.Dispatcher.Thread.CurrentCulture = culture;
                    App.Current.Dispatcher.Thread.CurrentUICulture = culture;
                    LocalizeDictionary.Instance.Culture = culture;
                    Lang.Culture = culture;
                    System.Windows.Application.Current.Resources["DefaultFont"] = new System.Windows.Media.FontFamily("Microsoft YaHei");
                }
                else if (language == Enums.Language.English)
                {
                    var culture = new CultureInfo("en");
                    App.Current.Dispatcher.Thread.CurrentCulture = culture;
                    App.Current.Dispatcher.Thread.CurrentUICulture = culture;
                    LocalizeDictionary.Instance.Culture = culture;
                    Lang.Culture = culture;
                    System.Windows.Application.Current.Resources["DefaultFont"] = new System.Windows.Media.FontFamily("Segoe UI");
                }
                else if (language == Enums.Language.Japanese)
                {
                    var culture = new CultureInfo("ja-JP");
                    App.Current.Dispatcher.Thread.CurrentCulture = culture;
                    App.Current.Dispatcher.Thread.CurrentUICulture = culture;
                    LocalizeDictionary.Instance.Culture = culture;
                    Lang.Culture = culture;
                    System.Windows.Application.Current.Resources["DefaultFont"] = new System.Windows.Media.FontFamily("Segoe UI");
                }
                else if (language == Enums.Language.Vietnamese)
                {
                    var culture = new CultureInfo("vi");
                    App.Current.Dispatcher.Thread.CurrentCulture = culture;
                    App.Current.Dispatcher.Thread.CurrentUICulture = culture;
                    LocalizeDictionary.Instance.Culture = culture;
                    Lang.Culture = culture;
                    System.Windows.Application.Current.Resources["DefaultFont"] = new System.Windows.Media.FontFamily("Segoe UI");
                }
                SaveSystemConfiguration(config);
            }
        }
        #endregion

        #region Feeder锟斤拷锟斤拷锟斤拷锟斤拷
        /// <summary>
        /// 锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟街伙拷锟斤拷锟斤拷稀锟?
        /// </summary>
        /// <returns>锟斤拷锟斤拷锟斤拷锟斤拷锟街伙拷锟斤拷锟斤拷稀锟?/returns>
        public IReadOnlyCollection<FeederClearWork> GetAllClearanceTasks() { lock (_sync) { return FeederClearanceTasks.ToList().AsReadOnly(); } }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟绞蔽�拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟?TaskCode锟斤拷锟斤拷珊锟街久伙拷锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// </summary>
        /// <param name="task">要锟斤拷锟接伙拷锟斤拷碌锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷</param>
        /// <returns>锟斤拷锟斤拷锟接伙拷锟斤拷碌锟?<see cref="FeederClearWork"/>锟斤拷锟斤拷锟斤拷为 <c>null</c> 时锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        public FeederClearWork AddOrUpdateClearanceTask(FeederClearWork task)
        {
            if (task == null) return null;
            lock (_sync)
            {
                var exist = FeederClearanceTasks.FirstOrDefault(t => t.Id == task.Id);
                if (exist != null)
                {
                    var idx = FeederClearanceTasks.IndexOf(exist);
                    FeederClearanceTasks[idx] = task;
                }
                else
                {
                    // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷为锟斤拷前锟斤拷锟斤拷偶锟?
                    task.TaskCode = FeederClearanceTasks.Count > 0 ? FeederClearanceTasks.Max(t => t.TaskCode) + 1 : 1;
                    FeederClearanceTasks.Add(task);
                }
            }
            FileHelper.WriteJsonFile(FeederClearanceTasks, ConfigPaths.FeederClearanceTasksConfigurationPath);
            return task;
        }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟狡筹拷锟斤拷锟斤拷锟斤拷锟今并持久伙拷锟斤拷锟斤拷锟侥硷拷锟斤拷
        /// </summary>
        /// <param name="id">要锟狡筹拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 Guid锟斤拷</param>
        /// <returns>锟斤拷锟揭碉拷锟斤拷锟狡筹拷锟斤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool RemoveClearanceTask(Guid id)
        {
            lock (_sync)
            {
                var exist = FeederClearanceTasks.FirstOrDefault(t => t.Id == id);
                if (exist != null)
                {
                    FileHelper.WriteJsonFile(FeederClearanceTasks, ConfigPaths.FeederClearanceTasksConfigurationPath);
                    return FeederClearanceTasks.Remove(exist);
                }
                else
                    return false;
            }

        }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷癫⒊志没锟斤拷占锟斤拷系锟斤拷锟斤拷锟斤拷募锟斤拷锟?
        /// </summary>
        public void ClearAllClearanceTasks()
        {
            lock (_sync)
            {
                FeederClearanceTasks.Clear();
            }
            FileHelper.WriteJsonFile(FeederClearanceTasks, ConfigPaths.FeederClearanceTasksConfigurationPath);
        }

        /// <summary>
        /// 锟叫讹拷锟角凤拷锟斤拷锟街革拷锟?Id 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟斤拷锟斤拷 Guid锟斤拷</param>
        /// <returns>锟斤拷锟节凤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool ContainsClearanceTask(Guid id)
        {
            lock (_sync) { return FeederClearanceTasks.Any(t => t.Id == id); }

        }

        /// <summary>
        /// 锟斤拷锟捷憋拷识锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷息锟斤拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟斤拷锟斤拷 Guid锟斤拷</param>
        /// <returns>匹锟斤拷锟?<see cref="FeederClearWork"/>锟斤拷锟揭诧拷锟斤拷锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        public FeederClearWork GetClearanceTask(Guid id)
        {
            lock (_sync) { return FeederClearanceTasks.FirstOrDefault(t => t.Id == id); }
        }

        /// <summary>
        /// 锟叫讹拷锟角凤拷锟斤拷锟街革拷锟斤拷锟斤拷锟斤拷诺锟斤拷锟斤拷锟斤拷锟斤拷锟?
        /// </summary>
        /// <param name="taskNumber">锟斤拷锟斤拷锟脚ｏ拷TaskCode锟斤拷锟斤拷</param>
        /// <returns>锟斤拷锟节凤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool ContainsClearanceTaskByNumber(int taskNumber)
        {
            lock (_sync) { return FeederClearanceTasks.Any(t => t.TaskCode == taskNumber); }
        }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷锟脚伙拷取锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷息锟斤拷
        /// </summary>
        /// <param name="taskNumber">锟斤拷锟斤拷锟脚ｏ拷TaskCode锟斤拷锟斤拷</param>
        /// <returns>匹锟斤拷锟?<see cref="FeederClearWork"/>锟斤拷锟揭诧拷锟斤拷锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        public FeederClearWork GetClearanceTaskByNumber(int taskNumber)
        {
            lock (_sync) { return FeederClearanceTasks.FirstOrDefault(t => t.TaskCode == taskNumber); }
        }
        #endregion

        #region Light controllers and channels

        /// <summary>
        /// 锟斤拷取锟斤拷锟叫癸拷源锟斤拷锟斤拷锟斤拷锟斤拷锟矫碉拷只锟斤拷锟斤拷锟较★拷
        /// 锟竭程帮拷全锟斤拷锟斤拷锟节诧拷使锟斤拷 <see cref="_sync"/> 锟斤拷锟斤拷锟斤拷锟斤拷锟皆憋拷证锟斤拷锟斤拷锟斤拷锟绞帮拷全锟斤拷
        /// </summary>
        /// <returns>锟斤拷锟斤拷前锟节达拷锟叫存储顺锟津返回碉拷只锟斤拷 <see cref="LightControllerConfig"/> 锟斤拷锟较★拷</returns>
        public IReadOnlyCollection<LightControllerConfig> GetAllLightControllers()
        {
            lock (_sync) { return LightControllers.ToList().AsReadOnly(); }
        }

        /// <summary>
        /// 锟斤拷锟捷匡拷锟斤拷锟斤拷锟斤拷识锟斤拷取锟斤拷锟斤拷锟斤拷源锟斤拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// 锟竭程帮拷全锟斤拷锟矫凤拷锟斤拷锟斤拷锟节存集锟较斤拷锟斤拷只锟斤拷锟斤拷锟绞诧拷锟斤拷锟节诧拷锟斤拷锟斤拷锟斤拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷识锟斤拷Id锟斤拷锟斤拷</param>
        /// <returns>匹锟斤拷锟?<see cref="LightControllerConfig"/> 实锟斤拷锟斤拷锟揭诧拷锟斤拷锟津返伙拷 <c>null</c>锟斤拷</returns>
        public LightControllerConfig GetLightController(int id)
        {
            lock (_sync) { return LightControllers.FirstOrDefault(c => c.Id == id); }
        }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷鹿锟皆达拷锟斤拷锟斤拷锟斤拷锟斤拷谩锟?
        /// - 锟斤拷 <paramref name="controller"/> 为 <c>null</c> 锟斤拷锟斤拷 <c>null</c>锟斤拷
        /// - 锟斤拷锟斤拷时锟斤拷 Id 匹锟斤拷锟斤拷锟斤拷锟筋并锟芥换锟斤拷
        /// - 锟斤拷锟斤拷时锟斤拷锟斤拷锟斤拷锟斤拷锟侥匡拷锟斤拷锟斤拷 Id锟斤拷锟斤拷为锟斤拷锟斤拷锟斤拷锟节碉拷每锟斤拷通锟斤拷锟斤拷锟斤拷全锟斤拷通锟斤拷锟斤拷牛锟紾lobalIndex锟斤拷锟斤拷
        /// 锟竭程帮拷全锟斤拷锟斤拷锟节诧拷使锟斤拷 <see cref="_sync"/> 锟斤拷锟斤拷锟斤拷锟较★拷
        /// </summary>
        /// <param name="controller">要锟斤拷锟接伙拷锟斤拷碌锟?<see cref="LightControllerConfig"/> 实锟斤拷锟斤拷</param>
        /// <returns>锟斤拷锟斤拷锟接伙拷锟斤拷碌锟?<see cref="LightControllerConfig"/> 实锟斤拷锟斤拷锟斤拷锟斤拷为 <c>null</c> 时锟斤拷锟斤拷 <c>null</c>锟斤拷</returns>
        /// <exception cref="ArgumentException">锟斤拷要锟斤拷锟斤拷/锟斤拷锟铰的匡拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟截革拷时锟阶筹拷锟斤拷</exception>
        public LightControllerConfig AddOrUpdateLightController(LightControllerConfig controller)
        {
            if (controller == null) return null;
            lock (_sync)
            {
                // 锟斤拷锟狡诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟截革拷锟斤拷同锟斤拷锟斤拷锟斤拷同 Id 锟斤拷锟斤拷锟斤拷锟斤拷
                if (LightControllers.Any(c => c.Name == controller.Name && c.Id != controller.Id))
                    throw new ArgumentException("Controller name must be unique");

                var exist = LightControllers.FirstOrDefault(c => c.Id == controller.Id);
                if (exist != null)
                {
                    // 锟斤拷锟斤拷锟斤拷锟叫匡拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟芥换锟斤拷
                    var idx = LightControllers.IndexOf(exist);
                    LightControllers[idx] = controller;
                }
                else
                {
                    // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
                    // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷为锟斤拷前锟斤拷锟?Id + 1锟斤拷锟斤拷锟斤拷锟斤拷为锟斤拷锟斤拷为 1锟斤拷
                    controller.Id = LightControllers.Count > 0 ? LightControllers.Max(c => c.Id) + 1 : 1;

                    // 锟斤拷锟斤拷锟斤拷一锟斤拷全锟斤拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟窖达拷锟节匡拷锟斤拷锟斤拷锟斤拷通锟斤拷 GlobalIndex 锟斤拷取锟斤拷锟街碉拷锟斤拷锟?
                    int nextGlobal = 0;
                    if (LightControllers.SelectMany(c => c.ChannelConfigs).Any())
                    {
                        nextGlobal = LightControllers.SelectMany(c => c.ChannelConfigs).Max(ch => ch.GlobalIndex) + 1;
                    }

                    // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷通锟斤拷锟斤拷锟斤拷通锟斤拷锟斤拷 GlobalIndex 锟斤拷效锟斤拷<0锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷通锟斤拷锟斤拷突锟斤拷锟斤拷锟斤拷锟铰凤拷锟斤拷
                    for (int i = 0; i < controller.ChannelConfigs.Count; i++)
                    {
                        var ch = controller.ChannelConfigs[i];
                        if (ch.GlobalIndex < 0 || LightControllers.SelectMany(c => c.ChannelConfigs).Any(existingCh => existingCh.GlobalIndex == ch.GlobalIndex))
                        {
                            ch.GlobalIndex = nextGlobal;
                            nextGlobal++;
                        }
                    }

                    LightControllers.Add(controller);
                }
            }
            // 锟街久伙拷锟斤拷锟铰猴拷墓锟皆达拷锟斤拷锟斤拷锟斤拷锟斤拷锟?
            FileHelper.WriteJsonFile(LightControllers, ConfigPaths.LightControllersConfigurationPath);
            return controller;
        }

        /// <summary>
        /// 锟斤拷锟斤拷 Id 锟狡筹拷锟斤拷源锟斤拷锟斤拷锟斤拷锟斤拷锟矫诧拷锟斤拷剩锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷卤锟脚ｏ拷锟斤拷 1 锟斤拷始锟斤拷锟斤拷锟斤拷牛锟斤拷锟?
        /// 锟斤拷锟斤拷锟斤拷志没锟斤拷锟斤拷锟斤拷募锟斤拷锟?
        /// </summary>
        /// <param name="id">要锟狡筹拷锟侥匡拷锟斤拷锟斤拷 Id锟斤拷</param>
        /// <returns>锟斤拷锟斤拷晒锟斤拷瞥锟斤拷锟斤拷锟?<c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷锟斤拷锟斤拷未锟揭碉拷锟斤拷 Id锟斤拷锟斤拷</returns>
        public bool RemoveLightController(int id)
        {
            bool result = false;
            lock (_sync)
            {
                var e = LightControllers.FirstOrDefault(c => c.Id == id);
                if (e != null)
                    result = LightControllers.Remove(e);

                // 锟斤拷锟铰帮拷 Id 锟斤拷锟津并达拷 1 锟斤拷始锟斤拷锟铰憋拷牛锟斤拷员锟斤拷锟斤拷锟斤拷锟斤拷锟?
                int no = 1;
                var sorted = LightControllers.OrderBy(c => c.Id).ToList();
                foreach (var c in sorted)
                {
                    c.Id = no;
                    no++;
                }
                LightControllers.Clear();
                foreach (var c in sorted)
                {
                    LightControllers.Add(c);
                }
            }
            FileHelper.WriteJsonFile(LightControllers, ConfigPaths.LightControllersConfigurationPath);
            return result;
        }

        /// <summary>
        /// 锟叫讹拷锟角凤拷锟斤拷锟街革拷锟?Id 锟侥癸拷源锟斤拷锟斤拷锟斤拷锟斤拷
        /// </summary>
        /// <param name="id">锟斤拷锟斤拷锟斤拷 Id锟斤拷</param>
        /// <returns>锟斤拷锟节凤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool ContainsLightController(int id) { lock (_sync) { return LightControllers.Any(c => c.Id == id); } }

        /// <summary>
        /// 锟斤拷取锟斤拷锟叫癸拷源通锟斤拷锟斤拷只锟斤拷锟斤拷锟较ｏ拷锟斤拷 GlobalIndex 锟斤拷锟津返回★拷
        /// </summary>
        /// <returns>锟斤拷 GlobalIndex 锟斤拷锟斤拷锟?<see cref="ChannelConfig"/> 只锟斤拷锟斤拷锟较★拷</returns>
        public IReadOnlyCollection<ChannelConfig> GetAllLightChannels()
        {
            lock (_sync) { return LightControllers.SelectMany(c => c.ChannelConfigs).OrderBy(ch => ch.GlobalIndex).ToList().AsReadOnly(); }
        }

        /// <summary>
        /// 锟斤拷锟斤拷全锟斤拷通锟斤拷锟斤拷锟斤拷锟斤拷取锟斤拷锟斤拷通锟斤拷锟斤拷锟矫★拷
        /// </summary>
        /// <param name="globalIndex">通锟斤拷锟斤拷全锟斤拷锟斤拷锟斤拷锟斤拷GlobalIndex锟斤拷锟斤拷</param>
        /// <returns>匹锟斤拷锟?<see cref="ChannelConfig"/> 实锟斤拷锟斤拷锟揭诧拷锟斤拷锟津返伙拷 <c>null</c>锟斤拷</returns>
        public ChannelConfig GetLightChannelByGlobalIndex(int globalIndex)
        {
            lock (_sync) { return LightControllers.SelectMany(c => c.ChannelConfigs).FirstOrDefault(ch => ch.GlobalIndex == globalIndex); }
        }

        /// <summary>
        /// 锟叫讹拷锟角凤拷锟斤拷锟街革拷锟饺�拷锟酵�拷锟斤拷锟斤拷锟斤拷锟酵�拷锟斤拷锟斤拷谩锟?
        /// </summary>
        /// <param name="globalIndex">全锟斤拷通锟斤拷锟斤拷锟斤拷锟斤拷</param>
        /// <returns>锟斤拷锟节凤拷锟斤拷 <c>true</c>锟斤拷锟斤拷锟津返伙拷 <c>false</c>锟斤拷</returns>
        public bool ContainsLightChannelByGlobalIndex(int globalIndex)
        {
            lock (_sync) { return LightControllers.SelectMany(c => c.ChannelConfigs).Any(ch => ch.GlobalIndex == globalIndex); }
        }

        /// <summary>
        /// 锟斤拷锟斤拷指锟斤拷全锟斤拷通锟斤拷锟斤拷默锟斤拷锟斤拷锟饺ｏ拷DefaultBrightness锟斤拷锟斤拷锟斤拷锟街久伙拷锟斤拷源锟斤拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// </summary>
        /// <param name="globalIndex">目锟斤拷通锟斤拷锟斤拷全锟斤拷锟斤拷锟斤拷锟斤拷GlobalIndex锟斤拷锟斤拷</param>
        /// <param name="brightness">要锟斤拷锟矫碉拷锟斤拷锟斤拷值锟斤拷</param>
        /// <returns>锟斤拷锟铰成癸拷锟斤拷锟斤拷 <c>true</c>锟斤拷锟揭诧拷锟斤拷锟斤拷应通锟斤拷锟斤拷锟斤拷 <c>false</c>锟斤拷</returns>
        public bool UpdateChannelDefaultBrightness(int globalIndex, int brightness)
        {
            lock (_sync)
            {
                var ch = LightControllers.SelectMany(c => c.ChannelConfigs).FirstOrDefault(x => x.GlobalIndex == globalIndex);
                if (ch == null) return false;
                ch.DefaultBrightness = brightness;
                FileHelper.WriteJsonFile(LightControllers, ConfigPaths.LightControllersConfigurationPath);
                return true;
            }
        }

        #endregion

        #region Plc Addresses
        public PlcAddressConfig GetPlcAddresses() { lock (_sync) { return PlcAddressConfig; } }
        #endregion

        #region ScrewDriver config (single device)
        /// <summary>
        /// 锟斤拷取锟斤拷锟斤拷锟斤拷锟矫ｏ拷锟斤拷锟借备锟斤拷锟斤拷
        /// </summary>
        /// <returns>锟斤拷前锟斤拷 <see cref="ScrewDriverConfig"/>锟斤拷锟斤拷未锟斤拷锟斤拷锟津返伙拷 null锟斤拷</returns>
        public ScrewDriverConfig GetScrewDriverConfig()
        {
            lock (_sync) { return _screwDriverConfig; }
        }

        /// <summary>
        /// 锟斤拷锟矫诧拷锟街久伙拷锟斤拷锟斤拷锟斤拷锟矫ｏ拷锟斤拷锟借备锟斤拷锟斤拷
        /// </summary>
        /// <param name="cfg">锟铰碉拷锟斤拷锟矫讹拷锟襟，诧拷锟斤拷为锟秸★拷</param>
        public void SetScrewDriverConfig(ScrewDriverConfig cfg)
        {
            if (cfg == null) throw new ArgumentNullException(nameof(cfg));
            lock (_sync)
            {
                _screwDriverConfig = cfg;
                FileHelper.WriteJsonFile(_screwDriverConfig, ConfigPaths.ScrewDriverConfigurationPath);
            }
        }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷前锟节达拷锟叫的碉拷锟斤拷锟斤拷锟矫憋拷锟芥到锟侥硷拷锟斤拷
        /// </summary>
        public void SaveScrewDriverConfig()
        {
            lock (_sync)
            {
                if (_screwDriverConfig != null)
                    FileHelper.WriteJsonFile(_screwDriverConfig, ConfigPaths.ScrewDriverConfigurationPath);
            }
        }
        #endregion

        #region Screw Feeders (material)
        /// <summary>
        /// 锟斤拷取锟斤拷锟斤拷锟斤拷丝锟斤拷锟斤拷锟斤拷锟斤拷锟矫碉拷只锟斤拷锟斤拷锟较★拷
        /// </summary>
        public IReadOnlyCollection<ScrewFeederInfo> GetAllScrewFeeders() { lock (_sync) { return ScrewFeeders.ToList().AsReadOnly(); } }

        /// <summary>
        /// 锟斤拷锟斤拷 Id 锟斤拷取锟斤拷锟斤拷锟斤拷丝锟斤拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// </summary>
        public ScrewFeederInfo GetScrewFeeder(Guid id) { lock (_sync) { return ScrewFeeders.FirstOrDefault(s => s.Id == id); } }

        /// <summary>
        /// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟剿匡拷锟斤拷锟斤拷锟斤拷锟斤拷谩锟?
        /// 锟斤拷锟斤拷时锟斤拷未指锟斤拷 FeederNumber 锟斤拷锟斤拷锟轿�拷锟角帮拷锟斤拷锟?1锟斤拷
        /// </summary>
        public ScrewFeederInfo AddOrUpdateScrewFeeder(ScrewFeederInfo feeder)
        {
            if (feeder == null) return null;
            lock (_sync)
            {
                var exist = ScrewFeeders.FirstOrDefault(f => f.Id == feeder.Id);
                if (exist != null)
                {
                    var idx = ScrewFeeders.IndexOf(exist);
                    ScrewFeeders[idx] = feeder;
                }
                else
                {
                    if (feeder.FeederNumber <= 0) feeder.FeederNumber = ScrewFeeders.Count + 1;
                    ScrewFeeders.Add(feeder);
                }
                FileHelper.WriteJsonFile(ScrewFeeders, ConfigPaths.ScrewFeedersConfigurationPath);
            }
            return feeder;
        }

        /// <summary>
        /// 锟狡筹拷锟斤拷丝锟斤拷锟斤拷锟斤拷锟斤拷锟矫★拷
        /// </summary>
        public bool RemoveScrewFeeder(Guid id)
        {
            bool result = false;
            lock (_sync)
            {
                var e = ScrewFeeders.FirstOrDefault(s => s.Id == id);
                if (e != null) result = ScrewFeeders.Remove(e);
            }
            FileHelper.WriteJsonFile(ScrewFeeders, ConfigPaths.ScrewFeedersConfigurationPath);
            return result;
        }

        public bool ContainsScrewFeeder(Guid id) { lock (_sync) { return ScrewFeeders.Any(s => s.Id == id); } }

        // event for low level alarm
        public event Action<ScrewFeederInfo> ScrewFeederLowLevelAlarmTriggered;

        /// <summary>
        /// 锟斤拷取指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷诺锟绞ｏ拷锟斤拷锟剿匡拷锟斤拷锟斤拷锟斤拷也锟斤拷锟斤拷锟斤拷锟?-1锟斤拷
        /// </summary>
        public int GetRemainingCountByFeederNumber(int feederNumber)
        {
            lock (_sync)
            {
                var f = ScrewFeeders.FirstOrDefault(s => s.FeederNumber == feederNumber);
                if (f == null) return -1;
                return f.RemainingCount;
            }
        }

        /// <summary>
        /// 锟斤拷取指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷诺牡锟斤拷锟斤拷锟斤拷锟阶刺�拷锟斤拷也锟斤拷锟斤拷锟斤拷锟?false锟斤拷
        /// </summary>
        public bool GetLowLevelAlarmStatusByFeederNumber(int feederNumber)
        {
            lock (_sync)
            {
                var f = ScrewFeeders.FirstOrDefault(s => s.FeederNumber == feederNumber);
                if (f == null) return false;
                return f.IsLowLevelAlarmActive;
            }
        }

        // helper: check and raise low level alarm when necessary
        private void CheckAndTriggerLowLevelAlarm(ScrewFeederInfo f)
        {
            if (f == null) return;
            if (f.LowLevelAlarmEnabled && f.RemainingCount <= f.LowLevelThreshold)
            {
                if (!f.IsLowLevelAlarmActive)
                {
                    f.IsLowLevelAlarmActive = true;
                    try
                    {
                        ScrewFeederLowLevelAlarmTriggered?.Invoke(f.Clone());
                    }
                    catch { }
                }
            }
            else
            {
                if (f.IsLowLevelAlarmActive)
                {
                    f.IsLowLevelAlarmActive = false;
                }
            }
        }

        /// <summary>
        /// 为指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷诺菁锟街革拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷惴碉拷锟?-1
        /// </summary>
        public int DecrementScrewCountByFeederNumber(int feederNumber, int decrement = 1)
        {
            lock (_sync)
            {
                var f = ScrewFeeders.FirstOrDefault(s => s.FeederNumber == feederNumber);
                if (f == null) return -1;
                if (decrement <= 0) decrement = 1;
                if (f.RemainingCount < decrement) return -1;
                f.RemainingCount -= decrement;
                // check alarm
                CheckAndTriggerLowLevelAlarm(f);
                FileHelper.WriteJsonFile(ScrewFeeders, ConfigPaths.ScrewFeedersConfigurationPath);
                return f.RemainingCount;
            }
        }

        /// <summary>
        /// 锟斤拷锟街革拷锟斤拷锟斤拷锟斤拷锟斤拷锟脚碉拷锟斤拷丝锟斤拷息锟斤拷锟斤拷锟轿猴拷锟矫空ｏ拷剩锟斤拷锟斤拷锟斤拷锟斤拷0锟斤拷
        /// </summary>
        public void ClearScrewFeederByNumber(int feederNumber)
        {
            lock (_sync)
            {
                var f = ScrewFeeders.FirstOrDefault(s => s.FeederNumber == feederNumber);
                if (f == null) return;
                f.BatchNumber = string.Empty;
                f.RemainingCount = 0;
                // check alarm
                CheckAndTriggerLowLevelAlarm(f);
                FileHelper.WriteJsonFile(ScrewFeeders, ConfigPaths.ScrewFeedersConfigurationPath);
            }
        }

        /// <summary>
        /// 为指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷魏牛锟斤拷锟斤拷锟皆�拷锟绞ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟揭伙拷锟斤拷锟絇ackSize锟斤拷
        /// </summary>
        public void SetBatchForFeederNumber(int feederNumber, string batchNumber)
        {
            if (string.IsNullOrWhiteSpace(batchNumber)) return;

            //锟斤拷取锟斤拷前锟侥诧拷锟斤拷员锟矫伙拷锟斤拷
            string operatorName = _systemDatabaseService.GetCurrentUser()?.UserName;

            // capture values under lock, then record to DB outside lock
            ScrewFeederInfo target = null;
            int remainingAfter = 0;
            int packSize = 0;
            string feederName = null;
            int previousCount = 0;
            lock (_sync)
            {
                var f = ScrewFeeders.FirstOrDefault(s => s.FeederNumber == feederNumber);
                if (f == null) return;
                f.BatchNumber = batchNumber;
                previousCount = f.RemainingCount;
                f.RemainingCount += Math.Max(0, f.PackSize);

                // prepare capture values
                target = f;
                remainingAfter = f.RemainingCount;
                packSize = f.PackSize;
                feederName = f.Name;

                // check alarm
                CheckAndTriggerLowLevelAlarm(f);
                FileHelper.WriteJsonFile(ScrewFeeders, ConfigPaths.ScrewFeedersConfigurationPath);
            }

            try
            {
                var record = new ScrewFeederBatchRecord
                {
                    BatchNumber = batchNumber,
                    PackSize = packSize,
                    ChangeTime = DateTime.Now,
                    RemainingCount = remainingAfter,
                    FeederNumber = feederNumber,
                    FeederName = feederName,
                    PreviousCount = previousCount,
                    OperatorName = operatorName,
                };

                // try get operator name from system database service if available
                try
                {
                    var user = _systemDatabaseService?.GetCurrentUser();
                    if (user != null)
                        record.OperatorName = user.UserName;
                }
                catch
                {
                    // ignore getting user failure
                }

                try
                {
                    if (_systemDatabaseService != null)
                    {
                        _ = _systemDatabaseService.RecordScrewFeederBatchAsync(record);
                    }
                }
                catch
                {
                    // 锟斤拷锟斤拷锟斤拷锟捷匡拷写锟斤拷锟斤拷螅�锟铰硷拷锟斤拷锟斤拷锟斤拷锟街?
                }
            }
            catch
            {
                // ignore any error creating/recording the batch record
            }
        }

        /// <summary>
        /// 锟斤拷锟绞ｏ拷锟斤拷锟剿匡拷欠癖ň锟?
        /// </summary>
        public bool CheckAlarm(int feederNumber)
        {
            lock (_sync)
            {
                var f = ScrewFeeders.FirstOrDefault(s => s.FeederNumber == feederNumber);
                if (f == null) return false;
                // check alarm
                CheckAndTriggerLowLevelAlarm(f);
                return f.IsLowLevelAlarmActive;
            }
        }
        #endregion

        #region 锟矫伙拷锟斤拷录刷锟斤拷锟斤拷
        /// <summary>
        /// 锟斤拷取刷锟斤拷锟斤拷锟斤拷锟斤拷
        /// </summary>
        /// <returns></returns>
        public SerialPortConfig GetCardReaderConfig()
        {
            lock (_sync)
            {
                if (_cardReaderConfig != null)
                    return _cardReaderConfig;

                if (File.Exists(ConfigPaths.CardReaderConfigurationPath))
                {
                    try
                    {
                        _cardReaderConfig = FileHelper.ReadJsonFile<SerialPortConfig>(ConfigPaths.CardReaderConfigurationPath);
                    }
                    catch
                    {
                        // 锟斤拷锟斤拷取失锟杰ｏ拷锟斤拷锟斤拷默锟斤拷锟斤拷锟矫诧拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷锟斤拷目锟斤拷锟斤拷锟斤拷锟斤拷锟矫诧拷锟斤拷一锟铰ｏ拷
                        _cardReaderConfig = new SerialPortConfig();
                        try { FileHelper.WriteJsonFile(_cardReaderConfig, ConfigPaths.CardReaderConfigurationPath); } catch { }
                    }
                }
                else
                {
                    _cardReaderConfig = new SerialPortConfig();
                    try { FileHelper.WriteJsonFile(_cardReaderConfig, ConfigPaths.CardReaderConfigurationPath); } catch { }
                }

                return _cardReaderConfig;
            }
        }

        /// <summary>
        /// 锟斤拷锟斤拷刷锟斤拷锟斤拷锟斤拷锟斤拷
        /// </summary>
        /// <param name="config"></param>
        public void SaveCardReaderConfig(SerialPortConfig config)
        {
            if (config == null) return;
            lock (_sync)
            {
                _cardReaderConfig = config;
                try
                {
                    FileHelper.WriteJsonFile(_cardReaderConfig, ConfigPaths.CardReaderConfigurationPath);
                }
                catch
                {
                    // 锟斤拷锟皆持久伙拷锟斤拷锟斤拷锟斤拷锟斤拷目锟斤拷锟斤拷锟斤拷锟斤拷锟芥方锟斤拷一锟铰ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷要时锟斤拷锟斤拷锟斤拷志锟斤拷录
                }
            }
        }



        #endregion

        #region 锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷
        public void SaveTorqueReaderConfig(TorqueSerialPortConfig config)
        {
            if (config == null) return;
            lock (_sync)
            {
                _torqueReaderConfig = config;
                try
                {
                    FileHelper.WriteJsonFile(_torqueReaderConfig, ConfigPaths.TorqueReaderConfigurationPath);
                }
                catch
                {
                    // 锟斤拷锟皆持久伙拷锟斤拷锟斤拷锟斤拷锟斤拷目锟斤拷锟斤拷锟斤拷锟斤拷锟芥方锟斤拷一锟铰ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷要时锟斤拷锟斤拷锟斤拷志锟斤拷录
                }
            }
        }

        public TorqueSerialPortConfig GetTorqueReaderConfig()
        {
            lock (_sync)
            {
                if (_torqueReaderConfig != null)
                    return _torqueReaderConfig;

                if (File.Exists(ConfigPaths.TorqueReaderConfigurationPath))
                {
                    try
                    {
                        _torqueReaderConfig = FileHelper.ReadJsonFile<TorqueSerialPortConfig>(ConfigPaths.TorqueReaderConfigurationPath);
                    }
                    catch
                    {
                        // 锟斤拷锟斤拷取失锟杰ｏ拷锟斤拷锟斤拷默锟斤拷锟斤拷锟矫诧拷锟斤拷锟斤拷锟侥硷拷锟斤拷锟斤拷锟斤拷目锟斤拷锟斤拷锟斤拷锟斤拷锟矫诧拷锟斤拷一锟铰ｏ拷
                        _torqueReaderConfig = new TorqueSerialPortConfig();
                        try { FileHelper.WriteJsonFile(_torqueReaderConfig, ConfigPaths.TorqueReaderConfigurationPath); } catch { }
                    }
                }
                else
                {
                    _torqueReaderConfig = new TorqueSerialPortConfig();
                    try { FileHelper.WriteJsonFile(_torqueReaderConfig, ConfigPaths.TorqueReaderConfigurationPath); } catch { }
                }

                return _torqueReaderConfig;
            }
        }

        #endregion

        /// <summary>
        /// 锟酵凤拷锟斤拷源锟斤拷锟斤拷锟芥当前锟节达拷锟叫碉拷锟斤拷锟斤拷锟斤拷锟矫碉拷锟侥硷拷锟斤拷
        /// </summary>
        public void Dispose()
        {
            SaveAll();
            GC.SuppressFinalize(this);
        }
    }
}