using DOAN.Model;
using DOAN.Model.MES.base_;
using DOAN.Model.MES.mm;
using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;
using DOAN.Repository;
using DOAN.Service.Mobile.IService;
using Infrastructure.Attribute;


namespace DOAN.Service.Mobile
{
    [AppService(ServiceType = typeof(IPADReportWorkService), ServiceLifetime = LifeTime.Transient)]
    public class PADReportWorkService : BaseService<ProReportwork>, IPADReportWorkService
    {
        /// <summary>
        /// 不防错直接报工
        /// </summary>
        /// <param name="wokorder"></param>
        /// <param name="reportNum"></param>
        /// <returns></returns>
        public int NoErrorProofingAndReportingReport(string wokorder, int reportNum)
        {
            int result = 0;


            var selected_workorder = Context.Queryable<ProReportwork>().Where(it => it.FkWorkorder == wokorder)
                .First();
            if (selected_workorder != null)
            {
                //修改
                result = Context.Updateable<ProReportwork>().Where(it => it.FkWorkorder == wokorder)
                    .SetColumns(it => it.FinishedNum == reportNum)
                    .SetColumns(it => it.UpdatedTime == DateTime.Now)
                    .SetColumns(it => it.UpdatedBy == "PDA")
                    .ExecuteCommand();
            }
            else
            {
                //新增
              var  handle_workorder=  Context.Queryable<ProWorkorder>().Where(it => it.Workorder == wokorder).First();
                var reportWork = new ProReportwork();
                reportWork.Id = XueHua;
                reportWork.FkWorkorder = wokorder;
                reportWork.DispatchNum = handle_workorder.DeliveryNum;
                reportWork.FinishedNum = reportNum;
                reportWork.GroupCode = selected_workorder.GroupCode;
                reportWork.LineCode = selected_workorder.LineCode;
                reportWork.CreatedTime = DateTime.Now;
                reportWork.CreatedBy = "PDA";
              
                result = Context.Insertable(reportWork).ExecuteCommand();
            }

            #region 线边库出库

            linesideInventoryDeductions(wokorder, reportNum);

            #endregion


            return result;
        }

        public List<BaseWorkRoute> GetAllRoute()
        {
            return Context.Queryable<BaseWorkRoute>().ToList();
        }

        public List<BaseGroup> GetGroupList()
        {
            return Context.Queryable<BaseGroup>().Where(it => it.Status == 1).ToList();
        }

        public ProWorkorderDto4 GetWorkOrderDetail(string workorder)
        {
            var query = Context.Queryable<ProWorkorder>()
                .Where(it => it.Workorder == workorder);


            return Context.Queryable(query)
                .LeftJoin<ProReportwork>((q, r) => q.Workorder == r.FkWorkorder)
                .Select((q, r) => new ProWorkorderDto4
                {
                    FinishNum = r.FinishedNum
                }, true).First();
        }

        public List<ProReportworkDto> GetWorkOrderStatusList(string group_code, int status, DateTime handleDate)
        {
            var query = Context.Queryable<ProWorkorder>().Where(it => it.GroupCode == group_code)
                .Where(it => it.Status == status)
                .Where(it => it.WorkorderDate == handleDate);

            return Context.Queryable(query)
                .LeftJoin<ProReportwork>((w, r) => w.Workorder == r.FkWorkorder)
                .Select((w, r) => new ProReportworkDto
                {
                    Id = r.Id,
                    ProductionCode = w.ProductionCode,
                    ProductionName = w.ProductionName,
                    Specification = w.Specification,
                    QualifiedNumber = r.QualifiedNumber,
                    UnqualifiedNumber = r.UnqualifiedNumber,
                    ReworkNumber = r.ReworkNumber,
                    ScrapNumber = r.ScrapNumber,
                    Remark = r.Remark,
                    Difference = r.QualifiedNumber - r.FinishedNum ?? 0,
                    FkWorkorder = w.Workorder,
                    GroupCode = w.GroupCode,
                    LineCode = w.LineCode,
                    DispatchNum = w.DeliveryNum ?? 0,
                    Priority = w.Priority,
                    Status = w.Status,
                    Beat = w.Beat
                }, true).ToList();
        }


        /// <summary>
        /// 修改报工表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateProReportwork(ProReportwork model)
        {
            // 更新线边库
            if (model.FinishedNum != null && string.IsNullOrEmpty(model.FkWorkorder))
            {
                linesideInventoryRecovery(model.FkWorkorder, model.CreatedBy);
                linesideInventoryDeductions(model.FkWorkorder, model.FinishedNum ?? 0);
            }


            //var response = Update(w => w.Id == model.Id, it => new ProReportwork()
            //{
            //    FkWorkorder = model.FkWorkorder,
            //    DispatchNum = model.DispatchNum,
            //    FinishedNum = model.FinishedNum,
            //    GroupCode = model.GroupCode,
            //    LineCode = model.LineCode,
            //    CreatedBy = model.CreatedBy,
            //    CreatedTime = model.CreatedTime,
            //    UpdatedBy = model.UpdatedBy,
            //    UpdatedTime = model.UpdatedTime,
            //});
            //return response;
            return Update(model, true);
        }

