using CMS.Extensions.Variable;
using CMS.Plugin.FormulaManagement.Abstractions;
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.CommonDto;
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;
using CMS.Plugin.MaterialManagement.Abstractions;
using CMS.Plugin.OrderManagement.Abstractions;
using CMS.Plugin.OrderManagement.Abstractions.Enums;
using CMS.Plugin.OrderManagement.Abstractions.Models;
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.CallMaterialOrder;
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.WorkPlan;
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.WorkTask;
using CMS.Plugin.PipeLineLems.Application.Contracts.Services;
using CMS.Plugin.PipeLineLems.Domain.CallMaterialOrder;
using CMS.Plugin.PipeLineLems.Domain.CallMaterialOrderRecord;
using CMS.Plugin.PipeLineLems.Domain.WorkPlan;
using CMS.Plugin.PipeLineLems.Domain.WorkTask;
using CMS.Plugin.ProcessManagement.Abstractions;
using CMS.Plugin.ProductManagement.Abstractions;
using CMS.Plugin.TraceManagement.Abstractions;
using CMS.Plugin.TraceManagement.Abstractions.Models.Traces;
using CmsQueryExtensions;
using CmsQueryExtensions.Entitys;
using CmsQueryExtensions.Extension;
using KissUtil.Extensions;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using Volo.Abp;
using Volo.Abp.ObjectMapping;
using Volo.Abp.Uow;

namespace CMS.Plugin.PipeLineLems.Application.Implements;

/// <summary> 
/// 作业计划表应用服务 
/// </summary> 
public class SharedService : CMSPluginAppService
{

