Display_D_HP/TeamAAS-VM/Services/ProductService.cs

using Cognex.VisionPro;
using Cognex.VisionPro.ToolBlock;
using Newtonsoft.Json;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Documents;
using Team.FFFeederService.Interfaces;
using TeamAAS_VP.Core;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Models.Product;

namespace TeamAAS_VP.Services
{
    /// <summary>
    /// 产品管理服务。
    /// 负责在内存中维护产品集合、加载/保存产品到磁盘、产品的增删改查、相机/机器人相关变更的级联更新等操作。
    /// 线程安全：使用 `_sync` 对共享字典 `_products` 的访问进行保护。
    /// 产品文件存放遵循约定目录：`ProductsRootPath\{ProductName}\{ProductName}.cfg`，视觉流程文件为 `.vpp`。
    /// </summary>
    public class ProductService : IProductService
    {
        private readonly Dictionary<Guid, ProductModel> _products = new Dictionary<Guid, ProductModel>();
        private readonly object _sync = new object();
        private Guid _currentProduct = Guid.Empty;
        IConfigService _configService;
        IFeederService _feederService;

        // 可配置的路径与文件名
        // 默认把产品放到公共应用数据目录下的 TeamAAS\Products
        /// <summary>
        /// 默认产品路径的相对子目录（相对于应用运行目录或配置指定的根）。
        /// </summary>
        public const string DefaultProductsSubPath = "..//Products";

        /// <summary>
        /// 模板 ToolBlock 的默认路径，用于在产品不存在视觉工具文件时进行初始化。
        /// </summary>
        public const string TemplateToolBlock = "..//Vision Template//TemplateToolBlock.vpp";

        /// <summary>
        /// 产品模板文件夹路径（用于通过模板创建新产品）。
        /// </summary>
        public const string ProductTemplatePath = "..//Product Template";

        /// <summary>
        /// 产品根目录（可配置）。默认值为 <see cref="DefaultProductsSubPath"/>.
        /// 每个产品在该目录下以其 Name 为子文件夹保存其配置与视觉文件。
        /// </summary>
        public string ProductsRootPath { get; set; }

        /// <summary>
        /// 当当前产品切换时触发的事件，参数为新的当前 <see cref="ProductModel"/> 实例。
        /// </summary>
        public event Action<ProductModel> OnProductChanged;

        /// <summary>
        /// 构造函数。
        /// </summary>
        /// <param name="configService">系统配置服务，用于读取/保存最近打开的产品等系统配置。</param>
        /// <param name="feederService">料斗服务，当前保存但未直接在本类中使用（保留用于扩展）。</param>
        public ProductService(IConfigService configService, IFeederService feederService)
        {
            _configService = configService;
            _feederService = feederService;
            ProductsRootPath = DefaultProductsSubPath;
        }

        /// <summary>
        /// 初始化服务：清空内存产品并从磁盘枚举并加载产品清单（仅读取 JSON 配置，不加载所有视觉 ToolBlock）。
        /// </summary>
        /// <returns>初始化是否成功（始终返回 true，除非抛出未捕获异常）。</returns>
        public bool Initialize()
        {
            // 清空现有产品
            RemoveAllProducts();

            // 获取所有产品列表
            var productList = GetAllProductList();
            lock (_sync)
            {
                foreach (var (id, name, filePath) in productList)
                {
                    var product = LoadProduct(filePath);
                    if (product != null)
                    {
                        _products[id] = product;
                    }
                }
            }
            return true;
        }

        /// <summary>
        /// 异步初始化服务。
        /// </summary>
        /// <returns>异步任务，完成时返回初始化结果。</returns>
        public Task<bool> InitializeAsync()
        {
            return Task.Run(() => Initialize());

        }

        /// <summary>
        /// 获取本地所有产品的元信息列表（ID、名称、配置文件路径）。
        /// </summary>
        /// <returns>返回一个元组集合，每项包含产品 ID、名称和对应的配置文件路径。</returns>
        public IEnumerable<(Guid id,string name,string filePath)> GetAllProductList()
        {
            if (!Directory.Exists(ProductsRootPath))
            {
                Directory.CreateDirectory(ProductsRootPath);
            }
            //在产品目录下有一个ProductList.cfg文件，里面保存了所有产品的ID和名称
            string productListFilePath = Path.Combine(ProductsRootPath, "ProductList.cfg");
            if (!File.Exists(productListFilePath))
            {
                return Enumerable.Empty<(Guid id, string name, string filePath)>();
            }
            // 读取文件内容，这是一个Json文件，里面保存了所有产品的ID和名称
            Dictionary<Guid, string> list = FileHelper.ReadJsonFile<Dictionary<Guid, string>>(productListFilePath);
            var result = new List<(Guid id, string name, string filePath)>();
            foreach (var kvp in list)
            {
                var id = kvp.Key;
                var name = kvp.Value;
                //产品路径为：ProductsRootPath//kvp.Value//kvp.Value.cfg
                var filePath = Path.Combine(ProductsRootPath, name, name + ".cfg");
                result.Add((id, name, filePath));
            }
            return result;
        }