        public int StartWorkOrder(string workorder)
        {
            var result = 0;
            // 获取同一天 同一组 同一线 的所有工单 把状态2 设为init 1
            var handleWorkorder =
                Context.Queryable<ProWorkorder>().Where(it => it.Workorder == workorder).First();
            UseTran2(() =>
            {
                Context.Updateable<ProWorkorder>().SetColumns(it => it.Status == 1)
                    .Where(it => it.Status == 2)
                    .Where(it => it.WorkorderDate == handleWorkorder.WorkorderDate)
                    .Where(it => it.GroupCode == handleWorkorder.GroupCode)
                    .Where(it => it.LineCode == handleWorkorder.LineCode)
                    .ExecuteCommand();


                result = Context.Updateable<ProWorkorder>().SetColumns(it => it.Status == 2)
                    .SetColumns(it => it.StartTime == DateTime.Now)
                    .Where(it => it.Workorder == workorder).ExecuteCommand();
            });
            return result;
        }

        public int FinishWorkOrder(string workorder)
        {
            return Context.Updateable<ProWorkorder>()
                .SetColumns(it => it.Status == 3)
                .SetColumns(it => it.EndTime == DateTime.Now)
                .Where(it => it.Workorder == workorder).ExecuteCommand();
        }


        /// <summary>
        /// 查询报工表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<ProReportworkDto> GetList(ProReportworkQueryDto parm)
        {
            if (parm.TimeRange != null && parm.TimeRange.Length == 2)
            {
                parm.TimeRange[0] = parm.TimeRange[0].Date;
                // parm.TimeRange[1] = parm.TimeRange[1].Date.AddDays(1);
                parm.TimeRange[1] = parm.TimeRange[1].Date;
            }

            var predicate = Expressionable.Create<ProWorkorder, ProReportwork>()
                    .AndIF(!string.IsNullOrEmpty(parm.FkWorkorder), (w, r) => w.Workorder.Contains(parm.FkWorkorder))
                    .AndIF(!string.IsNullOrEmpty(parm.GroupCode), (w, r) => w.GroupCode == parm.GroupCode)
                    .AndIF(!string.IsNullOrEmpty(parm.LineCode), (w, r) => w.LineCode == parm.LineCode)
                    .AndIF(parm.WarehouseconfirmationNum > 0, (w, r) => r.QualifiedNumber > 0)
                    .AndIF(
                        parm.TimeRange != null && parm.TimeRange.Length == 2 && parm.TimeRange[0] > DateTime.MinValue,
                        (w, r) => w.WorkorderDate >= parm.TimeRange[0])
                    .AndIF(
                        parm.TimeRange != null && parm.TimeRange.Length == 2 && parm.TimeRange[1] > DateTime.MinValue,
                        (w, r) => w.WorkorderDate <= parm.TimeRange[1])
                    .AndIF(parm.Status > 0, (w, r) => w.Status == parm.Status)
                ;


            var response = Context.Queryable<ProWorkorder>()
                .LeftJoin<ProReportwork>((w, r) => w.Workorder == r.FkWorkorder)
                .Where(predicate.ToExpression())
                .Select((w, r) => new ProReportworkDto
                {
                    Id = r.Id,
                    ProductionCode = w.ProductionCode,
                    ProductionName = w.ProductionName,
                    Specification = w.Specification,
                    QualifiedNumber = r.QualifiedNumber,
                    UnqualifiedNumber = r.UnqualifiedNumber,
                    ReworkNumber = r.ReworkNumber,
                    ScrapNumber = r.ScrapNumber,
                    Remark = r.Remark,
                    Difference = r.QualifiedNumber - r.FinishedNum ?? 0,
                    FkWorkorder = w.Workorder,
                    GroupCode = w.GroupCode,
                    LineCode = w.LineCode,
                    DispatchNum = w.DeliveryNum ?? 0,
                    Priority = w.Priority,
                    Status = w.Status,
                    Beat = w.Beat
                }, true).ToPage_NO_Convert<ProReportworkDto>(parm);

            return response;
        }


