Display_D_HP/TeamAAS-VM/Interfaces/IProductService.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using TeamAAS_VP.Models;

namespace TeamAAS_VP.Interfaces
{
    /// <summary>
    /// 产品管理服务：用于创建、存储、复制、移除、修改、加载与获取产品，以及管理当前产品状态。
    /// 实现应负责线程安全地管理内存中的产品集合，并提供同步与异步两种操作方式以便 UI 与后台任务使用。
    /// </summary>
    public interface IProductService : IDisposable
    {

        void Clear();
        /// <summary>
        /// 当前产品编号
        /// </summary>
        string CurrentProductCode { get; set; }

        /// <summary>
        /// 产品切换事件
        /// </summary>
        event Action<ProductModel> OnProductChanged;

        /// <summary>
        /// 使用指定的本地产品清单文件初始化服务（同步）。
        /// 实现应负责从清单文件读取产品信息并将其加载到服务的内部集合中。
        /// 返回 true 表示初始化并加载成功；false 表示失败（或按实现约定抛出异常）。
        /// </summary>
        /// <returns>初始化是否成功。</returns>
        bool Initialize();

        /// <summary>
        /// 使用指定的本地产品清单文件初始化服务（异步）。
        /// 实现应负责从清单文件读取产品信息并将其加载到服务的内部集合中。
        /// 返回 true 表示初始化并加载成功；false 表示失败（或按实现约定抛出异常）。
        /// </summary>
        /// <returns>初始化是否成功的任务。</returns>
        Task<bool> InitializeAsync();

        /// <summary>
        /// 获取所有产品的简要信息列表（同步）。
        /// </summary>
        /// <returns></returns>
        IEnumerable<(Guid id, string name, string filePath)> GetAllProductList();

        /// <summary>
        /// 异步创建产品并将其添加到服务管理的集合中。
        /// </summary>
        /// <param name="product">要创建并添加的产品模型。</param>
        /// <returns>如果创建并添加成功则返回 true；否则返回 false。</returns>
        Task<bool> CreateProductAsync(ProductModel product);

        /// <summary>
        /// 同步创建产品并将其添加到服务管理的集合中。
        /// </summary>
        /// <param name="product">要创建并添加的产品模型。</param>
        /// <returns>如果创建并添加成功则返回 true；否则返回 false。</returns>
        bool CreateProduct(ProductModel product);

        /// <summary>
        /// 根据指定 ID 获取产品（同步）。
        /// </summary>
        /// <param name="id">产品的唯一标识符。</param>
        /// <returns>如果存在则返回对应的 <see cref="ProductModel"/>；不存在时返回 null（或实现自定义的空表示）。</returns>
        ProductModel GetProduct(Guid id);

        /// <summary>
        /// 根据指定 ID 异步获取产品。
        /// </summary>
        /// <param name="id">产品的唯一标识符。</param>
        /// <returns>返回可能为 null 的 <see cref="ProductModel"/>，表示未找到时为 null。</returns>
        Task<ProductModel> GetProductAsync(Guid id);

        /// <summary>
        /// 获取所有已加载的产品（只读集合，同步）。
        /// </summary>
        /// <returns>返回包含当前所有产品的只读集合。</returns>
        IReadOnlyCollection<ProductModel> GetAllProducts();

        /// <summary>
        /// 异步获取所有已加载的产品（只读集合）。
        /// </summary>
        /// <returns>返回包含当前所有产品的只读集合。</returns>
        Task<IReadOnlyCollection<ProductModel>> GetAllProductsAsync();

        /// <summary>
        /// 尝试根据指定 ID 获取产品（同步），不会抛出异常用于查找失败的情况。
        /// </summary>
        /// <param name="id">要查找的产品 ID。</param>
        /// <param name="product">当返回 true 时为找到的产品；否则应设置为 null 或默认值。</param>
        /// <returns>如果找到产品则返回 true；否则返回 false。</returns>
        bool TryGetProduct(Guid id, out ProductModel product);