        /// <summary>
        /// 将当前内存中的产品清单保存到磁盘（ProductList.cfg）。
        /// </summary>
        public void SaveProductList()
        {
            if (!Directory.Exists(ProductsRootPath))
            {
                Directory.CreateDirectory(ProductsRootPath);
            }
            //在产品目录下有一个ProductList.cfg文件，里面保存了所有产品的ID和名称
            string productListFilePath = Path.Combine(ProductsRootPath, "ProductList.cfg");
            Dictionary<Guid, string> list = new Dictionary<Guid, string>();
            lock (_sync)
            {
                foreach (var kvp in _products)
                {
                    list[kvp.Key] = kvp.Value.Name;
                }
            }

            // 保存为Json文件
            FileHelper.WriteJsonFile(list, productListFilePath);
        }

        /// <summary>
        /// 异步保存产品清单到磁盘。
        /// </summary>
        /// <returns>表示异步操作的任务。</returns>
        public Task SaveProductListAsync()
        {
            return Task.Run(() => SaveProductList());
        }

        /// <summary>
        /// 在内存中创建并注册一个新产品，同时将其保存到磁盘。
        /// </summary>
        /// <param name="product">要创建的产品模型。若其 ID 为空则会分配新的 GUID。</param>
        /// <returns>若名称冲突则返回 false；否则返回 true 表示创建成功。</returns>
        /// <exception cref="ArgumentNullException">当 <paramref name="product"/> 为 null 时抛出。</exception>
        public bool CreateProduct(ProductModel product)
        {
            if (product == null) throw new ArgumentNullException(nameof(product));
            //如果当前存在同名产品，则创建失败
            lock (_sync)
            {
                if (_products.Values.Any(p => p.Name == product.Name))
                {
                    return false;
                }
            }

            //对产品的编号进行自增
            lock (_sync)
            {
                if (_products.Count == 0)
                {
                    product.NumberCode = 1;
                }
                else
                {
                    product.NumberCode = _products.Values.Max(p => p.NumberCode) + 1;
                }
            }

            if (product.ID == Guid.Empty) product.ID = Guid.NewGuid();

            lock (_sync)
            {
                _products[product.ID] = product;
            }

            //保存产品清单
            SaveProductList();

            // 创建后自动保存到磁盘
            SaveProduct(product.ID);

            return true;
        }

        /// <summary>
        /// 异步创建产品。
        /// </summary>
        /// <param name="product">产品模型。</param>
        /// <returns>异步任务，结果为创建是否成功。</returns>
        public Task<bool> CreateProductAsync(ProductModel product)
        {
            return Task.Run(() => CreateProduct(product));
        }

        /// <summary>
        /// 根据 ID 获取内存中的产品模型（同步）。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>对应的 <see cref="ProductModel"/>，若不存在则返回 null。</returns>
        public ProductModel GetProduct(Guid id)
        {
            lock (_sync)
            {
                _products.TryGetValue(id, out var p);
                return p;
            }
        }

        /// <summary>
        /// 异步获取指定 ID 的产品（仅包装同步方法）。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>包含产品模型的任务。</returns>
        public Task<ProductModel> GetProductAsync(Guid id)
        {
            var p = GetProduct(id);
            return Task.FromResult(p);
        }

        /// <summary>
        /// 获取当前服务内存中所有产品的只读集合。
        /// </summary>
        /// <returns>只读的产品集合。</returns>
        public IReadOnlyCollection<ProductModel> GetAllProducts()
        {
            lock (_sync)
            {
                return _products.Values.ToList().AsReadOnly();
            }
        }

        /// <summary>
        /// 异步获取所有产品（包装同步实现）。
        /// </summary>
        /// <returns>包含只读产品集合的任务。</returns>
        public Task<IReadOnlyCollection<ProductModel>> GetAllProductsAsync()
        {
            var list = GetAllProducts();
            return Task.FromResult(list);
        }

        /// <summary>
        /// 尝试从内存中获取指定 ID 的产品。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <param name="product">输出参数，若找到则为对应产品，否则为 null。</param>
        /// <returns>若找到返回 true，否则返回 false。</returns>
        public bool TryGetProduct(Guid id, out ProductModel product)
        {
            lock (_sync)
            {
                return _products.TryGetValue(id, out product);
            }
        }