    /// <summary>
    /// 分拣功能
    /// </summary>
    /// <param name="_serviceProvider"></param>
    /// <param name="input"></param>
    /// <param name="myCurrentUser"></param>
    /// <returns></returns>
    public async Task<MesOrderResponse> CommonPick(IServiceProvider _serviceProvider, PickInput input, MyCurrentUser myCurrentUser)
    {
        if (string.IsNullOrEmpty(input.TaskCode))
        {
            throw new UserFriendlyException("请输入任务编号");
        };
        if (string.IsNullOrEmpty(input.PipeSpecCode))
        {
            throw new UserFriendlyException("请输入管段编码");
        };
        if (string.IsNullOrEmpty(input.ContinerNo))
        {
            throw new UserFriendlyException("请输入托盘号");
        };
        //1、记录分拣记录表
        //2、更新作业计划表的状态 =已分拣
        //3、写入 分拣变量
        //4、写入追溯报表
        //5、物料组盘


        VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
        var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
        var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
        var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
        var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
        var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
        var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

        //Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
        //            {
        //                { "分拣托盘号","托盘1"},
        //                { "分拣方向", "短管装配"},
        //                { "分拣人", myCurrentUser.UserAccount }
        //            };
        //_variableService.WriteValueAsync(keyValuePairs);

        //根据工序名获取工序对象
        var workSection = await _workSectionManager.GetByNameAsync("分拣工序");
        var workStation = await _workStationManager.GetByNameAsync("分拣工位");
        //写入追溯报表
        var finishTime = DateTime.Now;
        TraceModel traceModel = new TraceModel()
        {
            SerialNumber = input.PipeSpecCode,
            WorkSectionId = workSection.Id,
            WorkSectionName = workSection.Name,
            WorkStationName = workStation.Name,

            FinishTime = finishTime,
            IsQualified = true,
            UnqualifiedReason = "",
            ProductModel = "",
            ProductName = "",

        };
        traceModel.Params = new List<TraceParamModel>();
        foreach (var item in workSection.ProcessParameters)
        {
            var value = "ssss";
            traceModel.Params.Add(new TraceParamModel()
            {
                Key = item.Key,
                Value = value.SafeString()
            });
        }
        //物料参数列表
        var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.TaskCode == input.TaskCode);
        var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == firstWorkPlan.DataIdentifier);
        //TODO:这里调用wms的叫料接口
        try
        {
            //首先判断库存是否存在
            var dto = await IsExistInWms(input.PipeSpecCode);
            if (dto != null)
            {
                throw new UserFriendlyException($"已经分拣过，库存在库位{dto.PlaceNo},托盘号{dto.ContainerNo}");
            }


            WmsMaterialStockCreateDto param = new WmsMaterialStockCreateDto()
            {
                ContainerNo = input.ContinerNo,
                MaterialModel = firstWorkPlan.MaterialMode,
                PlaceNo = input.PlaceNo,
                StockNumber = 1,
                MaterialBatch = callMaterialOrder.MaterialBatch,

                RedundantField1 = firstWorkPlan.ProcessRouteNumber, //扩展字段显示 工艺流向编号
                RedundantField2 = firstWorkPlan.PipeSpecCode, //扩展字段显示 管段编码
                RedundantField3 = firstWorkPlan.PipeSectionName, //扩展字段显示 管段名称

            };
            string baseUrl = @"http://127.0.0.1:18000/api/v1/HIAWms/";
            string url = baseUrl + "LMesOperate/LMesPick";
            string json = JsonConvert.SerializeObject(param);
            var result = HttpApiRequest.HttpPost(url, json);
            var res = JsonConvert.DeserializeObject<CmsApiResponse<WmsMaterialStockDto>>(result);
            if (res.Code == 200)
            {
                var retData = res.Data;
                //callMaterialOrder.MaterialBatch = retData[0].MaterialBatch;
                //callMaterialOrder.WmsTaskNo = retData[0].TaskNo;
                //callMaterialOrder.WmsRetResult = res.Message;
            }
            else
            {
                throw new UserFriendlyException(res.Message);
            }
        }
        catch (Exception)
        {

            throw;
        }





        var rawPipe_DataIdentifier = await materialProvider.FindByNameAsync("原料管标识");
        var rawPipe_MaterialMode = await materialProvider.FindByNameAsync("原料管型号");
        var rawPipe_Batch = await materialProvider.FindByNameAsync("原料管批次");
        List<TraceMaterialModel> _MaterialParams = new List<TraceMaterialModel>();
        foreach (var item in workSection.MaterialParameters)
        {
            if (item.Name == "原料管型号")
            {
                _MaterialParams.Add(new TraceMaterialModel()
                {
                    Key = item.Key,
                    Quantity = 1,
                    MaterialId = rawPipe_MaterialMode.MaterialId,
                    MaterialDetailId = rawPipe_MaterialMode.MaterialDetails.First().Id,
                    Value = firstWorkPlan.MaterialMode

                });
            }
            if (item.Name == "原料管标识")
            {
                _MaterialParams.Add(new TraceMaterialModel()
                {
                    Key = item.Key,
                    Quantity = 1,
                    MaterialId = rawPipe_DataIdentifier.MaterialId,
                    MaterialDetailId = rawPipe_DataIdentifier.MaterialDetails.First().Id,
                    Value = firstWorkPlan.DataIdentifier,

                });
            }
            if (item.Name == "原料管批次")
            {
                _MaterialParams.Add(new TraceMaterialModel()
                {
                    Key = item.Key,
                    Quantity = 1,
                    MaterialId = rawPipe_Batch.MaterialId,
                    MaterialDetailId = rawPipe_Batch.MaterialDetails.First().Id,
                    Value = callMaterialOrder.MaterialBatch,//批次暂时写死

                });
            }
        };

        //配置过程参数(采集参数、配方参数)
        traceModel.Params = new List<TraceParamModel>();
        foreach (var item in workSection.ProcessParameters)
        {
            string _value = "";
            if (item.Name == "分拣方向")
            {
                _value = "短管分拣";
            }
            if (item.Name == "分拣托盘号")
            {
                _value = input.ContinerNo;
            }
            if (item.Name == "分拣人")
            {
                _value = myCurrentUser.UserAccount;
            }
            //item.Key
            TraceParamModel traceParamModel = new TraceParamModel()
            {
                Key = item.Key,
                Value = _value
            };
            traceModel.Params.Add(traceParamModel);
        };
        foreach (var item in workSection.FormulaParameters)
        {
            string _value = "";
            if (item.Name == "分拣方向")
            {
                _value = "短管分拣";
            }
            if (item.Name == "分拣托盘号")
            {
                _value = input.ContinerNo;
            }
            if (item.Name == "分拣人")
            {
                _value = myCurrentUser.UserAccount;
            }
            //item.Key
            TraceParamModel traceParamModel = new TraceParamModel()
            {
                Key = item.Key,
                Value = _value
            };
            traceModel.Params.Add(traceParamModel);
        };

        traceModel.MaterialParams = _MaterialParams;

        await traceProvider.CreateTraceAsync(traceModel);

        var response = new MesOrderResponse
        {
            Code = "200",
            Data = "",
            Message = "处理成功",
            Time = DateTime.UtcNow
        };
        return response;
    }

    /// <summary>
    /// 创建作业计划
    /// </summary>
    /// <param name="input"></param>
    /// <param name="_serviceProvider"></param>
    /// <param name="workPlanAppService"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    public async Task<MesOrderResponse> CommonCreatebyApsAsync(List<WorkPlanInput> input, IServiceProvider _serviceProvider,
    WorkPlanAppService workPlanAppService,
    string userId, string userAccount
    )
    {

        if (input == null)
        {
            throw new UserFriendlyException("输入参数不能为空");
        }

        if (input.Count == 0)
        {
            throw new UserFriendlyException("输入参数Data不能为空");
        }

        //写死 打码内容
        foreach (var item in input)
        {
            //格式 管段编码,管段名称,船号,项目号
            item.MarkingContent = item.PipeSpecCode + "," + item.PipeSectionName + "," + item.ShipNumber + "," + item.ProjectNumber;
        }

        //校验数据
        //1、原料标识相同的不能存在于两个 管段编号中
        //var validationResult = ValidateUniqueDataIdentifierPerPipeSection(input);
        //if (!validationResult.isValid)
        //{
        //    处理验证失败的情况
        //    throw new UserFriendlyException($"验证失败: {validationResult.errorMessage}");
        //    返回错误信息给客户端或进行其他处理
        //}


        var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

        var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
        var productProvider = _serviceProvider.GetRequiredService<IProductProvider>();
        var formulaProvider = _serviceProvider.GetRequiredService<IFormulaProvider>();

        var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();

        List<OrderModel> orderModels = new List<OrderModel>();

        #region 事务

        using var scope = _serviceProvider.CreateScope();
        var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
        using var uow = unitOfWorkManager.Begin(requiresNew: true);

        try
        {
            #region 数据处理

            //按照 原料标识 分组
            var groupTask = input.GroupBy(x => x.DataIdentifier);
            foreach (var gTask in groupTask)
            {



                //var product = await productProvider.FindByNameAsync(orderItem.PipeSectionName);
                //if (product == null)
                //{
                //    throw new UserFriendlyException($"产品名称[{orderItem.PipeSectionName}]不存在");
                //}

                //var formula = await formulaProvider.GetFormulaAsync(product.Id);
                //if (formula == null)
                //{
                //    throw new UserFriendlyException($"产品型号[{orderItem.MaterialCode}]无关联配方");
                //}
                //首先要创建 打码切割的工单 
                var productForCut = await productProvider.FindByNameAsync("切割原料管");
                if (productForCut == null)
                {
                    throw new UserFriendlyException($"产品名称[切割原料管]不存在");
                }
                var formulaForCut = await formulaProvider.GetFormulaAsync(productForCut.Id);
                if (formulaForCut == null)
                {
                    throw new UserFriendlyException($"产品名称[切割原料管]无关联配方");
                }
                //按照 管段编号 分组
                var group = gTask.ToList().GroupBy(x => x.PipeSpecCode);
                foreach (var item in group)
                {
                    var prodOrderNo = "Order_" + item.Key;
                    var order = await orderManager.GetByCodeAsync(prodOrderNo);
                    if (order != null)
                    {
                        //throw new UserFriendlyException($"生产工单[{prodOrderNo}]已存在");
                        continue;
                    }

                    OrderModel orderModelForCut = new OrderModel()
                    {
                        Id = Guid.NewGuid(),
                        Code = prodOrderNo,
                        Source = "APS推送",
                        PlanStartTime = gTask.ToList().First().PlannedStartTime,
                        PlanFinishTime = gTask.ToList().First().PlannedEndTime,
                        PlanQty = 1,
                        Status = OrderStatus.NotActive,
                        Product = new AssociationProductModel() { Id = productForCut.Id, Name = productForCut.Name, Model = productForCut.Model, ShortNumber = productForCut.ShortNumber },
                        Formula = new AssociationFormulaModel() { Id = formulaForCut.Id, Code = formulaForCut.Code, Name = formulaForCut.Name }
                    };
                    orderModelForCut.ExtraProperties["OuterDiameter"] = gTask.ToList().First().OuterDiameter;//外径
                    orderModelForCut.ExtraProperties["Material"] = gTask.ToList().First().Material;//材质
                    orderModelForCut.ExtraProperties["Length"] = gTask.ToList().First().Length;//长度
                    orderModelForCut.ExtraProperties["DataIdentifier"] = gTask.ToList().First().DataIdentifier;//原料标识
                    orderModelForCut.ExtraProperties["MaterialMode"] = gTask.ToList().First().MaterialMode;//原料类型
                    orderModelForCut.ExtraProperties["PipeFittingCode"] = gTask.ToList().First().PipeFittingCode;//管段编号

                    var orderForCut = await orderManager.GetByCodeAsync(orderModelForCut.Code);
                    if (orderForCut != null)
                    {
                        //throw new UserFriendlyException($"工单[{orderModelForCut.Code}]已存在");
                        //不再抛异常，直接跳过
                        break;
                    }

                    var orderModelResultForCut = await orderManager.CreateAsync(orderModelForCut);
                    if (orderModelResultForCut == null)
                    {
                        throw new UserFriendlyException($"工单[{orderModelForCut.Code}]创建失败");
                    }
                    orderModels.Add(orderModelResultForCut);


                    //OrderModel orderModel = new OrderModel();
                    //orderModel.Id = Guid.NewGuid();
                    //orderModel.Code = orderItem.TaskCode;
                    //orderModel.Source = "APS推送";
                    //orderModel.Product = new AssociationProductModel() { Id = product.Id, Name = product.Name, Model = product.Model, ShortNumber = product.ShortNumber };
                    ////orderModel.Formula = new AssociationFormulaModel() { Id = formula.Id, Code = formula.Code, Name = formula.Name };
                    //orderModel.PlanStartTime = orderItem.PlannedStartTime;
                    //orderModel.PlanFinishTime = orderItem.PlannedEndTime;
                    //orderModel.PlanQty = (ulong?)orderItem.OrderQty;
                    //orderModel.Status = OrderStatus.NotActive;
                    //orderModel.ExtraProperties["Source"] = "ddd";
                    //var source = orderModel.ExtraProperties["Source"];
                    //var orderModelResult = await orderManager.CreateAsync(orderModel);
                    //if (orderModelResult == null)
                    //{
                    //    throw new UserFriendlyException($"工单[{orderItem.TaskCode}]创建失败");
                    //}
                    //orderModels.Add(orderModelResult);
                }


                //保存到 scms_callmaterialorders 表中
                CallMaterialOrderCreateDto insertObjForOrder = new CallMaterialOrderCreateDto()
                {
                    CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.未执行,
                    DataIdentifier = gTask.Key,
                    MaterialMode = gTask.ToList().First().MaterialMode,
                    CreatorName = userAccount,
                    Quantity = 1
                };

                await callMaterialOrderAppService.CreateAsync(insertObjForOrder);
            }



            //throw new UserFriendlyException($"主动触发失败");
            //保存到  scms_workplans 表中
            foreach (var item in input)
            {
                var insertObj = ObjectMapper.Map<WorkPlanInput, WorkPlanCreateDto>(item);
                //insertObj.OrgMaterialCode = "1111";
                insertObj.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.未执行;
                insertObj.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.未生产;
                insertObj.Sort = 1;
                insertObj.CreatorName = userAccount;
                insertObj.Remark = "系统导入";
                await workPlanAppService.CreateAsync(insertObj);

                //增加新增计划任务表数据 【Editby shaocx,2025-05-20】
                var org_insertTaskObj = ObjectMapper.Map<WorkPlanCreateDto, WorkTaskCreateDto>(insertObj);
                org_insertTaskObj.Son_TaskCode = insertObj.TaskCode;
                await workTaskAppService.CreateAsync(org_insertTaskObj);
                if (insertObj.ProcessName == "切割工序")
                {//新建 分拣工序
                    var insertTaskObj = ObjectMapper.Map<WorkPlanCreateDto, WorkTaskCreateDto>(insertObj);
                    insertTaskObj.Son_TaskCode = insertObj.TaskCode + "_1";
                    insertTaskObj.ProcessName = "分拣工序";
                    await workTaskAppService.CreateAsync(insertTaskObj);
                }
                else if (insertObj.ProcessName == "装配工序")
                {//新建 法兰冲码工序(多个)
                 //目前暂时搞成一个法兰
                    var insertTaskObj = ObjectMapper.Map<WorkPlanCreateDto, WorkTaskCreateDto>(insertObj);
                    insertTaskObj.Son_TaskCode = insertObj.TaskCode + "_1";
                    insertTaskObj.ProcessName = "法兰冲码工序";
                    await workTaskAppService.CreateAsync(insertTaskObj);
                }
            }

            #endregion

            await uow.CompleteAsync();
        }
        catch (Exception ex)
        {
            await uow.RollbackAsync();
            throw ex;
        }
        finally
        {

        }



        #endregion



        // 发布事件
        //await _eventBus.PublishAsync(new EntityChangedEto("MESCREATE", input, null, EntityChangeType.Add, true));

        var response = new MesOrderResponse
        {
            Code = "000000",
            Data = orderModels,
            Message = "处理成功",
            Time = DateTime.UtcNow
        };
        return response;
    }

    /// <summary>
    /// 验证原料标识相同的记录不能存在于两个不同的管段编号中
    /// </summary>
    /// <param name="inputs">作业计划输入参数列表</param>
    /// <returns>验证结果，包含是否通过验证及错误信息</returns>
    public static (bool isValid, string errorMessage) ValidateUniqueDataIdentifierPerPipeSection(List<WorkPlanInput> inputs)
    {
        if (inputs == null || !inputs.Any())
        {
            return (true, string.Empty);
        }

        // 使用Lookup分组，键为原料标识，值为对应的管段编号集合
        var dataIdentifierGroups = inputs.ToLookup(x => x.DataIdentifier, x => x.PipeSpecCode);

        foreach (var group in dataIdentifierGroups)
        {
            // 忽略空的原料标识
            if (string.IsNullOrEmpty(group.Key))
            {
                continue;
            }

            // 获取当前原料标识对应的唯一管段编号集合
            var uniquePipeSections = group.Distinct().ToList();

            // 如果存在多个不同的管段编号，则违反规则
            if (uniquePipeSections.Count > 1)
            {
                return (false, $"原料标识 '{group.Key}' 存在于多个不同的管段编号中: {string.Join(", ", uniquePipeSections)}");
            }
        }

        return (true, string.Empty);
    }


    /// <summary>
    /// 根据原料标识进行叫料操作
    /// </summary>
    /// <param name="dataIdentifier">原料标识</param>
    /// <param name="_serviceProvider">服务提供者</param>
    /// <returns>操作结果</returns>
    /// <exception cref="UserFriendlyException">当数据不存在或状态不允许叫料时抛出</exception>
    public async Task<MesOrderResponse> CallMaterial(CallMaterialByDataIdentifierInput input, IServiceProvider _serviceProvider, MyCurrentUser myCurrentUser)
    {
        if (string.IsNullOrEmpty(input.Id.ToString()))
        {
            throw new UserFriendlyException("原料标识不能为空");
        }

        var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
        var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
        var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
        var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
        var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();

        // 查找数据

        var callMaterialOrder = await callMaterialOrderRepository.GetAsync(input.Id);
        if (callMaterialOrder == null)
        {
            throw new UserFriendlyException($"找不到叫料记录");
        }

        // 验证状态
        if (callMaterialOrder.CallMaterialStatus != Domain.Shared.Enums.CallMaterialStatusEnum.未执行)
        {
            //throw new UserFriendlyException($"原料标识为 '{callMaterialOrder.DataIdentifier}' 的叫料记录状态为 '{callMaterialOrder.CallMaterialStatus}'，不允许叫料");
        }

        //TODO:这里调用wms的叫料接口
        try
        {
            List<LMesCallMaterialInput> param = new List<LMesCallMaterialInput>() {
             new LMesCallMaterialInput(){
                     DataIdentifier=callMaterialOrder.DataIdentifier,
                      MaterialMode=callMaterialOrder.MaterialMode,
             }
        };
            string baseUrl = @"http://127.0.0.1:18000/api/v1/HIAWms/";
            string url = baseUrl + "lMesOperate/LMesCallMaterial";
            string json = JsonConvert.SerializeObject(param);
            var result = HttpApiRequest.HttpPost(url, json);

            var res = JsonConvert.DeserializeObject<CmsApiResponse<List<MyCallMaterialOutput>>>(result);
            if (res.Code == 200)
            {
                var retData = res.Data;
                callMaterialOrder.MaterialBatch = retData[0].MaterialBatch;
                callMaterialOrder.WmsTaskNo = retData[0].TaskNo;
                callMaterialOrder.WmsRetResult = res.Message;
            }
            else
            {
                throw new UserFriendlyException(res.Message);
            }
            //*/
        }
        catch (Exception)
        {

            throw;
        }


        // 更新数据
        //callMaterialOrder.MaterialBatch = GenerateRandomBatch();//wms返回的原料批次
        //callMaterialOrder.WmsRetResult = "成功";
        //callMaterialOrder.WmsTaskNo = GenerateRandomTaskNo();
        callMaterialOrder.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
        callMaterialOrder.LastModifierName = "SuperAdmin";

        await callMaterialOrderRepository.UpdateAsync(callMaterialOrder);

        //更新作业计划表
        var workPlanList = await workPlanRepository.GetListByFilterAsync(x => x.DataIdentifier == callMaterialOrder.DataIdentifier);
        foreach (var item in workPlanList)
        {
            item.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
            item.LastModifierName = "SuperAdmin";
        }
        await workPlanRepository.UpdateManyAsync(workPlanList);

        //更新作业任务表
        var workTaskList = await workTaskRepository.GetListByFilterAsync(x => x.DataIdentifier == callMaterialOrder.DataIdentifier);
        foreach (var item in workTaskList)
        {
            item.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
            item.LastModifierName = "SuperAdmin";
        }
        await workTaskRepository.UpdateManyAsync(workTaskList);

        //新增叫料记录表
        var callMaterialOrderRecord = new CallMaterialOrderRecord()
        {
            CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成,
            MaterialBatch = callMaterialOrder.MaterialBatch,
            MaterialMode = callMaterialOrder.MaterialMode,
            DataIdentifier = callMaterialOrder.DataIdentifier,
            Quantity = 1,
            WmsRetResult = callMaterialOrder.WmsRetResult,
            WmsTaskNo = callMaterialOrder.WmsTaskNo,
            CreatorName = "SuperAdmin"
        };
        await callMaterialOrderRecordRepository.InsertAsync(callMaterialOrderRecord);

        //更新工单表的状态
        var pipeSpecCodeList = workPlanList.Select(x => x.PipeSpecCode).Distinct().ToList();
        foreach (var item in pipeSpecCodeList)
        {
            var prodOrderNo = "Order_" + item;
            var order = await orderManager.GetByCodeAsync(prodOrderNo);
            if (order != null)
            {
                order.ExtraProperties["CallMaterialStatus"] = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成.ToString();
            }
            await orderManager.UpdateAsync(order);
        }


        // 返回结果
        var response = new MesOrderResponse
        {
            Code = "200",
            Message = "叫料成功",
            Time = DateTime.UtcNow
        };
        return response;
    }

    /// <summary>
    ///装配/焊接开工
    /// </summary>
    /// <param name="input"></param>
    /// <param name="_serviceProvider"></param>
    /// <param name="myCurrentUser"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    public async Task<MesOrderResponse> StartProduction(StartProductionInput input, IServiceProvider _serviceProvider, MyCurrentUser myCurrentUser)
    {
        if (string.IsNullOrEmpty(input.TaskCode.ToString()))
        {
            throw new UserFriendlyException("任务编码不能为空");
        }

        string processName = "";

        VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
        var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
        var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
        var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
        var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
        var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
        var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

        // 查找数据
        var workTask = await workTaskRepository.GetSingleByFilterAsync(x => x.TaskCode == input.TaskCode);
        if (workTask == null)
        {
            throw new UserFriendlyException($"找不到作业计划");
        }
        var workPlan = await workPlanRepository.GetSingleByFilterAsync(x => x.TaskCode == input.TaskCode);
        if (workPlan == null)
        {
            throw new UserFriendlyException($"找不到作业计划");
        }
        if (workPlan.ProcessName == "装配工序")
        {
            processName = "装配";
        }
        else if (workPlan.ProcessName == "焊接工序")
        {
            processName = "焊接";
        }

        // 验证状态
        if (workPlan.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.暂停中 && workPlan.WorkPlanStatus != Domain.Shared.Enums.WorkPlanStatusEnum.未生产)
        {
            //暂时注释
            //throw new UserFriendlyException($"任务编码 '{input.TaskCode}' 的录状态为 '{workPlan.WorkPlanStatus}'，不允许开工");
        }

        var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == workPlan.DataIdentifier);
        #region 事务

        using var scope = _serviceProvider.CreateScope();
        var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
        using var uow = unitOfWorkManager.Begin(requiresNew: true);

        try
        {
            #region 数据处理

            //1、更新作业计划表为 生产中
            //2、给PLC发工艺参数指令,并写入 plc中 产品id
            //if (workPlan.ProcessName == "装配工序")
            //{
            //    workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
            //}
            //else if (workPlan.ProcessName == "焊接工序")
            //{
            //    workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
            //}
            workPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;
            workTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.生产中;

            await workPlanRepository.UpdateAsync(workPlan);

            Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
                        {
                            { $"{processName}_ProductID", workPlan.PipeSpecCode },
                            { $"{processName}管段编码", workPlan.PipeSpecCode },
                            { $"{processName}管段名称", workPlan.PipeSectionName },
                            { $"{processName}原料管批次", callMaterialOrder.MaterialBatch },
                            { $"{processName}原料管型号", callMaterialOrder.MaterialMode },
                            { $"{processName}原料管标识", callMaterialOrder.DataIdentifier },
                            { $"{processName}项目号", workPlan.ProjectNumber },
                            { $"{processName}船号", workPlan.ShipNumber },

                            //采集数据模拟写入
                            { $"{processName}压力", "10.0 MPa" },
                            { $"{processName}速度", "18mm/s"},

                            { $"{processName}人", myCurrentUser.UserAccount},
                            { $"{processName}间隙","15mm"},
                            { $"{processName}位置", "10,23,24"},
                        };
            _variableService.WriteValueAsync(keyValuePairs);


            #endregion

            await uow.CompleteAsync();

            // 返回结果
            var response = new MesOrderResponse
            {
                Code = "200",
                Message = "处理成功",
                Time = DateTime.UtcNow
            };
            return response;
        }
        catch (Exception)
        {
            await uow.RollbackAsync();
            throw;
        }
        finally
        {

        }



        #endregion
    }



    /// <summary>
    /// 装配工序完工
    /// </summary>
    /// <param name="_serviceProvider"></param>
    /// <param name="input"></param>
    /// <param name="myCurrentUser"></param>
    /// <returns></returns>
    public async Task<MesOrderResponse> CompleteAssemblyProcess(IServiceProvider _serviceProvider, CompleteAssemblyProcessInput input, MyCurrentUser myCurrentUser)
    {
        //1、记录分拣记录表
        //2、更新作业计划表的状态 =已分拣
        //3、写入 分拣变量
        //4、写入追溯报表
        //5、物料组盘

        if (string.IsNullOrEmpty(input.PipeSpecCode))
        {
            throw new UserFriendlyException($"管段编码不能为空");
        }


        VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
        var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
        var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
        var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
        var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
        var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
        var workTaskAppService = _serviceProvider.GetRequiredService<IWorkTaskAppService>();
        var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
        var workTaskRepository = _serviceProvider.GetRequiredService<IWorkTaskRepository>();
        var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

        string processName = "";
        var firstWorkTask = await workTaskAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == input.ProcessName);
        if (firstWorkTask == null)
        {
            throw new UserFriendlyException($"找不到作业计划");
        }
        //物料参数列表
        var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode && x.ProcessName == input.ProcessName);
        if (firstWorkPlan == null)
        {
            throw new UserFriendlyException($"找不到作业计划");
        }
        if (firstWorkPlan.ProcessName == "装配工序")
        {
            processName = "装配";
        }
        else if (firstWorkPlan.ProcessName == "焊接工序")
        {
            processName = "焊接";
        }

        await CompleteHandleOutStoreFinish(_serviceProvider, processName, true);

        //根据工序名获取工序对象
        var workSection = await _workSectionManager.GetByNameAsync($"{processName}工序");
        var workStation = await _workStationManager.GetByNameAsync($"{processName}工位");
        //写入追溯报表
        var finishTime = DateTime.Now;
        TraceModel traceModel = new TraceModel()
        {
            SerialNumber = input.PipeSpecCode,
            WorkSectionId = workSection.Id,
            WorkSectionName = workSection.Name,
            WorkStationName = workStation.Name,

            FinishTime = finishTime,
            IsQualified = true,
            UnqualifiedReason = "",
            ProductModel = "",
            ProductName = "",

        };
        traceModel.Params = new List<TraceParamModel>();
        foreach (var item in workSection.ProcessParameters)
        {
            var value = "ssss";
            traceModel.Params.Add(new TraceParamModel()
            {
                Key = item.Key,
                Value = value.SafeString()
            });
        }

        #region 事务

        using var scope = _serviceProvider.CreateScope();
        var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
        using var uow = unitOfWorkManager.Begin(requiresNew: true);

        try
        {
            #region 数据处理

            firstWorkTask.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
            await workTaskRepository.UpdateAsync(firstWorkTask);

            firstWorkPlan.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.已完成;
            await workPlanRepository.UpdateAsync(firstWorkPlan);

            var callMaterialOrder = await callMaterialOrderAppService.GetSingleByFilterAsync(x => x.DataIdentifier == firstWorkPlan.DataIdentifier);

            var rawPipe_DataIdentifier = await materialProvider.FindByNameAsync("原料管标识");
            var rawPipe_MaterialMode = await materialProvider.FindByNameAsync("原料管型号");
            var rawPipe_Batch = await materialProvider.FindByNameAsync("原料管批次");
            var rawPipe_ProjectNumber = await materialProvider.FindByNameAsync("项目号");
            var rawPipe_ShipNumber = await materialProvider.FindByNameAsync("船号");
            List<TraceMaterialModel> _MaterialParams = new List<TraceMaterialModel>();
            foreach (var item in workSection.MaterialParameters)
            {
                if (item.Name == "原料管型号")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_MaterialMode.MaterialId,
                        MaterialDetailId = rawPipe_MaterialMode.MaterialDetails.First().Id,
                        Value = firstWorkPlan.MaterialMode

                    });
                }
                if (item.Name == "原料管标识")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_DataIdentifier.MaterialId,
                        MaterialDetailId = rawPipe_DataIdentifier.MaterialDetails.First().Id,
                        Value = firstWorkPlan.DataIdentifier,

                    });
                }
                if (item.Name == "原料管批次")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_Batch.MaterialId,
                        MaterialDetailId = rawPipe_Batch.MaterialDetails.First().Id,
                        Value = callMaterialOrder.MaterialBatch,//批次暂时写死

                    });
                }
                if (item.Name == "项目号")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_ProjectNumber.MaterialId,
                        MaterialDetailId = rawPipe_ProjectNumber.MaterialDetails.First().Id,
                        Value = firstWorkPlan.ProjectNumber,

                    });
                }
                if (item.Name == "船号")
                {
                    _MaterialParams.Add(new TraceMaterialModel()
                    {
                        Key = item.Key,
                        Quantity = 1,
                        MaterialId = rawPipe_ShipNumber.MaterialId,
                        MaterialDetailId = rawPipe_ShipNumber.MaterialDetails.First().Id,
                        Value = firstWorkPlan.ShipNumber,

                    });
                }
            };

            //配置过程参数(采集参数、配方参数)
            traceModel.Params = new List<TraceParamModel>();
            foreach (var item in workSection.ProcessParameters)
            {
                string _value = "";

                //采集参数
                if (item.Name == $"{processName}压力")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}压力");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}位置")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}位置");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}速度")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}速度");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }

                if (item.Name == $"{processName}间隙")
                {
                    _value = "15mm";
                }
                if (item.Name == $"{processName}人")
                {
                    _value = myCurrentUser.UserAccount;
                }
                //item.Key
                TraceParamModel traceParamModel = new TraceParamModel()
                {
                    Key = item.Key,
                    Value = _value
                };
                traceModel.Params.Add(traceParamModel);
            };
            foreach (var item in workSection.FormulaParameters)
            {
                string _value = "";

                //采集参数
                if (item.Name == $"{processName}压力")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}压力");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}位置")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}位置");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }
                if (item.Name == $"{processName}速度")
                {
                    var _getValue = await _variableService.ReadValueAsync($"{processName}速度");
                    _value = _getValue.Content.Value.SafeString().ToString();
                }

                if (item.Name == $"{processName}间隙")
                {
                    _value = "15mm";
                }
                if (item.Name == $"{processName}人")
                {
                    _value = myCurrentUser.UserAccount;
                }
                //item.Key
                TraceParamModel traceParamModel = new TraceParamModel()
                {
                    Key = item.Key,
                    Value = _value
                };
                traceModel.Params.Add(traceParamModel);
            };

            traceModel.MaterialParams = _MaterialParams;

            await traceProvider.CreateTraceAsync(traceModel);

            var response = new MesOrderResponse
            {
                Code = "200",
                Data = "",
                Message = "处理成功",
                Time = DateTime.UtcNow
            };
            return response;

            #endregion

            await uow.CompleteAsync();
        }
        catch (Exception)
        {
            await uow.RollbackAsync();
            throw;
        }
        finally
        {

        }



        #endregion

    }


    /// <summary>
    /// 公共处理 响应出站完成信号
    /// </summary>
    /// <param name="_serviceProvider"></param>
    /// <param name="input"></param>
    /// <param name="myCurrentUser"></param>
    /// <returns></returns>
    public async Task CompleteHandleOutStoreFinish(IServiceProvider _serviceProvider, string processName, bool isOutResult)
    {

        VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();

        Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
                    {
                        { $"{processName}出站完成",isOutResult},
                        { $"{processName}出站结果",isOutResult? "成功":""},
                    };
        await _variableService.WriteValueAsync(keyValuePairs);

    }


    /// <summary>
    /// 分拣时获取生产计划和分配区域
    /// </summary>
    /// <param name="input"></param>
    /// <param name="_serviceProvider"></param>
    /// <param name="myCurrentUser"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    public async Task<CmsApiResponse<PickOutput>> GetPickRetAsync(GetWorkPlanInput input, IServiceProvider _serviceProvider, MyCurrentUser myCurrentUser)
    {


        var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
        var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
        var _workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();
        var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
        var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();

        // 查找数据

        WorkPlanDto workPlanDto = await _workPlanAppService.FindSingleByFilterAsync(input);

        //TODO:这里调用wms的库存查询接口
        try
        {
            GetWmsMaterialStockInput param = new GetWmsMaterialStockInput()
            {
                RedundantField1 = workPlanDto.ProcessRouteNumber,
                RedundantField1_FilterMode = SearchFilterModeEnum.精准查询
            };

            string baseUrl = @"http://127.0.0.1:18000/api/v1/HIAWms/";
            string url = baseUrl + "LMesOperate/FindListByFilter";
            string json = JsonConvert.SerializeObject(param);
            var result = HttpApiRequest.HttpPost(url, json);
            var res = JsonConvert.DeserializeObject<CmsApiResponse<List<WmsMaterialStockDto>>>(result);
            if (res.Code == 200)
            {
                var retData = res.Data as List<WmsMaterialStockDto>;
                var data = new PickOutput()
                {
                    WorkPlan = workPlanDto,
                    PlaceNo = "",//待赋值
                    ContinerNo = ""//待赋值
                };
                if (retData?.Count > 0)
                {
                    data.PlaceNo = retData.First().PlaceNo;
                    data.ContinerNo = retData.First().ContainerNo;
                }

                var response = new CmsApiResponse<PickOutput>
                {
                    Code = 200,
                    Data = data,
                    Message = "处理成功",
                };
                return response;

            }
            else
            {
                throw new UserFriendlyException(res.Message);
            };
            //*/
            //模拟
            //var data = new PickOutput()
            //{
            //    WorkPlan = workPlanDto,
            //    PlaceNo = "",//待赋值
            //    ContinerNo = ""//待赋值
            //};
            //var response = new CmsApiResponse<PickOutput>
            //{
            //    Code = 200,
            //    Data = data,
            //    Message = "处理成功",
            //};
            //return response;

        }
        catch (Exception)
        {

            throw;
        }
    }

    /// <summary>
    /// 管段编码是否存在库存中
    /// </summary>
    /// <param name="pipeSpecCode"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    public async Task<WmsMaterialStockDto> IsExistInWms(string pipeSpecCode)
    {
        //TODO:这里调用wms的库存查询接口
        try
        {
            GetWmsMaterialStockInput param = new GetWmsMaterialStockInput()
            {
                RedundantField2 = pipeSpecCode,
                RedundantField2_FilterMode = SearchFilterModeEnum.精准查询
            };

            string baseUrl = @"http://127.0.0.1:18000/api/v1/HIAWms/";
            string url = baseUrl + "LMesOperate/FindListByFilter";
            string json = JsonConvert.SerializeObject(param);
            var result = HttpApiRequest.HttpPost(url, json);
            var res = JsonConvert.DeserializeObject<CmsApiResponse<List<WmsMaterialStockDto>>>(result);
            if (res.Code == 200)
            {
                var retData = res.Data as List<WmsMaterialStockDto>;
                if (retData?.Count > 0)
                {
                    return retData.First();
                }
                return null;

            }
            else
            {
                throw new UserFriendlyException(res.Message);
            };
        }
        catch (Exception)
        {

            throw;
        }
    }

    /// <summary>
    /// 生成随机的WmsTaskNo
    /// </summary>
    /// <returns>随机生成的任务编号</returns>
    private string GenerateRandomTaskNo()
    {
        // 获取当前时间戳（从1970-01-01 00:00:00 UTC到现在的秒数）
        long timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();

        // 生成前缀
        return $"WMS{timestamp}";
    }

    private string GenerateRandomBatch()
    {
        // 获取当前时间戳（从1970-01-01 00:00:00 UTC到现在的秒数）
        long timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();

        // 生成前缀
        return $"Batch{timestamp}";
    }
}