        /// <summary>
        /// 线边库 库存扣除
        /// </summary>
        /// <param name="workorder"></param>
        private void linesideInventoryDeductions(string workorder, int reportNum)
        {
            var selected_workorder = Context.Queryable<ProWorkorder>().Where(it => it.Workorder == workorder).First();

            if (selected_workorder == null)
            {
                return;
            }

            //TODO 获取实际报工数量  作为线边库库存 出库
            // 查询这个工单的BOM
            List<BaseMaterialBom> SubMaterialList = Context.Queryable<BaseMaterialBom>()
                .Where(it => it.InvCode == selected_workorder.ProductionCode)
                .ToList();
            if (SubMaterialList.Count > 0)
            {
                List<MmLinesidebarInventoryOutboundAndInbound> InsertedSubMaterialOutboundAndInboundList =
                    new List<MmLinesidebarInventoryOutboundAndInbound>();
                List<MmLinesidebarInventory> needReduceLinesidebarInventories = new List<MmLinesidebarInventory>();
                // 添加出库记录
                // 扣除库存记录
                string[] SubMaterialArray = SubMaterialList.Select(it => it.InvCode).ToArray();
                //线边库存
                List<MmLinesidebarInventory> SideInventoryList = Context.Queryable<MmLinesidebarInventory>()
                    .Where(it => it.LineCode == selected_workorder.LineCode)
                    .Where(it => SubMaterialArray.Contains(it.MaterialCode)).ToList();

                foreach (var subMaterial in SubMaterialList)
                {
                    //物料在线边库存
                    if (SideInventoryList.Where(it => it.MaterialCode == subMaterial.SubInvCode).Any())
                    {
                        // 记录需要扣除的线边库存
                        MmLinesidebarInventory sideInventory = new MmLinesidebarInventory();
                        sideInventory.LineCode = selected_workorder.LineCode;
                        sideInventory.MaterialCode = subMaterial.SubInvCode;
                        var seleced = SideInventoryList.Where(it => it.MaterialCode == subMaterial.SubInvCode).First();

                        sideInventory.LogicQuantity =
                            seleced.LogicQuantity -
                            reportNum * Convert.ToDecimal(subMaterial.Iusequantity); //库存------需要扣减的数量
                        needReduceLinesidebarInventories.Add(sideInventory);

                        MmLinesidebarInventoryOutboundAndInbound outbound =
                            new MmLinesidebarInventoryOutboundAndInbound();
                        outbound.Id = XueHua;
                        outbound.LineCode = selected_workorder.LineCode;
                        outbound.MaterialCode = subMaterial.SubInvCode;
                        outbound.MaterialName = subMaterial.SubInvName;
                        outbound.Action = 1;
                        outbound.Quantity = reportNum * Convert.ToDecimal(subMaterial.Iusequantity);
                        outbound.Remark = $"(正常)触摸屏报工，工单号为{workorder}";
                        outbound.CreatedBy = "kanban";
                        outbound.CreatedTime = DateTime.Now;
                        InsertedSubMaterialOutboundAndInboundList.Add(outbound);
                    }
                    else
                    {
                        MmLinesidebarInventoryOutboundAndInbound outbound =
                            new MmLinesidebarInventoryOutboundAndInbound();
                        outbound.Id = XueHua;
                        outbound.LineCode = selected_workorder.LineCode;
                        outbound.MaterialCode = subMaterial.SubInvCode;
                        outbound.MaterialName = subMaterial.SubInvName;
                        outbound.Action = 1;
                        outbound.Quantity = reportNum * Convert.ToDecimal(subMaterial.Iusequantity);
                        outbound.Remark = $"(异常)触摸屏报工，工单号为{workorder}，物料不在这个线边库";
                        outbound.CreatedBy = "kanban";
                        outbound.CreatedTime = DateTime.Now;
                        InsertedSubMaterialOutboundAndInboundList.Add(outbound);
                    }
                }

                UseTran2(() =>
                {
                    Context.Updateable(needReduceLinesidebarInventories).UpdateColumns(it => new { it.LogicQuantity })
                        .WhereColumns(it => new { it.LineCode, it.MaterialCode }).ExecuteCommand();
                    Context.Insertable(InsertedSubMaterialOutboundAndInboundList).ExecuteCommand();
                });
            }
        }


        /// <summary>
        /// 取消出库
        /// </summary>
        /// <param name="workorder"></param>
        /// <param name="CreatedBy"></param>
        private void linesideInventoryRecovery(string workorder, string CreatedBy)
        {
            // 取消报工 出库
            var cancal = Context.Queryable<MmLinesidebarInventoryOutboundAndInbound>()
                .Where(it => it.WorkOrder == workorder).OrderByDescending(it => it.CreatedTime).First();

            // 取消 报工库存日志
            MmLinesidebarInventoryOutboundAndInbound log = new MmLinesidebarInventoryOutboundAndInbound();
            log.Id = XueHua;
            log.LineCode = cancal.LineCode;
            log.MaterialCode = cancal.MaterialCode;
            log.MaterialName = cancal.MaterialName;
            log.Action = 2;
            log.Quantity = cancal.Quantity;
            log.Remark = $"取消这个工单{cancal.WorkOrder}的报工消耗，恢复库存;{cancal.Remark}";
            log.CreatedBy = CreatedBy;
            log.CreatedTime = DateTime.Now;


            UseTran2(() =>
            {
                // 增加库存
                Context.Updateable<MmLinesidebarInventory>()
                    .Where(it => it.LineCode == cancal.LineCode)
                    .Where(it => it.MaterialCode == cancal.MaterialCode)
                    .SetColumns(it => it.LogicQuantity == it.LogicQuantity + cancal.Quantity);


                Context.Insertable(log).ExecuteCommand();
            });
        }
    }
}