        /// <summary>
        /// 异步尝试获取产品。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>任务，结果为 (found, product) 二元组。</returns>
        public Task<(bool found, ProductModel product)> TryGetProductAsync(Guid id)
        {
            ProductModel p;
            bool f;
            lock (_sync)
            {
                f = _products.TryGetValue(id, out p);
            }
            return Task.FromResult((f, p));
        }

        /// <summary>
        /// 判断内存中是否包含指定 ID 的产品。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>存在返回 true，否则 false。</returns>
        public bool ContainsProduct(Guid id)
        {
            lock (_sync)
            {
                return _products.ContainsKey(id);
            }
        }

        /// <summary>
        /// 异步判断产品是否存在（包装同步实现）。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>包含结果的任务。</returns>
        public Task<bool> ContainsProductAsync(Guid id)
        {
            var v = ContainsProduct(id);
            return Task.FromResult(v);
        }

        /// <summary>
        /// 判断服务中是否包含指定名称的产品（同步）。
        /// </summary>
        /// <param name="name">产品的名称</param>
        /// <returns>若包含则返回 true；否则返回 false。</returns>
        public bool ContainsProductByName(string name)
        {

            lock (_sync)
            {
                return _products.Values.Any(p => p.Name == name);
            }
        }

        /// <summary>
        /// 判断服务中是否包含指定名称的产品（异步）。
        /// </summary>
        /// <param name="name">产品的名称</param>
        /// <returns>若包含则返回 true；否则返回 false。</returns>
        public Task<bool> ContainsProductByNameAsync(string name)
        {
            return Task.FromResult(ContainsProductByName(name));
        }


        /// <summary>
        /// 从内存中移除产品（不删除磁盘文件），并保存产品清单。
        /// </summary>
        /// <param name="id">要移除的产品 ID。</param>
        /// <returns>若内存中存在并移除成功返回 true，否则 false。</returns>
        public bool RemoveProduct(Guid id)
        {
            bool result;
            lock (_sync)
            {
                result= _products.Remove(id);
            }

            // 删除后可选择删除对应的文件（视需求而定）
            SaveProductList();
            return result;
        }

        /// <summary>
        /// 异步移除产品（包装同步实现）。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>任务，结果为移除是否成功。</returns>
        public Task<bool> RemoveProductAsync(Guid id)
        {
            var r = RemoveProduct(id);
            return Task.FromResult(r);
        }

        /// <summary>
        /// 清空内存中所有产品（不删除磁盘数据）。
        /// </summary>
        public void RemoveAllProducts()
        {
            lock (_sync)
            {
                _products.Clear();
            }
        }

        // 仍保留按路径保存的版本（向后兼容）
        /// <summary>
        /// 按指定路径保存产品。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <param name="filePath">保存路径（包含文件名）。</param>
        public void SaveProduct(Guid id, string filePath)
        {
            var p = GetProduct(id);
            if (p == null) return;
            SaveProduct(p, filePath);
        }

        /// <summary>
        /// 异步按路径保存产品（包装同步实现）。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <param name="filePath">保存路径。</param>
        /// <returns>表示异步操作的任务。</returns>
        public Task SaveProductAsync(Guid id, string filePath)
        {
            return Task.Run(() => SaveProduct(id, filePath));
        }

        // 新增：不需要传入路径的保存，使用约定目录和文件名
        /// <summary>
        /// 将产品保存到约定目录（ProductsRootPath\<product.Name>\<product.Name>.cfg），并保存其视觉 ToolBlock 文件。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        public void SaveProduct(Guid id)
        {
            // 获取产品
            var p = GetProduct(id);

            if (p == null) return;

            // 获取产品文件路径，产品路径为：ProductsRootPath//p.Name//p.Name.cfg
            string filePath = Path.Combine(ProductsRootPath, p.Name, p.Name + ".cfg");
            SaveProduct(p, filePath);
        }