        /// <summary>
        /// 异步尝试根据指定 ID 获取产品。返回一个元组，包含查找是否成功以及对应的产品（若未找到则为 null）。
        /// </summary>
        /// <param name="id">要查找的产品 ID。</param>
        /// <returns>返回元组：(found: 是否找到, product: 找到的产品或 null)。</returns>
        Task<(bool found, ProductModel product)> TryGetProductAsync(Guid id);

        /// <summary>
        /// 判断服务中是否包含指定 ID 的产品（同步）。
        /// </summary>
        /// <param name="id">产品的唯一标识符。</param>
        /// <returns>若包含则返回 true；否则返回 false。</returns>
        bool ContainsProduct(Guid id);

        /// <summary>
        /// 异步判断服务中是否包含指定 ID 的产品。
        /// </summary>
        /// <param name="id">产品的唯一标识符。</param>
        /// <returns>若包含则返回 true；否则返回 false。</returns>
        Task<bool> ContainsProductAsync(Guid id);

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

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

        /// <summary>
        /// 从服务中移除指定 ID 的产品（同步）。
        /// </summary>
        /// <param name="id">要移除的产品 ID。</param>
        /// <returns>如果移除成功（存在并被移除）返回 true，否则返回 false。</returns>
        bool RemoveProduct(Guid id);

        /// <summary>
        /// 异步从服务中移除指定 ID 的产品。
        /// </summary>
        /// <param name="id">要移除的产品 ID。</param>
        /// <returns>如果移除成功（存在并被移除）返回 true，否则返回 false。</returns>
        Task<bool> RemoveProductAsync(Guid id);

        /// <summary>
        /// 从服务中移除所有产品（同步），清空内部集合并释放相关资源（若有）。
        /// </summary>
        void RemoveAllProducts();

        /// <summary>
        /// 将指定产品保存到给定文件路径（同步）。
        /// 若产品不存在，应抛出相应异常或以返回值/日志方式处理（实现约定）。
        /// </summary>
        /// <param name="id">要保存的产品 ID。</param>
        /// <param name="filePath">目标文件的完整路径。</param>
        void SaveProduct(Guid id, string filePath);

        /// <summary>
        /// 异步将指定产品保存到给定文件路径。
        /// </summary>
        /// <param name="id">要保存的产品 ID。</param>
        /// <param name="filePath">目标文件的完整路径。</param>
        Task SaveProductAsync(Guid id, string filePath);

        /// <summary>
        /// 保存产品
        /// </summary>
        /// <param name="id"></param>
        void SaveProduct(Guid id);

        /// <summary>
        /// 保存产品
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        Task SaveProductAsync(Guid id);

        /// <summary>
        /// 保存产品清单
        /// </summary>
        void SaveProductList();

        /// <summary>
        /// 异步保存产品清单
        /// </summary>
        /// <returns></returns>
        Task SaveProductListAsync();

        /// <summary>
        /// 从指定文件加载产品（同步）。实现应负责反序列化并将产品添加到服务管理的集合（或仅返回实例，取决于实现约定）。
        /// </summary>
        /// <param name="id">要加载的产品唯一标识符。</param>
        /// <returns>加载并返回的 <see cref="ProductModel"/> 实例。</returns>
        ProductModel LoadProduct(Guid id);

        /// <summary>
        /// 异步从指定文件加载产品并返回加载的模型。
        /// </summary>
        /// <param name="id">要加载的产品唯一标识符。</param>
        /// <returns>加载并返回的 <see cref="ProductModel"/> 实例。</returns>
        Task<ProductModel> LoadProductAsync(Guid id);

        /// <summary>
        /// 根据产品加载记录，获取最近一次加载的产品信息（同步）。
        /// </summary>
        /// <returns>返回一个元组：<c>(id, name)</c>，分别表示最后加载的产品 ID 与名称；若无记录，ID 可为 <see cref="Guid"/>.Empty，名称可为空字符串。</returns>
        (Guid id, string name) LoadLastProduct();

