using System.Reflection.Emit;
using System.Text;
using Aop.Api.Domain;
using DbModels;
using JNPF.Common.Core.Manager;
using JNPF.Common.Enums;
using JNPF.Common.Extension;
using JNPF.Common.Security;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.Extensitions.EventBus;
using JNPF.FriendlyException;
using JNPF.Logging;
using JNPF.Systems.Interfaces.System;
using JNPF.VisualDev;
using JNPF.VisualDev.Entitys.Dto.VisualDevModelData;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using NPOI.SS.Formula.Functions;
using Org.BouncyCastle.Crypto.Generators;
using Senparc.Weixin.Work.AdvancedAPIs.MailList;
using SqlSugar;
using Tnb.BasicData;
using Tnb.BasicData.Entities;
using Tnb.BasicData.Entitys.Entity;
using Tnb.EquipMgr.Entities;
using Tnb.ProductionMgr.Entities;
using Tnb.ProductionMgr.Entities.Dto;
using Tnb.ProductionMgr.Entities.Dto.PrdManage;
using Tnb.ProductionMgr.Entities.Enums;
using Tnb.ProductionMgr.Interfaces;

namespace Tnb.ProductionMgr
{
    /// <summary>
    /// 生产计划管理
    /// </summary>
    [ApiDescriptionSettings(Tag = ModuleConst.Tag, Area = ModuleConst.Area, Order = 700)]
    [Route("api/[area]/[controller]/[action]")]
    [OverideVisualDev(ModuleId)]
    public class PrdMoService : IOverideVisualDevService, IPrdMoService, IDynamicApiController, ITransient
    {
        private const string ModuleId = "25567924238373";
        private readonly ISqlSugarRepository<PrdMo> _repository;
        private readonly IDataBaseManager _dataBaseManager;
        private readonly IUserManager _userManager;
        private readonly IDictionaryDataService _dictionaryDataService;

        public OverideVisualDevFunc OverideFuncs { get; } = new OverideVisualDevFunc();

        public PrdMoService(
            ISqlSugarRepository<PrdMo> repository,
            IDataBaseManager dataBaseManager,
            IUserManager userManager,
            IDictionaryDataService dictionaryDataService
            )
        {
            _repository = repository;
            _dataBaseManager = dataBaseManager;
            _userManager = userManager;
            _dictionaryDataService = dictionaryDataService;
            OverideFuncs.DeleteAsync = Delete;
        }



        #region Get

        /// <summary>
        /// 根据产品ID获取模具列表 
        /// </summary>
        /// <param name="itemId">产品ID</param>
        /// <returns></returns>
        /// <remarks>
        /// <br/>return results:
        /// <br/>[
        /// <br/>    {
        /// <br/>        mold_code:模具编号
        /// <br/>        mold_name:模具名称
        /// <br/>        item_name:产品名称
        /// <br/>        item_code:产品编号
        /// <br/>        cavity_qty:模穴数
        /// <br/>    }
        /// <br/>]
        /// </remarks>
        [HttpGet("{itemId}")]
        public async Task<dynamic> GetMoldListByItemId(string itemId)
        {
            var db = _repository.AsSugarClient();
            var list = await db.Queryable<Molds>().InnerJoin<BasMaterial>((a, b) => a.item_id == b.id)
                                  .Where((a, b) => a.item_id == itemId)
                                  .Select((a, b) => new MoldListOutput
                                  {
                                      mold_id = a.id,
                                      mold_code = a.mold_code,
                                      mold_name = a.mold_name,
                                      item_name = b.name,
                                      cavity_qty = a.cavity_qty,
                                      item_code = b.code,
                                  })
                                  .ToListAsync();
            return list;

        }
        /// <summary>
        /// 根据模具Id获取设备列表
        /// </summary>
        /// <param name="moldId"></param>
        /// <returns></returns>
        [HttpGet("{moldId}")]
        public async Task<dynamic> GetEquipmentListByMoldId(string moldId)
        {
            var items = await _repository.AsSugarClient().Queryable<EqpEquipment>()
                              .Where(it => it.mold_id == moldId)
                              .Select(it => new EquipmentListOutput
                              {
                                  eqp_id = it.id,
                                  eqp_code = it.eqp_code,
                                  eqp_type_code = it.eqp_type_code,
                                  eqp_machine_num = it.eqp_machine_num,
                                  tonnage = it.tonnage,
                                  task_list_qty = SqlFunc.Subqueryable<PrdTask>().Where(x => x.eqp_id == it.id).Count(),
                                  estimated_end_date = SqlFunc.Subqueryable<PrdTask>().Where(x => x.eqp_id == it.id).OrderByDesc(o => o.estimated_end_date).Select(x => x.estimated_end_date)
                              })
                              .Mapper(x =>
                              {
                                  x.first_date = x.estimated_end_date.HasValue ? x.estimated_end_date.Value.ToString("yyyy-MM-dd HH:mm:ss") : "";
                              })
                              .ToListAsync();
            return items;

        }