        /// <summary>
        /// 将指定的 <see cref="ProductModel"/> 序列化并写入指定路径，同时为每个相机流程保存或初始化对应的 `.vpp` ToolBlock 文件。
        /// </summary>
        /// <param name="p">产品模型，不能为空。</param>
        /// <param name="filePath">目标配置文件路径（包含文件名）。</param>
        /// <exception cref="ArgumentNullException">当 <paramref name="p"/> 为 null 时抛出。</exception>
        public void SaveProduct(ProductModel p,string filePath)
        {
            if (p == null) throw new ArgumentNullException(nameof(p));
            var dir = Path.GetDirectoryName(filePath);
            if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
            FileHelper.WriteJsonFile(p, filePath);
            foreach (var item in p.CameraProcedures)
            {
                foreach (var item1 in item.ProcedureModels)
                {
                    string prcPath = dir + "//" + item.Camera + "//" + item1.Name + ".vpp";
                    if (!Directory.Exists(Path.GetDirectoryName(prcPath)))
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(prcPath));
                    }
                    if (item1.ToolBlock != null)
                    {
                        CogSerializer.SaveObjectToFile(item1.ToolBlock, prcPath);
                    }
                    else
                    {
                        //判断路径下是否存在toolblock
                        if (File.Exists(prcPath))
                        {
                            item1.ToolBlock = CogSerializer.LoadObjectFromFile(prcPath) as CogToolBlock;
                        }
                        else
                        {
                            if (File.Exists(TemplateToolBlock))
                            {
                                //保存模板
                                item1.ToolBlock = CogSerializer.LoadObjectFromFile(TemplateToolBlock) as CogToolBlock;
                                CogSerializer.SaveObjectToFile(item1.ToolBlock, prcPath);
                            }

                        }
                    }
                }
            }
        }

        /// <summary>
        /// 异步按约定目录保存产品。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>表示异步操作的任务。</returns>
        public Task SaveProductAsync(Guid id)
        {
            return Task.Run(() => SaveProduct(id));
        }

        /// <summary>
        /// 从指定路径加载产品配置（仅反序列化 JSON，不加载 ToolBlock 文件）。
        /// </summary>
        /// <param name="filePath">产品配置文件路径。</param>
        /// <returns>加载得到的 <see cref="ProductModel"/>，若文件不存在则返回 null。</returns>
        public ProductModel LoadProduct(string filePath)
        {
            if (!File.Exists(filePath)) return null;
            var prd = FileHelper.ReadJsonFile<ProductModel>(filePath);
            return prd;
        }

        /// <summary>
        /// 根据内存中已注册的产品 ID，从约定目录加载其视觉 ToolBlock 并返回产品实例。
        /// </summary>
        /// <param name="id">产品 ID（必须已在内存中注册）。</param>
        /// <returns>加载后的 <see cref="ProductModel"/>，若未注册或找不到则返回 null。</returns>
        public ProductModel LoadProduct(Guid id)
        {
            var p = GetProduct(id);
            if (p == null) return null;
            // 获取产品文件路径，产品路径为：ProductsRootPath//p.Name//p.Name.cfg
            string filePath = Path.Combine(ProductsRootPath, p.Name, p.Name + ".cfg");
            var dir = Path.GetDirectoryName(filePath);
            if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);

            // 加载每个相机的流程ToolBlock
            foreach (var camera in p.CameraProcedures)
            {
                foreach (var prc in camera.ProcedureModels)
                {
                    string prcPath = dir + "//" + camera.Camera + "//" + prc.Name + ".vpp";
                    prc.ToolBlock = CogSerializer.LoadObjectFromFile(prcPath) as CogToolBlock;
                }
            }

            return p;
        }

        /// <summary>
        /// 异步加载产品视觉流程（包装同步实现）。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>包含加载后产品的任务。</returns>
        public Task<ProductModel> LoadProductAsync(Guid id)
        {
            return Task.Run(() => LoadProduct(id));
        }

        /// <summary>
        /// 从系统配置中读取上次打开的产品并尝试加载该产品到内存，并将其设置为当前产品。
        /// </summary>
        /// <returns>若成功加载并设置则返回 (id, name)，否则返回 (Guid.Empty, string.Empty)。</returns>
        public (Guid id, string name) LoadLastProduct()
        {
            // 获取最后打开的产品ID
            var sysConfig = _configService.GetSystemConfiguration();
            if (sysConfig == null || sysConfig.LastOpenedProductId == Guid.Empty)
            {
                return (Guid.Empty, string.Empty);
            }
            var lastProductId = sysConfig.LastOpenedProductId;

            //判断是否存在产品
            if (!ContainsProduct(lastProductId))
            {
                return (Guid.Empty, string.Empty);
            }

            // 尝试从磁盘加载
            var loaded = LoadProduct(lastProductId);
            if (loaded != null)
            {
                SetCurrentProduct(lastProductId);
                return (lastProductId, loaded.Name ?? string.Empty);
            }

            // 如果未能加载，返回空结果
            return (Guid.Empty, string.Empty);
        }

        /// <summary>
        /// 异步加载最后打开的产品（包装同步实现）。
        /// </summary>
        /// <returns>包含 (id, name) 的任务。</returns>
        public Task<(Guid id, string name)> LoadLastProductAsync()
        {
            // 可以使用 Task.FromResult，因为内部是同步且快速的文件检测/读取
            return Task.Run(() => LoadLastProduct());
        }

        /// <summary>
        /// 将指定产品设置为当前产品，并更新系统配置中的 LastOpenedProductId，同时触发 OnProductChanged 事件。
        /// 仅当内存中存在该产品时生效。
        /// </summary>
        /// <param name="id">要设置为当前的产品 ID。</param>
        public void SetCurrentProduct(Guid id)
        {
            lock (_sync)
            {
                if (_products.ContainsKey(id))
                {
                    _currentProduct = id;
                    _products[id].IsLoad = true;
                    //将其他的产品设置为未加载状态
                    foreach (var kvp in _products)
                    {
                        if (kvp.Key != id)
                        {
                            kvp.Value.IsLoad = false;
                        }
                    }
                    var sysConfig = _configService.GetSystemConfiguration();
                    sysConfig.LastOpenedProductId = id;
                    _configService.SaveSystemConfiguration(sysConfig);
                    OnCurrentProductChanged(_products[id]);
                }
            }
        }

        /// <summary>
        /// 获取当前产品模型（若未设置则返回 null）。
        /// </summary>
        /// <returns>当前产品或 null。</returns>
        public ProductModel GetCurrentProduct()
        {
            lock (_sync)
            {
                if (_currentProduct == Guid.Empty) return null;
                _products.TryGetValue(_currentProduct, out var p);
                return p;
            }
        }

        /// <summary>
        /// 复制已有产品并为副本分配新的 ID 与名称，同时保存副本并返回新副本的 ID。
        /// </summary>
        /// <param name="id">源产品 ID。</param>
        /// <param name="newName">新产品的名称。</param>
        /// <returns>新产品的 ID，失败时返回 Guid.Empty。</returns>
        public Guid CopyProduct(Guid id, string newName)
        {
            var p = GetProduct(id);
            if (p == null) return Guid.Empty;
            var clone = p.Clone();
            clone.ID = Guid.NewGuid();
            clone.Name = newName;
            clone.DateTime = DateTime.Now;
            CreateProduct(clone);
            return clone.ID;
        }

        /// <summary>
        /// 异步复制产品。
        /// </summary>
        /// <param name="id">源产品 ID。</param>
        /// <param name="newName">新名称。</param>
        /// <returns>包含新产品 ID 的任务。</returns>
        public Task<Guid> CopyProductAsync(Guid id, string newName)
        {
            return Task.Run(() => CopyProduct(id, newName));
        }

        /// <summary>
        /// 永久删除产品：从内存中移除并递归删除其在磁盘上的文件夹及所有内容。
        /// </summary>
        /// <param name="id">要删除的产品 ID。</param>
        public void DeleteProduct(Guid id)
        {
            //获取产品
            var p = GetProduct(id);
            //如果产品不存在，直接返回
            if (p == null) return;
            //获取产品文件夹路径，产品路径为：ProductsRootPath//p.Name
            string productDirPath = Path.Combine(ProductsRootPath, p.Name);
            //移除产品
            RemoveProduct(id);
            //删除产品文件夹及其内容
            DeleteDirectoryRecursively(productDirPath);
        }

        /// <summary>
        /// 异步删除产品（包装同步实现）。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <returns>表示异步删除操作的任务。</returns>
        public Task DeleteProductAsync(Guid id)
        {
            return Task.Run(() => DeleteProduct(id));
        }

        /// <summary>
        /// 对指定产品进行重命名：更新内存模型并在磁盘上重命名对应文件夹（若存在），然后保存产品清单与产品配置。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <param name="newName">新的产品名称。</param>
        public void RenameProduct(Guid id, string newName)
        {
            // 获取产品
            var p = GetProduct(id);
            if (p == null) return;
            // 获取旧产品文件夹路径，产品路径为：ProductsRootPath//p.Name
            string oldProductDirPath = Path.Combine(ProductsRootPath, p.Name);
            // 更新产品名称
            p.Name = newName;
            // 获取新产品文件夹路径
            string newProductDirPath = Path.Combine(ProductsRootPath, newName);
            // 重命名文件夹
            if (Directory.Exists(oldProductDirPath))
            {
                Directory.Move(oldProductDirPath, newProductDirPath);
            }
            // 保存产品清单
            SaveProductList();

            //对产品进行保存
            SaveProduct(id);
        }

        /// <summary>
        /// 异步重命名产品（包装同步实现）。
        /// </summary>
        /// <param name="id">产品 ID。</param>
        /// <param name="newName">新的名称。</param>
        /// <returns>表示异步操作的任务。</returns>
        public Task RenameProductAsync(Guid id, string newName)
        {
            return Task.Run(() => RenameProduct(id, newName));
        }

        /// <summary>
        /// 更新内存中产品对象并将其保存到磁盘（若存在）。
        /// </summary>
        /// <param name="product">要更新的产品模型（不能为空）。</param>
        public void UpdateProduct(ProductModel product)
        {
            if (product == null) throw new ArgumentNullException(nameof(product));
            lock (_sync)
            {
                if (_products.ContainsKey(product.ID))
                {
                    _products[product.ID] = product;
                }
            }
            // 更新后自动保存到磁盘
            SaveProduct(product.ID);
        }

        /// <summary>
        /// 异步更新产品（包装同步实现）。
        /// </summary>
        /// <param name="product">产品模型。</param>
        /// <returns>表示异步操作的任务。</returns>
        public Task UpdateProductAsync(ProductModel product)
        {
            return Task.Run(() => UpdateProduct(product));
        }

        /// <summary>
        /// 根据指定的模板名称创建产品并保存。模板文件位于 <see cref="ProductTemplatePath"/>。
        /// </summary>
        /// <param name="templateName">模板名称（对应子文件夹与 cfg 文件名）。</param>
        /// <param name="productName">新产品名称。</param>
        /// <returns>创建并返回的新产品模型；若模板不存在则返回 null。</returns>
        public ProductModel CreateProductByTemplateName(string templateName, string productName)
        {
            // 产品模板路径为：ProductTemplatePath//templateName//templateName.cfg
            string templateFilePath = Path.Combine(ProductTemplatePath, templateName, templateName + ".cfg");
            var templateProduct = LoadProduct(templateFilePath);
            if (templateProduct == null) return null;
            var newProduct = templateProduct.Clone();
            newProduct.Name = productName;
            newProduct.ID= Guid.NewGuid();
            CreateProduct(newProduct);
            return GetProduct(newProduct.ID);
        }

        /// <summary>
        /// 异步根据模板创建产品。
        /// </summary>
        /// <param name="templateName">模板名。</param>
        /// <param name="productName">产品名。</param>
        /// <returns>包含新产品模型的任务。</returns>
        public Task<ProductModel> CreateProductByTemplateNameAsync(string templateName, string productName)
        {
            return Task.Run(() => CreateProductByTemplateName(templateName, productName));
        }

        /// <summary>
        /// 在所有产品中增加一个相机流程（当系统新增相机时调用），并保存每个产品的配置。
        /// </summary>
        /// <param name="cameraId">相机 ID。</param>
        /// <param name="cameraName">相机名称。</param>
        public void AddCameraToProduct(Guid cameraId, string cameraName)
        {
            //获取所有产品
            var products= GetAllProducts();
            if (products == null) return;
            //遍历所有产品，增加相机流程
            foreach (var item in products)
            {
                item.AddCameraProcedure(new CameraProcedure(cameraId, cameraName));
                //单个产品的配置文件路径
                string productFilePath = Path.Combine(ProductsRootPath, item.Name, item.Name + ".cfg");
                //保存产品
                FileHelper.WriteJsonFile(item, productFilePath);
            }

        }

        /// <summary>
        /// 异步在所有产品中增加相机流程。
        /// </summary>
        /// <param name="cameraId">相机 ID。</param>
        /// <param name="cameraName">相机名。</param>
        /// <returns>表示异步操作的任务。</returns>
        public Task AddCameraToProductAsync(Guid cameraId, string cameraName)
        {
            return Task.Run(() => AddCameraToProduct(cameraId, cameraName));
        }

        /// <summary>
        /// 在所有产品中移除指定相机对应的流程，并保存产品文件。
        /// </summary>
        /// <param name="cameraId">要移除的相机 ID。</param>
        public void RemoveCameraFromProduct(Guid cameraId)
        {
            var products= GetAllProducts();
            if (products == null) return;
            //遍历所有产品，删除相机流程
            foreach (var item in products)
            {
                item.RemoveCameraProcedure(cameraId);
                //单个产品的配置文件路径
                string productFilePath = Path.Combine(ProductsRootPath, item.Name, item.Name + ".cfg");
                //保存产品
                FileHelper.WriteJsonFile(item, productFilePath);
            }
        }

        /// <summary>
        /// 异步在所有产品中移除相机流程。
        /// </summary>
        /// <param name="cameraId">相机 ID。</param>
        /// <returns>任务。</returns>
        public Task RemoveCameraFromProductAsync(Guid cameraId)
        {
            return Task.Run(() => RemoveCameraFromProduct(cameraId));
        }

        /// <summary>
        /// 更新所有产品中指定相机的名称，并在磁盘上重命名对应的相机文件夹（若存在）。
        /// </summary>
        /// <param name="cameraId">相机 ID。</param>
        /// <param name="newCameraName">新相机名称。</param>
        public void UpdateCameraNameInProduct(Guid cameraId, string newCameraName)
        {
            var products= GetAllProducts();
            if (products == null) return;
            //遍历所有产品，修改相机名称
            foreach (var item in products)
            {
                //旧名称
                string oldCameraName = string.Empty;
                var cameraProcedure = item.CameraProcedures.FirstOrDefault(cp => cp.ID == cameraId);
                if (cameraProcedure != null)
                {
                    oldCameraName = cameraProcedure.Camera;
                    cameraProcedure.Camera = newCameraName;
                }
                //单个产品的配置文件路径
                string productFilePath = Path.Combine(ProductsRootPath, item.Name, item.Name + ".cfg");
                //保存产品
                FileHelper.WriteJsonFile(item, productFilePath);
                if (!string.IsNullOrEmpty(oldCameraName))
                {
                    //改之前相机流程文件夹路径
                    string cameraDirPath = Path.Combine(ProductsRootPath, item.Name, oldCameraName);
                    //如果相机名称发生变化，重命名相机流程文件夹
                    if (oldCameraName != newCameraName)
                    {
                        string newCameraDirPath = Path.Combine(ProductsRootPath, item.Name, newCameraName);
                        if (Directory.Exists(cameraDirPath))
                        {
                            Directory.Move(cameraDirPath, newCameraDirPath);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 异步更新所有产品中的相机名称。
        /// </summary>
        /// <param name="cameraId">相机 ID。</param>
        /// <param name="newCameraName">新名称。</param>
        /// <returns>任务。</returns>
        public Task UpdateCameraNameInProductAsync(Guid cameraId, string newCameraName)
        {
            return Task.Run(() => UpdateCameraNameInProduct(cameraId, newCameraName));
        }

        /// <summary>
        /// 在所有产品中增加机器人点位表条目并保存对应产品文件（当系统新增机器人或点位时调用）。
        /// </summary>
        /// <param name="robotId">机器人 ID。</param>
        /// <param name="robotPointName">点位名称。</param>
        public void AddRobotPointToProduct(Guid robotId, string robotPointName)
        {
            //获取所有产品
            var products = GetAllProducts();
            if (products == null) return;
            //遍历所有产品，增加机器人点位表
            foreach (var item in products)
            {
                item.RobotPoint.AddRobot(robotId, robotPointName);
                //单个产品的配置文件路径
                string productFilePath = Path.Combine(ProductsRootPath, item.Name, item.Name + ".cfg");
                //保存产品
                FileHelper.WriteJsonFile(item, productFilePath);
            }

        }

        /// <summary>
        /// 异步为所有产品增加机器人点位。
        /// </summary>
        /// <param name="robotId">机器人 ID。</param>
        /// <param name="robotPointName">点位名。</param>
        /// <returns>任务。</returns>
        public Task AddRobotPointToProductAsync(Guid robotId, string robotPointName)
        {
            return Task.Run(() => AddRobotPointToProduct(robotId, robotPointName));
        }

        /// <summary>
        /// 在所有产品中移除指定机器人相关的点位配置并保存产品文件。
        /// </summary>
        /// <param name="robotId">机器人 ID。</param>
        public void RemoveRobotPointFromProduct(Guid robotId)
        {
            var products = GetAllProducts();
            if (products == null) return;
            //遍历所有产品，删除机器人点位表
            foreach (var item in products)
            {
                item.RobotPoint.RemoveRobot(robotId);
                //单个产品的配置文件路径
                string productFilePath = Path.Combine(ProductsRootPath, item.Name, item.Name + ".cfg");
                //保存产品
                FileHelper.WriteJsonFile(item, productFilePath);
            }
        }

        /// <summary>
        /// 异步在所有产品中移除机器人点位。
        /// </summary>
        /// <param name="robotId">机器人 ID。</param>
        /// <returns>任务。</returns>
        public Task RemoveRobotPointFromProductAsync(Guid robotId)
        {
            return Task.Run(() => RemoveRobotPointFromProduct(robotId));
        }

        /// <summary>
        /// 更新所有产品中指定机器人点位的名称并保存产品配置。
        /// </summary>
        /// <param name="robotId">机器人 ID。</param>
        /// <param name="newRobotPointName">新的点位名称。</param>
        public void UpdateRobotPointNameInProduct(Guid robotId, string newRobotPointName)
        {
            var products = GetAllProducts();
            if (products == null) return;
            //遍历所有产品，修改机器人点位名称
            foreach (var item in products)
            {
                var robotPointStore = item.RobotPoint.Robots.FirstOrDefault(rp => rp.Id == robotId);
                if (robotPointStore != null)
                {
                    robotPointStore.Name = newRobotPointName;
                }
                //单个产品的配置文件路径
                string productFilePath = Path.Combine(ProductsRootPath, item.Name, item.Name + ".cfg");
                //保存产品
                FileHelper.WriteJsonFile(item, productFilePath);
            }
        }

        /// <summary>
        /// 异步更新机器人点位名称。
        /// </summary>
        /// <param name="robotId">机器人 ID。</param>
        /// <param name="newRobotPointName">新名称。</param>
        /// <returns>任务。</returns>
        public Task UpdateRobotPointNameInProductAsync(Guid robotId, string newRobotPointName)
        {
            return Task.Run(() => UpdateRobotPointNameInProduct(robotId, newRobotPointName));
        }

        /// <summary>
        /// 加载指定产品的某个相机流程的视觉工具（ToolBlock）。
        /// 若视觉工具文件不存在则尝试从模板加载并保存到目标路径；若模板也不存在则抛出 <see cref="FileNotFoundException"/>。
        /// </summary>
        /// <param name="productid">产品 ID。</param>
        /// <param name="cameraid">相机 ID。</param>
        /// <param name="prcname">流程名称。</param>
        public void LoadProcedureVisionTools(Guid productid, Guid cameraid, string prcname)
        {
            //获取产品
            var product= GetProduct(productid);
            if (product == null) return;
            //获取相机流程
            var cameraProcedure = product.CameraProcedures.FirstOrDefault(cp => cp.ID == cameraid);
            if (cameraProcedure == null) return;
            //获取指定名称的流程
            var procedure = cameraProcedure.ProcedureModels.FirstOrDefault(pm => pm.Name == prcname);
            if (procedure == null) return;
            //获取流程视觉工具路径
            string vpppath= Path.Combine(ProductsRootPath, product.Name, cameraProcedure.Camera, prcname + ".vpp");
            if (File.Exists(vpppath))
            {
                procedure.ToolBlock = CogSerializer.LoadObjectFromFile(vpppath) as CogToolBlock;
            }
            else
            {
                //如果不存在，则加载一个模板工具
                if (File.Exists(TemplateToolBlock))
                {
                    procedure.ToolBlock = CogSerializer.LoadObjectFromFile(TemplateToolBlock) as CogToolBlock;
                    //保存到指定路径
                    CogSerializer.SaveObjectToFile(procedure.ToolBlock, vpppath);
                }
                else
                {
                    throw new FileNotFoundException("模板工具文件不存在，无法创建新的视觉工具。", TemplateToolBlock);
                }
            }
        }

        /// <summary>
        /// 异步加载指定产品流程的视觉工具，返回是否成功。
        /// </summary>
        /// <param name="productid">产品 ID。</param>
        /// <param name="cameraid">相机 ID。</param>
        /// <param name="prcname">流程名称。</param>
        /// <returns>成功返回 true，发生异常返回 false。</returns>
        public Task<bool> LoadProcedureVisionToolsAsync(Guid productid, Guid cameraid, string prcname)
        {
            return Task.Run(() =>
            {
                try
                {
                    LoadProcedureVisionTools(productid, cameraid, prcname);
                    return true;
                }
                catch
                {
                    return false;
                }
            });
        }

        /// <summary>
        /// 获取当前产品的指定视觉流程ID的视觉流程对象
        /// </summary>
        /// <param name="procedureId"></param>
        /// <returns></returns>
        public ProcedureModel GetCurrentProductProcedureModelById(Guid procedureId)
        {
            var currentProduct = GetCurrentProduct();
            if (currentProduct == null) return null;
            foreach (var cameraProcedure in currentProduct.CameraProcedures)
            {
                var procedure = cameraProcedure.ProcedureModels.FirstOrDefault(pm => pm.Id == procedureId);
                if (procedure != null)
                {
                    return procedure;
                }
            }
            return null;
        }


        /// <summary>
        /// 递归删除指定目录及其所有子目录和文件。
        /// 注意：此操作会永久删除磁盘上的文件，请谨慎调用。
        /// </summary>
        /// <param name="dirPath">要删除的目录路径。</param>
        private void DeleteDirectoryRecursively(string dirPath)
        {
            if (Directory.Exists(dirPath))
            {
                var dirInfo = new DirectoryInfo(dirPath);
                // 删除所有文件
                foreach (var file in dirInfo.GetFiles())
                {
                    file.Delete();
                }
                // 递归删除所有子目录
                foreach (var dir in dirInfo.GetDirectories())
                {
                    DeleteDirectoryRecursively(dir.FullName);
                }
                // 删除当前目录
                dirInfo.Delete();
            }
        }

        /// <summary>
        /// 触发当前产品切换事件的内部方法（线程安全地调用事件）。
        /// </summary>
        /// <param name="product">新的当前产品。</param>
        private void OnCurrentProductChanged(ProductModel product)
        {
            OnProductChanged?.Invoke(product);
        }

        /// <summary>
        /// 释放资源，清空内存中的产品集合并抑制终结化。
        /// </summary>
        public void Dispose()
        {
            RemoveAllProducts();
            GC.SuppressFinalize(this);
        }
    }
}