        /// <summary>
        /// 异步根据产品加载记录，获取最近一次加载的产品信息。
        /// </summary>
        /// <returns>返回一个元组：<c>(id, name)</c>，分别表示最后加载的产品 ID 与名称；若无记录，ID 可为 <see cref="Guid"/>.Empty，名称可为空字符串。</returns>
        Task<(Guid id, string name)> LoadLastProductAsync();

        /// <summary>
        /// 设置为当前选中的或正在编辑的产品（同步）。
        /// </summary>
        /// <param name="id"></param>
        void SetCurrentProduct(Guid id);

        /// <summary>
        /// 获取当前选中的或正在编辑的产品实例（同步）。
        /// </summary>
        /// <returns>当前产品的 <see cref="ProductModel"/> 实例；若无当前产品可返回 null。</returns>
        ProductModel GetCurrentProduct();

        /// <summary>
        /// 复制指定产品为一个新对象并返回新对象的 ID（同步）。
        /// 实现应复制所有必要的数据并为新产品生成新的唯一 ID，同时支持为新产品指定名称。
        /// </summary>
        /// <param name="id">要复制的源产品 ID。</param>
        /// <param name="newName">新复制产品的名称。</param>
        /// <returns>新复制产品的 ID。</returns>
        Guid CopyProduct(Guid id, string newName);

        /// <summary>
        /// 异步复制指定产品为一个新对象并返回新对象的 ID。
        /// </summary>
        /// <param name="id">要复制的源产品 ID。</param>
        /// <param name="newName">新复制产品的名称。</param>
        /// <returns>新复制产品的 ID。</returns>
        Task<Guid> CopyProductAsync(Guid id, string newName);

        /// <summary>
        /// 永久删除产品
        /// </summary>
        /// <param name="id"></param>
        void DeleteProduct(Guid id);

        /// <summary>
        /// 永久删除产品
        /// </summary>
        /// <param name="id"></param>
        Task DeleteProductAsync(Guid id);

        /// <summary>
        /// 对指定产品进行重命名
        /// </summary>
        /// <param name="id"></param>
        /// <param name="newName"></param>
        void RenameProduct(Guid id, string newName);

        /// <summary>
        /// 对指定产品进行重命名
        /// </summary>
        /// <param name="id"></param>
        /// <param name="newName"></param>
        /// <returns></returns>
        Task RenameProductAsync(Guid id, string newName);

        /// <summary>
        /// 更新产品
        /// </summary>
        /// <param name="product"></param>
        void UpdateProduct(ProductModel product);

        /// <summary>
        /// 更新产品
        /// </summary>
        /// <param name="product"></param>
        /// <returns></returns>
        Task UpdateProductAsync(ProductModel product);

        /// <summary>
        /// 根据指定的模板名称创建产品
        /// </summary>
        /// <param name="templateName"></param>
        /// <param name="productName"></param>
        /// <returns></returns>
        ProductModel CreateProductByTemplateName(string templateName, string productName);

        /// <summary>
        /// 根据指定的模板名称异步创建产品
        /// </summary>
        /// <param name="templateName"></param>
        /// <param name="productName"></param>
        /// <returns></returns>
        Task<ProductModel> CreateProductByTemplateNameAsync(string templateName, string productName);

        /// <summary>
        /// 增加相机时，需要对产品的相机流程进行增加
        /// </summary>
        /// <param name="cameraId"></param>
        /// <param name="cameraName"></param>
        void AddCameraToProduct(Guid cameraId, string cameraName);

        /// <summary>
        /// 增加相机时，需要对产品的相机流程进行增加
        /// </summary>
        /// <param name="cameraId"></param>
        /// <param name="cameraName"></param>
        /// <returns></returns>
        Task AddCameraToProductAsync(Guid cameraId, string cameraName);

        /// <summary>
        /// 删除相机时，需要对产品的相机流程进行删除
        /// </summary>
        /// <param name="cameraId"></param>
        void RemoveCameraFromProduct(Guid cameraId);