        /// <summary>
        /// 工单调整-生产任务重新排序
        /// </summary>
        /// <param name="eqpId">设备ID</param>
        /// <returns>排序后生产任务列表</returns>
        /// <remarks>
        /// returns:
        /// <br/>[
        /// <br/>    {
        /// <br/>        no:生产序号
        /// <br/>        mo_id：工单编号
        /// <br/>        group_flag：同组标识
        /// <br/>        plan_qty:计划生产数量
        /// <br/>        comple_qty:完成数量
        /// <br/>        item_name:产品名称
        /// <br/>        mold_code:模具编号
        /// <br/>    }
        /// <br/>]
        /// </remarks>
        [HttpGet("{eqpId}")]
        public async Task<dynamic> PrdTaskSort(string eqpId)
        {
            var taskStatusDic = await _dictionaryDataService.GetDicByTypeId(DictConst.PrdTaskStatusTypeId);
            var list = await _repository.AsSugarClient().Queryable<PrdTask>()
                .Where(it => it.eqp_id == eqpId)
                .OrderBy(o => o.estimated_start_date)
                .ToListAsync();
            var data = list.Select((x, idx) => new PrdTaskSortOutput
            {
                no = idx + 1,
                mo_id = x.mo_id,
                status = taskStatusDic.ContainsKey(x.status) ? taskStatusDic[x.status].ToString() : "",
                group_flag = x.group_flag,
                plan_qty = x.plan_qty,
                comple_qty = x.comple_qty,
                item_name = x.item_name,
                mold_code = x.mold_code,
            })
            .ToList();
            return data;
        }
        /// <summary>
        /// 查看生产任务操作记录
        /// </summary>
        /// <param name="taskId">任务ID</param>
        /// <returns></returns>
        [HttpGet("{taskId}")]
        public async Task<dynamic> GetMoOperRecord(string taskId)
        {
            var list = await _repository.AsSugarClient().Queryable<PrdTaskLog>().Where(it => it.id == taskId).ToListAsync();
            var data = list.Adapt<List<PrdTaskOperOutput>>();
            var dic = await _dictionaryDataService.GetDicByTypeId(DictConst.PrdTaskStatusTypeId);
            _repository.AsSugarClient().ThenMapper(data, x => x.statusName = dic.ContainsKey(x.status) ? dic[x.status].ToString() : "");
            return data;
        }
        /// <summary>
        /// 根据任务单号获取提报记录明细
        /// </summary>
        /// <param name="icmoCode">任务单号</param>
        /// <remarks>
        /// returns:
        ///<br/> {
        ///<br/>     icmo_qty:任务计划数量
        ///<br/>     reported_work_qty:已报工数量
        ///<br/>     reported_qty:报工数量
        ///<br/>     prd_qty:生产数量
        ///<br/> }
        /// </remarks>
        [HttpGet("{icmoCode}")]
        public async Task<dynamic> GetPrdReportByIcmoCode(string icmoCode)
        {
            var db = _repository.AsSugarClient();
            var res = await db.Queryable<PrdReport>().Where(it => it.icmo_code == icmoCode).Select(it => new PrdReportOutput
            {
                icmo_qty = it.icmo_qty,
                reported_work_qty = it.reported_work_qty,
                //reported_qty = it.reported_qty,
                prd_qty = it.prd_qty,
                scrap_qty = SqlFunc.Subqueryable<PrdScrapped>().Select(x => x.scrap_qty),
            })
            .Mapper(it =>
            {
                it.icmo_qty = it.icmo_qty ?? (db.Queryable<PrdTask>().First(it => it.icmo_code == icmoCode)?.scheduled_qty < 1 ? 0 : it.icmo_qty ?? db.Queryable<PrdTask>().First(it => it.icmo_code == icmoCode).scheduled_qty);
                it.reported_work_qty = it.reported_work_qty ?? 0;
                //it.reported_qty = it.reported_qty ?? 0;
                it.prd_qty = it.prd_qty ?? 0;
                it.scrap_qty = it.scrap_qty ?? 0;
            })
            .FirstAsync();
            res ??= new PrdReportOutput
            {
                icmo_qty = db.Queryable<PrdTask>().First(it => it.icmo_code == icmoCode)?.scheduled_qty,
                reported_work_qty = 0,
                //reported_qty = 0,
                prd_qty = 0,
                scrap_qty = 0,
            };
            return res;
        }
        /// <summary>
        /// 获取提报生产记录
        /// </summary>
        /// <param name="icmoCode"></param>
        /// <returns></returns>
        [HttpGet("{icmoCode}")]
        public async Task<dynamic> GetReportRecord(string icmoCode)
        {
            var db = _repository.AsSugarClient();
            var output = new SelfTestScrappedOutput();
            output.icmo_code = icmoCode;
            var scrap = (await db.Queryable<PrdScrapped>().FirstAsync(it => it.icmo_code == icmoCode));
            output.scrap_qty = scrap != null ? scrap.scrap_qty : 0;
            output.categoryItems = new List<SelfTestScrappedOutputItem>();
            var categorys = await db.Queryable<PrdScrappedDefectiveCagetory>().Where(it => it.icmo_code == icmoCode).ToListAsync();
            foreach (var category in categorys)
            {
                var categoryItem = category.Adapt<SelfTestScrappedOutputItem>();
                categoryItem.items = new List<PrdScrappedDefectiveItem>();
                var items = await db.Queryable<PrdScrappedDefectiveItem>().Where(it => it.defective_cagetory_id == category.id).ToListAsync();
                categoryItem.items.AddRange(items);
                output.categoryItems.Add(categoryItem);
            }
            return output;
        }