        /// <summary>
        /// 删除相机时，需要对产品的相机流程进行删除
        /// </summary>
        /// <param name="cameraId"></param>
        /// <returns></returns>
        Task RemoveCameraFromProductAsync(Guid cameraId);

        /// <summary>
        /// 修改相机名称时，需要对产品的相机流程进行修改
        /// </summary>
        /// <param name="cameraId"></param>
        /// <param name="newCameraName"></param>
        void UpdateCameraNameInProduct(Guid cameraId, string newCameraName);

        /// <summary>
        /// 修改相机名称时，需要对产品的相机流程进行修改
        /// </summary>
        /// <param name="cameraId"></param>
        /// <param name="newCameraName"></param>
        /// <returns></returns>
        Task UpdateCameraNameInProductAsync(Guid cameraId, string newCameraName);

        /// <summary>
        /// 增加机器人时，需要对产品的机器人点位进行增加
        /// </summary>
        /// <param name="robotId"></param>
        /// <param name="robotPointName"></param>
        void AddRobotPointToProduct(Guid robotId, string robotPointName);


        /// <summary>
        /// 增加扫码枪时，需要对产品的扫码枪点位进行增加
        /// </summary>
        /// <param name="scannerId"></param>
        /// <param name="scannerPointName"></param>
        void AddScannerPointToProduct(Guid scannerId, string scannerPointName);
        /// <summary>
        /// 增加机器人时，需要对产品的机器人点位进行增加
        /// </summary>
        /// <param name="robotId"></param>
        /// <param name="robotPointName"></param>
        /// <returns></returns>
        Task AddRobotPointToProductAsync(Guid robotId, string robotPointName);

        /// <summary>
        /// 删除机器人时，需要对产品的机器人点位进行删除
        /// </summary>
        /// <param name="robotId"></param>
        void RemoveRobotPointFromProduct(Guid robotId);

        /// <summary>
        /// 删除扫码枪时，需要对产品的扫码枪点位进行删除
        /// </summary>
        /// <param name="scannerId"></param>
        void RemoveScannerPointFromProduct(Guid scannerId);

        /// <summary>
        /// 删除机器人时，需要对产品的机器人点位进行删除
        /// </summary>
        /// <param name="robotId"></param>
        /// <returns></returns>
        Task RemoveRobotPointFromProductAsync(Guid robotId);

        /// <summary>
        /// 修改机器人名称时，需要对产品的机器人点位进行修改
        /// </summary>
        /// <param name="robotId"></param>
        /// <param name="newRobotPointName"></param>
        void UpdateRobotPointNameInProduct(Guid robotId, string newRobotPointName);

        /// <summary>
        /// 修改机器人名称时，需要对产品的机器人点位进行修改
        /// </summary>
        /// <param name="robotId"></param>
        /// <param name="newRobotPointName"></param>
        /// <returns></returns>
        Task UpdateRobotPointNameInProductAsync(Guid robotId, string newRobotPointName);

        /// <summary>
        /// 加载指定产品流程的视觉工具
        /// </summary>
        /// <param name="productid"></param>
        /// <param name="cameraid"></param>
        /// <param name="prcname"></param>
        void LoadProcedureVisionTools(Guid productid, Guid cameraid, string prcname);

        /// <summary>
        /// 加载指定产品流程的视觉工具
        /// </summary>
        /// <param name="productid"></param>
        /// <param name="cameraid"></param>
        /// <param name="prcname"></param>
        /// <returns></returns>
        Task<bool> LoadProcedureVisionToolsAsync(Guid productid, Guid cameraid, string prcname);

        /// <summary>
        /// 获取当前产品的指定视觉流程ID的视觉流程对象
        /// </summary>
        /// <param name="procedureId"></param>
        /// <returns></returns>
        ProcedureModel GetCurrentProductProcedureModelById(Guid procedureId);

    }
}