        #endregion

        #region Post

        /// <summary>
        /// 生产工单创建-生产工单下发
        /// </summary>
        /// <param name="input">生产工单下发输入参数</param>
        /// <returns></returns>
        [HttpPut]
        public async Task<dynamic> WorkOrderIssue(MoCrInput input)
        {
            if (input is null)
            {
                throw new ArgumentNullException(nameof(input));
            }
            if (input.Behavior.IsNullOrWhiteSpace())
            {
                throw new ArgumentException($"{nameof(input.Behavior)},not be null or empty");
            }

            var db = _repository.AsSugarClient();
            //获取同组工单的Id，一起下发
            var combineMoCodes = await db.Queryable<PrdMo>().Where(it => input.WorkOrderIds.Contains(it.id)).Select(it => it.combine_mo_code).ToListAsync();
            if (combineMoCodes?.Count > 0)
            {
                var moIds = await db.Queryable<PrdMo>().Where(it => combineMoCodes.Contains(it.combine_mo_code) && !input.WorkOrderIds.Contains(it.id)).Select(it => it.id).ToListAsync();
                input.WorkOrderIds = input.WorkOrderIds.Concat(moIds).ToList();
            }


            Tuple<string, string> getMoStatus(MoBehavior behavior)
            {
                Tuple<string, string> multi = null;
                switch (behavior)
                {
                    case MoBehavior.Release:
                        multi = Tuple.Create(DictConst.IssueId, DictConst.ToBeScheduledEncode);
                        break;
                    case MoBehavior.Closed:
                        multi = Tuple.Create(DictConst.MoCloseId, DictConst.ClosedEnCode);
                        break;
                }
                return multi!;
            }
            var behavior = input.Behavior.ToEnum<MoBehavior>();
            var multi = getMoStatus(behavior);

            var row = await db.Updateable<PrdMo>()
                          .SetColumns(it => new PrdMo { mo_status = multi.Item1, icmo_status = multi.Item2 })
                          .Where(it => input.WorkOrderIds.Contains(it.id))
                          .ExecuteCommandAsync();
            return (row > 0);
        }
        /// <summary>
        /// 关联同组工单
        /// </summary>
        /// <param name="input">关联同组工单输入参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<dynamic> RelevancySameGroupMo(MoCrInput input)
        {
            (bool executeRes, string errMsg) multi = (true, "");
            var list = await _repository.AsSugarClient().Queryable<PrdMo>()
                                                        .InnerJoin<Molds>((a, b) => a.item_code == b.item_id)
                                                        .Where((a, b) => input.WorkOrderIds.Contains(a.id))
                                                        .Select((a, b) => new
                                                        {
                                                            planDate = a.plan_start_date,
                                                            mold_code = b.mold_code,
                                                        }).ToListAsync();
            var planDateAll = true;
            var moldIdAll = true;
            if (list?.Count > 0)
            {
                var planDate = list.FirstOrDefault()?.planDate;
                var moldCode = list.FirstOrDefault()?.mold_code;

                planDateAll = list.Skip(1).All(x => x.planDate == planDate);
                moldIdAll = list.Skip(1).All(x => x.mold_code == moldCode);
                if (planDateAll && moldIdAll)
                {
                    var groupId = SnowflakeIdHelper.NextId();
                    multi.executeRes = await _repository.AsSugarClient().Updateable<PrdMo>()
                                                           .SetColumns(c => new PrdMo { combine_mo_code = groupId })
                                                           .Where(it => input.WorkOrderIds.Contains(it.id))
                                                           .ExecuteCommandHasChangeAsync();
                }
                else
                {
                    multi.executeRes = false;
                    if (!planDateAll)
                    {
                        throw new AppFriendlyException("计划开始日期不一致", null);
                    }
                    if (!moldIdAll)
                    {
                        throw new AppFriendlyException("未关联到同一模具下", null);
                    }
                }
            }
            return multi;
        }

        /// <summary>
        /// 取消关联
        /// </summary>
        /// <param name="input">取消关联输入参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<dynamic> CanelRelevancy(MoCrInput input)
        {
            return await _repository.AsSugarClient().Updateable<PrdMo>()
                                                    .SetColumns(c => new PrdMo { combine_mo_code = "" })
                                                    .Where(it => input.WorkOrderIds.Contains(it.id))
                                                    .ExecuteCommandHasChangeAsync();
        }

        /// <summary>
        /// 生产工单-生产排产
        /// </summary>
        /// <param name="input">
        ///<br/>{
        ///<br/>    Id:生产任务主键Id
        ///<br/>    MoType:工单类型 1、注塑/挤出 2、组装/包装
        ///<br/>    MoId:工单Id
        ///<br/>    ItemId:产品编号
        ///<br/>    ItemName:产品名称
        ///<br/>    MoldId:模具Id
        ///<br/>    MoldName:模具名称
        ///<br/>    EqpId:设备Id
        ///<br/>    EqpName:设备名称
        ///<br/>    LineId:产线编号
        ///<br/>    LineName:产线名称
        ///<br/>}
        /// </param>
        /// <returns></returns>

        [HttpPost]
        public async Task<dynamic> ProductionScheduling(ProductionSchedulingCrInput input)
        {
            var row = -1;
            if (input.mo_type.HasValue && input.mo_type.Value == 1)
            {
                input.id ??= SnowflakeIdHelper.NextId();
                var entity = input.Adapt<PrdTask>();
                entity.status = DictConst.ToBeStartedEnCode; //任务单状态默认，待排产
                entity.create_id = _userManager.UserId;
                entity.create_time = DateTime.Now;
                entity.prd_task_id = input.id;

                var db = _repository.AsSugarClient();
                try
                {
                    List<PrdMo> entities = new();
                    List<PrdTask> icmoEntities = new();
                    //根据工单Id查询同组工单号，进行同组工单排产处理
                    var combineMoCodes = await db.Queryable<PrdMo>().Where(it => it.id == input.mo_id).Select(it => it.combine_mo_code).Distinct().ToListAsync();
                    if (combineMoCodes?.Count > 0)
                    {
                        entities = await db.Queryable<PrdMo>().Where(it => combineMoCodes.Contains(it.combine_mo_code)).ToListAsync();
                    }

                    await db.Ado.BeginTranAsync();
                    //同组工单排产
                    if (entities.Count > 0)
                    {
                        icmoEntities = entities.Select(x => new PrdTask
                        {
                            id = SnowflakeIdHelper.NextId(),
                            item_id = x.id,
                            item_code = x.item_code,
                            mo_type = input.mo_type,
                            plan_start_date = x.plan_start_date,
                            plan_end_date = x.plan_end_date,
                        }).ToList();
                        icmoEntities.ForEach(x =>
                        {
                            x.status = DictConst.ToBeStartedEnCode; //任务单状态默认，待排产
                            x.create_id = _userManager.UserId;
                            x.create_time = DateTime.Now;
                            x.prd_task_id = x.id;
                        });
                        row = await db.Insertable(icmoEntities).ExecuteCommandAsync();
                        var icmoRecords = icmoEntities.Adapt<List<PrdTaskLog>>();
                        icmoRecords.ForEach(x =>
                        {
                            x.id = SnowflakeIdHelper.NextId();
                            x.status ??= DictConst.ToBeStartedEnCode;
                            x.create_id = _userManager.UserId;
                            x.create_time = DateTime.Now;
                            x.operator_name = _userManager.RealName;
                        });
                        var icmoIds = icmoRecords.Select(it => it.task_id).Distinct().ToList();
                        var statusMany = icmoRecords.Select(it => it.status).Distinct().ToList();
                        //任务状态变更时插入操作记录
                        var logEntities = await db.Queryable<PrdTaskLog>().Where(it => icmoIds.Contains(it.task_id)).ToListAsync();
                        if (logEntities?.Count > 0)
                        {
                            var dbTaskStatusList = logEntities.Select(x => x.status).Distinct().ToList();
                            var ultimatelyStatus = statusMany.Except(dbTaskStatusList).ToList();
                            icmoRecords = icmoRecords.Where(x => ultimatelyStatus.Contains(x.status)).ToList();
                        }
                        if (icmoRecords.Count > 0)
                        {
                            row = await db.Insertable(icmoRecords).ExecuteCommandAsync();
                        }
                    }
                    else
                    {
                        if (!input.mo_code.IsNullOrEmpty())
                        {
                            var icmoCode = await db.Queryable<PrdTask>().Where(it => !string.IsNullOrEmpty(it.icmo_code) && it.icmo_code.Contains(input.mo_code)).OrderByDescending(it => it.icmo_code).Select(it => it.icmo_code).FirstAsync();
                            if (icmoCode.IsNullOrEmpty())
                            {
                                entity.icmo_code = $"{input.mo_code}-01";
                            }
                            else
                            {
                                var pos = icmoCode.IndexOf("-", StringComparison.Ordinal);
                                if (pos > -1)
                                {
                                    var sb = new StringBuilder();
                                    var num = icmoCode.AsSpan().Slice(pos + 1).ToString().ParseToInt();
                                    var code = icmoCode.AsSpan().Slice(pos + 1).ToString();
                                    var n = (num + 1).ToString().PadLeft(2, '0');
                                    entity.icmo_code = sb.Append(code).Append(n).ToString();
                                }
                            }
                        }
                        row = await db.Storageable(entity).ExecuteCommandAsync();
                        var taskLogEntity = input.Adapt<PrdTaskLog>();
                        taskLogEntity.id ??= SnowflakeIdHelper.NextId();
                        taskLogEntity.task_id = input.id;
                        taskLogEntity.status ??= "ToBeStarted";
                        taskLogEntity.create_id = _userManager.UserId;
                        taskLogEntity.create_time = DateTime.Now;
                        taskLogEntity.operator_name = _userManager.RealName;

                        //任务状态变更时插入操作记录 
                        if (!db.Queryable<PrdTaskLog>().Where(it => it.task_id == input.id && it.status == taskLogEntity.status).Any())
                        {
                            row = await db.Insertable(taskLogEntity).ExecuteCommandAsync();
                        }
                    }

                    if (row > 0)
                    {
                        if (icmoEntities?.Count > 0 && combineMoCodes?.FirstOrDefault() is not null)
                        {
                            var moList = await db.Queryable<PrdMo>().Where(it => combineMoCodes.Contains(it.combine_mo_code)).ToListAsync();
                            var combinePlanQty = icmoEntities?.Sum(x => x.plan_qty); //合并工单后的计划数量
                            var combineScheduledQty = icmoEntities?.Sum(x => x.scheduled_qty); //合并后的已排产数量
                            if (combineScheduledQty < combinePlanQty)
                            {
                                icmoEntities!.ForEach(x =>
                                {
                                    var item = moList.Find(xx => xx.id == x.mo_id);
                                    if (item != null)
                                    {
                                        item.input_qty += x.scheduled_qty;
                                        item.mo_status = DictConst.WaitProductId;
                                    }
                                });
                            }
                            else
                            {
                                //如果已排产数量大于计划数量，修改工单状态为，待开工
                                if (combineScheduledQty >= combinePlanQty)
                                {
                                    icmoEntities!.ForEach(x =>
                                    {
                                        var item = moList.Find(xx => xx.id == x.mo_id);
                                        if (item != null)
                                        {
                                            item.input_qty += x.scheduled_qty;
                                            item.mo_status = DictConst.AlreadyId;
                                        }
                                    });
                                }
                            }
                            row = await db.Updateable(moList).ExecuteCommandAsync();

                        }
                        else
                        {
                            var obj = (await db.Queryable<PrdMo>().FirstAsync(it => it.id == input.mo_id));
                            obj.input_qty += entity.scheduled_qty;
                            string moStatus = "", icmoStatus = "";

                            //判断，已排产数量>=计划数量时将状态改为 已排产
                            if (obj.input_qty >= obj.plan_qty)
                            {
                                moStatus = DictConst.AlreadyId;
                                icmoStatus = DictConst.ToBeStartedEnCode;
                            }
                            else
                            {
                                //修改工单状态为待排产，同事修改已排产数量
                                moStatus = DictConst.WaitProductId;
                                icmoStatus = DictConst.ToBeScheduledEncode;
                            }
                            row = await db.Updateable<PrdMo>().SetColumns(it => new PrdMo
                            {
                                mo_status = moStatus,
                                icmo_status = icmoStatus,
                                input_qty = obj.input_qty
                            })
                            .Where(it => it.id == entity.mo_id).ExecuteCommandAsync();
                        }
                    }

                    await db.Ado.CommitTranAsync();
                }
                catch (Exception ex)
                {
                    JNPF.Logging.Log.Error("生产任务发布时发生错误", ex);
                    await db.Ado.RollbackTranAsync();
                }
            }
            return row > 0;
        }
        /// <summary>
        /// 生产任务下发，开始 、结束、完成
        /// </summary>
        /// <param name="input">输入参数</param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="NotImplementedException"></exception>
        [HttpPost]
        public async Task<dynamic> PrdTaskRelease(PrdTaskReleaseUpInput input)
        {
            var row = -1;
            if (input is null)
            {
                throw new ArgumentNullException(nameof(input));
            }
            if (input.TaskIds is null)
            {
                throw new ArgumentNullException(nameof(input.TaskIds));
            }
            if (input.Behavior.IsNullOrWhiteSpace())
            {
                throw new ArgumentException($"{nameof(input.Behavior)} not be null or empty");
            }
            string SetTaskStatus(PrdTaskBehavior behavior) => behavior switch
            {
                PrdTaskBehavior.Release => DictConst.ToBeStartedEnCode,
                PrdTaskBehavior.Start => DictConst.InProgressEnCode,
                PrdTaskBehavior.Closed => DictConst.ClosedEnCode,
                PrdTaskBehavior.Compled => DictConst.ComplatedEnCode,
                _ => throw new NotImplementedException(),
            };
            PrdTaskBehavior behavior = input.Behavior.ToEnum<PrdTaskBehavior>();
            var status = SetTaskStatus(behavior);
            var db = _repository.AsSugarClient();
            if (behavior == PrdTaskBehavior.Compled)
            {
                var list = await db.Queryable<PrdTask>().Where(it => input.TaskIds.Contains(it.id)).Select(it => it).ToListAsync();
                if (list?.Count > 0)
                {
                    var schedQtySum = list.Sum(x => x.scheduled_qty);
                    var planQtySum = list.Sum(x => x.plan_qty);
                    if (schedQtySum < planQtySum)
                    {
                        throw new AppFriendlyException("任务数量必须大于等于生产计划数量,才可完成", 500);
                    }
                }
            }
            row = await db.Updateable<PrdTask>()
                          .SetColumns(it => new PrdTask { status = status })
                          .Where(it => input.TaskIds.Contains(it.id))
                          .ExecuteCommandAsync();
            return (row > 0);
        }

        /// <summary>
        /// 生产任务单修改
        /// </summary>
        /// <param name="input">生产任务单修改输入参数</param>
        /// <returns></returns>
        /// <exception cref="AppFriendlyException"></exception>
        [HttpPost]
        public async Task<dynamic> IcmoModify(IcmoUpInput input)
        {
            var row = -1;
            var db = _repository.AsSugarClient();
            if (input.icmo_id.IsNullOrWhiteSpace())
                throw new ArgumentNullException(nameof(input.icmo_id));
            var icmoItem = await db.Queryable<PrdTask>().FirstAsync(it => it.id == input.icmo_id);
            switch (input.category)
            {
                case 1: //设备
                    var eqpItem = await db.Queryable<EqpEquipment>().FirstAsync(it => it.id == input.eqp_id);
                    icmoItem.eqp_id = eqpItem.id;
                    icmoItem.eqp_type_code = eqpItem.eqp_type_code;
                    if (input.scheduled_qty > icmoItem.plan_qty)
                    {
                        throw new AppFriendlyException("任务单数量不能大于计划数量", 500);
                    }
                    row = await db.Updateable<PrdMo>().SetColumns(it => new PrdMo { input_qty = input.scheduled_qty }).Where(it => it.id == input.mo_id).ExecuteCommandAsync();
                    break;
                case 2: //模具 
                    var moldItem = await db.Queryable<Molds>().FirstAsync(it => it.id == input.mold_id);
                    icmoItem.mold_id = moldItem.id;
                    icmoItem.mold_code = moldItem.mold_code;
                    icmoItem.mold_name = moldItem.mold_name;
                    icmoItem.mold_cavity_qty = moldItem.cavity_qty;
                    break;
            }
            row = await db.Updateable(icmoItem).ExecuteCommandAsync();
            return (row > 0);
        }
        /// <summary>
        /// 生产提报
        /// </summary>
        /// <param name="input"></param>
        /// <remarks>
        /// input:
        /// <br/>{
        /// <br/>    icmo_id:生产任务ID
        /// <br/>    icmo_code:任务单号
        /// <br/>    prd_qty：生产数量
        /// <br/>    reported_work_qty：已报工数量
        /// <br/>    reported_qty：提报数量
        /// <br/>    icmo_qty：生产任务量
        /// <br/>}
        /// </remarks>
        [HttpPost]
        public async Task<dynamic> PrdReport(PrdReportCrInput input)
        {
            var row = -1;
            var db = _repository.AsSugarClient();
            var report = await db.Queryable<PrdReport>().FirstAsync(it => it.icmo_code == input.icmo_code);
            if (report is not null)
            {
                report.reported_work_qty += input.reported_qty;
                report.prd_qty += input.reported_qty;

            }
            else
            {
                report = input.Adapt<PrdReport>();
                report.id = SnowflakeIdHelper.NextId();
                report.reported_work_qty = input.reported_qty;
                report.prd_qty = input.reported_qty;
            }
            row = await db.Storageable(report).ExecuteCommandAsync();
            var prdTask = await db.Queryable<PrdTask>().FirstAsync(it => it.icmo_code == input.icmo_code);
            var record = prdTask.Adapt<PrdReportRecord>();
            if (prdTask != null)
            {
                record.eqp_code = (await db.Queryable<EqpEquipment>().FirstAsync(it => it.id == prdTask.eqp_id))?.eqp_code;
                record.completed_qty = input.reported_qty;
                row = await db.Insertable(record).ExecuteCommandAsync();
            }
            return row > 0;
        }
        /// <summary>
        /// 自检报废提交
        /// </summary>
        /// <param name="input">自检报废输入参数</param>
        /// <returns>true/false</returns>
        /// <remarks>
        /// input:
        ///<br/>{
        ///<br/>  "icmo_code": 任务单号,
        ///<br/>  "scrap_qty": 报废数量,
        ///<br/>  "remark": 备注,
        ///<br/>  "categoryItems": [
        ///<br/>    {
        ///<br/>      "defective_category":次品分类,
        ///<br/>      "category_qty": 分类数量,
        ///<br/>      "items": [
        ///<br/>        {
        ///<br/>          "defective_item": 次品项,
        ///<br/>          "defective_item_qty": 次品项数量
        ///<br/>        }
        ///<br/>      ]
        ///<br/>    }
        ///<br/>  ]
        ///<br/>}
        /// </remarks>
        [HttpPost]
        public async Task<dynamic> SelfTestScrapped(SelfTestScrappedInput input)
        {
            var db = _repository.AsSugarClient();
            var prdScrapped = await db.Queryable<PrdScrapped>().FirstAsync(it => it.icmo_code == input.icmo_code);
            if (prdScrapped is null)
            {
                prdScrapped = input.Adapt<PrdScrapped>();
                prdScrapped.id = SnowflakeIdHelper.NextId();
                prdScrapped.create_id = _userManager.UserId;
                prdScrapped.create_time = DateTime.Now;
            }

            var result = await db.Ado.UseTranAsync(async () =>
            {
                var categorys = new List<PrdScrappedDefectiveCagetory>();
                foreach (var categoryItem in input.categoryItems)
                {
                    categorys = await db.Queryable<PrdScrappedDefectiveCagetory>().Where(it => it.icmo_code == input.icmo_code).ToListAsync();
                    if (categorys?.Count > 0)
                    {
                        foreach (var category in categorys)
                        {
                            var defectiveItems = categoryItem.items?.Select(x => x.defective_item).ToList();
                            var list = await db.Queryable<PrdScrappedDefectiveItem>().Where(it => defectiveItems!.Contains(it.defective_item)).ToListAsync();
                            category.category_qty = list?.Sum(it => it.defective_item_qty) + categoryItem.items.Sum(x => x.defective_item_qty);
                            if (list?.Count > 0)
                            {
                                if (categoryItem.items?.Count > 0)
                                {
                                    foreach (var x in categoryItem.items)
                                    {
                                        var item = list.Find(f => f.defective_item == x.defective_item);
                                        if (item != null)
                                        {
                                            item.defective_item_qty += x.defective_item_qty;
                                        }
                                    }
                                    await db.Updateable(list).ExecuteCommandAsync();
                                }
                            }
                        }
                        await db.Updateable(categorys).ExecuteCommandAsync();
                    }
                    else
                    {

                        var category = categoryItem.Adapt<PrdScrappedDefectiveCagetory>();
                        category.id = SnowflakeIdHelper.NextId();
                        category.icmo_code = input.icmo_code;
                        category.create_id = _userManager.UserId;
                        category.create_time = DateTime.Now;
                        category.category_qty = categoryItem.items?.Sum(x => x.defective_item_qty);
                        categorys!.Add(category);
                        var items = new List<PrdScrappedDefectiveItem>();
                        if (categoryItem.items?.Count > 0)
                        {
                            foreach (var item in categoryItem.items)
                            {
                                var defectiveItem = item.Adapt<PrdScrappedDefectiveItem>();
                                defectiveItem.id = SnowflakeIdHelper.NextId();
                                defectiveItem.defective_cagetory_id = category.id;
                                items.Add(defectiveItem);
                            }
                            await db.Insertable(items).ExecuteCommandAsync();
                        }
                        await db.Insertable(category).ExecuteCommandAsync();
                    }
                }

                //var scrapQty = await db.Queryable<PrdScrappedDefectiveItem>().SumAsync(it => it.defective_item_qty);
                //prdScrapped.scrap_qty = scrapQty;
                var report = await db.Queryable<PrdReport>().FirstAsync(it => it.icmo_code == input.icmo_code);
                if (report != null)
                {
                    report.prd_qty += input.scrap_qty;
                    await db.Updateable<PrdReport>(report).ExecuteCommandAsync();
                }
                await db.Storageable(prdScrapped).ExecuteCommandAsync();
                var prdTask = await db.Queryable<PrdTask>().FirstAsync(it => it.icmo_code == input.icmo_code);
                var record = prdTask.Adapt<PrdSelfTestScrappedRecord>();
                if (prdTask != null)
                {
                    record.eqp_code = (await db.Queryable<EqpEquipment>().FirstAsync(it => it.id == prdTask.eqp_id))?.eqp_code;
                    record.scrap_qty = input.scrap_qty;
                    await db.Insertable(record).ExecuteCommandAsync();
                }
            });
            return result.IsSuccess;
        }

        #endregion


        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>

        private async Task Delete(string id)
        {
            var db = _repository.AsSugarClient();
            var result = await db.Ado.UseTranAsync(async () =>
            {
                var row = -1;
                var prdTask = await db.Queryable<PrdTask>().FirstAsync(it => it.id == id);
                row = await db.Deleteable<PrdTask>().Where(it => it.id == id).ExecuteCommandAsync();
                if (row > 0)
                {
                    var prdMo = await db.Queryable<PrdMo>().FirstAsync(it => it.id == prdTask.mo_id);
                    if (prdMo is not null)
                    {
                        prdMo.input_qty += prdTask.scheduled_qty;
                        prdMo.icmo_status = DictConst.ToBeScheduledEncode;
                        row = await db.Updateable(prdMo).ExecuteCommandAsync();
                    }
                }
                return row > 0;
            });
            if (!result.IsSuccess) throw Oops.Oh(ErrorCode.COM1002);

        }
    }
}