using System.Collections.Generic;
using Aliyun.OSS;
using DOAN.Model.BZFM;
using DOAN.Model.MES.order;
using DOAN.Model.MES.order.Dto;
using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;
using DOAN.Model.Mobile.Dto;
using DOAN.Repository;
using DOAN.Service.MES.product.IService;
using DOAN.Service.Mobile;
using Infrastructure.Attribute;
using MailKit.Search;
using Microsoft.Data.SqlClient;
using Microsoft.IdentityModel.Tokens;
using SqlSugar.DistributedSystem.Snowflake;

namespace DOAN.Service.MES.product
{
    /// <summary>
    /// 工单物料服务实现
    /// </summary>
    [AppService(
        ServiceType = typeof(IProWorkorderMaterialService),
        ServiceLifetime = LifeTime.Transient
    )]
    public class ProWorkorderMaterialService
        : BaseService<ProWorkorder>,
            IProWorkorderMaterialService
    {
        /// <summary>
        /// 根据工单号查询工单已领料清单
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <returns>领料清单数据</returns>
        public List<MaterialTakeDto> GetMaterialTakeList(string workorder)
        {
            var result = Context
                .Queryable<MmRecordOutbound>()
                .Where(it => it.Workorder == workorder)
                .Where(it => it.TransactionType == "领料出库")
                .Where(it => it.Remarks != "已撤销" || it.Remarks == null)
                //.WhereIF(isHideZero, it => it != "已撤销")
                .Select(it => new MaterialTakeDto
                {
                    Id = it.Id,
                    MaterialCode = it.MaterialCode,
                    MaterialName = it.MaterialName,
                    SupplierCode = it.SupplierCode,
                    SupplierName = it.SupplierName,
                    BatchNo = it.BatchNo,
                    StoveCode = it.StoveCode,
                    Quantity = it.Quantity,
                    Unit = it.Unit,
                    CreatedTime = it.CreatedTime.Value,
                    Operator = it.Operator,
                    OutboundNo = it.OutboundNo,
                    Workorder = it.Workorder,
                    WorkorderRaw = it.WorkorderRaw,
                })
                .ToList();
            foreach (var item in result)
            {
                if (!string.IsNullOrEmpty(item.WorkorderRaw))
                {
                    var workorderRawInfo = Context
                        .Queryable<ProWorkorder>()
                        .Where(x => x.Workorder == item.WorkorderRaw)
                        .First();
                    if (workorderRawInfo != null)
                    {
                        item.StoveCode = workorderRawInfo.StoveCode;
                        item.BatchNo = workorderRawInfo.FeedOrder;
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// 根据工单号查询工单已成品入库清单
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <param name="isHideZero">是否隐藏0库存</param>
        /// <returns>成品入库清单数据</returns>
        public List<ProductStorageDto> GetProductStorageList(string workorder)
        {
            var result = Context
                .Queryable<MmRecordInbound>()
                .Where(it => it.Workorder == workorder)
                .Where(it => it.TransactionType == "生产入库")
                .Where(it => it.Remarks != "已撤销" || it.Remarks == null)
                .Select(it => new ProductStorageDto
                {
                    Id = it.Id,
                    MaterialCode = it.MaterialCode,
                    MaterialName = it.MaterialName,
                    BatchNo = it.BatchNo,
                    Quantity = it.Quantity,
                    Unit = it.Unit,
                    CreatedTime = it.CreatedTime.Value,
                    Operator = it.Operator,
                    InboundNo = it.InboundNo,
                    Workorder = it.Workorder,
                    WorkorderRaw = it.WorkorderRaw,
                })
                .ToList();
            return result;
        }

        /// <summary>
        /// 根据工单号查询工单已出货清单
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <param name="isHideZero">是否隐藏0库存</param>
        /// <returns>出货清单数据</returns>
        public List<ShipmentDto> GetShipmentList(string workorder)
        {
            var result = Context
                .Queryable<MmRecordOutbound>()
                .Where(it => it.Workorder == workorder)
                .Where(it => it.TransactionType == "出货出库")
                .Where(it => it.Remarks != "已撤销" || it.Remarks == null)
                .Select(it => new ShipmentDto
                {
                    Id = it.Id,
                    MaterialCode = it.MaterialCode,
                    MaterialName = it.MaterialName,
                    BatchNo = it.BatchNo,
                    Quantity = it.Quantity,
                    Unit = it.Unit,
                    CreatedTime = it.CreatedTime.Value,
                    Operator = it.Operator,
                    OutboundNo = it.OutboundNo,
                    Workorder = it.Workorder,
                    WorkorderRaw = it.WorkorderRaw,
                    CustomerOrder = it.OrderNo,
                })
                .ToList();
            return result;
        }

        /// <summary>
        /// 根据工单查询物料库存接口
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <param name="isHideZero">是否隐藏0</param>
        /// <param name="searchType">查询范围 1-物料库 2-转用库</param>
        /// <returns>物料库存信息列表</returns>
        public PagedInfo<MaterialInventoryDto> GetMaterialInventoryList(
            WorkorderMaterialQueryDto query
        )
        {
            try
            {
                // 参数验证
                if (string.IsNullOrEmpty(query.Workorder))
                {
                    throw new ArgumentNullException(nameof(query.Workorder), "工单号不能为空");
                }
                string workorder = query.Workorder;
                bool isHideZero = query.IsHideZero;

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单号不存在", nameof(workorder));
                }
                var result = new PagedInfo<MaterialInventoryDto>();
                result.Result = new List<MaterialInventoryDto>();
                // 单原材料
                if (workorderInfo.RouteCode != "10")
                {
                    var materialCode = workorderInfo.MaterialCode;
                    var InventoryList = Context
                        .Queryable<MmInventory>()
                        .Where(it => it.MaterialCode == materialCode)
                        .Where(it => it.LocationCode == "YCL001")
                        .WhereIF(isHideZero, it => it.CurrentQty > 0)
                        .Select(it => new MaterialInventoryDto
                        {
                            MaterialId = it.Id,
                            MaterialCode = it.MaterialCode,
                            MaterialName = it.MaterialName,
                            CurrentQuantity = it.CurrentQty,
                            SupplierCode = it.SupplierCode,
                            SupplierName = it.SupplierName,
                            Unit = it.Unit,
                            BatchNo = it.BatchNo,
                        })
                        .OrderBy(it => it.MaterialCode)
                        .OrderBy(it => it.BatchNo)
                        .ToPage(query);
                    result = InventoryList;
                }
                else
                {
                    //组合材料
                    var bomList = Context
                        .Queryable<MmMaterial>()
                        .Where(it => it.ParentMaterialCode == workorderInfo.productionCode)
                        .ToList();
                    foreach (MmMaterial mmMaterial in bomList)
                    {
                        var InventoryList = Context
                            .Queryable<MmInventory>()
                            .Where(it => it.MaterialCode == mmMaterial.MaterialCode)
                            .Where(it => it.SupplierCode == mmMaterial.SupplierCode)
                            .Where(it => it.LocationCode == "YCL001" || it.LocationCode == "CP001")
                            .WhereIF(isHideZero, it => it.CurrentQty > 0)
                            .Select(it => new MaterialInventoryDto
                            {
                                MaterialId = it.Id,
                                MaterialCode = it.MaterialCode,
                                MaterialName = it.MaterialName,
                                CurrentQuantity = it.CurrentQty,
                                SupplierCode = it.SupplierCode,
                                SupplierName = it.SupplierName,
                                Unit = it.Unit,
                                BatchNo = it.BatchNo,
                            })
                            .OrderBy(it => it.MaterialCode)
                            .OrderBy(it => it.BatchNo)
                            .ToList();
                        result.Result.AddRange(InventoryList);
                        result.TotalNum += 1;
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("查询物料库存失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 根据工单号获取可领料工单清单（产成品领取半成品）
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <param name="isHideZero">是否隐藏0记录</param>
        /// <param name="searchType">查询范围 1-物料库 2-转用库</param>
        /// <returns>可领料工单清单</returns>
        public PagedInfo<ProWorkorderDto> GetPickableWorkordersByWorkorder(
            WorkorderMaterialQueryDto query
        )
        {
            try
            {
                // 参数验证
                if (string.IsNullOrEmpty(query.Workorder))
                {
                    throw new ArgumentNullException(nameof(query.Workorder), "工单号不能为空");
                }
                string workorder = query.Workorder;
                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单不存在", nameof(workorder));
                }
                // 需要领取半成品
                if (workorderInfo.RouteCode == "10")
                {
                    return Context
                        .Queryable<MmRecordInbound>()
                        .LeftJoin<ProWorkorder>((mri, pro) => mri.Workorder == pro.Workorder)
                        .Where((mri, pro) => mri.MaterialCode == workorderInfo.MaterialCode)
                        .Where((mri, pro) => mri.TransactionType == "生产入库")
                        .Where((mri, pro) => mri.Remarks != "已撤销" || mri.Remarks == null)
                        //.Where((mri, pro) => pro.ShipmentNum < pro.PlanNum)
                        .OrderByDescending((mri, pro) => mri.Workorder)
                        .Select(
                            (mri, pro) =>
                                new ProWorkorderDto
                                {
                                    Id = pro.Id,
                                    Workorder = mri.Workorder,
                                    productionName = mri.MaterialCode,
                                    productionCode = mri.MaterialName,
                                    MaterialCode = mri.MaterialCode,
                                    MaterialName = mri.MaterialName,
                                    ShipmentNum = pro.ShipmentNum,
                                    PlanNum = pro.PlanNum,
                                    Remark01 = mri.Remarks,
                                },
                            true
                        )
                        .ToPage(query);
                }
                else
                {
                    // 非10线则返回库存

                    // 示例返回空列表
                    return new PagedInfo<ProWorkorderDto>();
                }
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("获取可领料工单清单失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 根据工单号查询成品库存
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <param name="isHideZero">是否隐藏为0记录</param>
        /// <returns>成品库存信息列表</returns>
        public PagedInfo<MaterialInventoryDto> GetProductInventoryList(
            WorkorderMaterialQueryDto query
        )
        {
            try
            {
                // 参数验证
                if (string.IsNullOrEmpty(query.Workorder))
                {
                    throw new ArgumentNullException(nameof(query.Workorder), "工单号不能为空");
                }
                string workorder = query.Workorder;
                bool isHideZero = query.IsHideZero;

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单不存在", nameof(workorder));
                }
                var result = Context
                    .Queryable<MmInventory>()
                    .Where(it => it.MaterialCode == workorderInfo.productionCode)
                    .Where(it => it.LocationCode == "CP001")
                    .WhereIF(isHideZero, it => it.CurrentQty > 0)
                    .Select(it => new MaterialInventoryDto
                    {
                        MaterialId = it.Id,
                        MaterialCode = it.MaterialCode,
                        MaterialName = it.MaterialName,
                        CurrentQuantity = it.CurrentQty,
                        SupplierCode = it.SupplierCode,
                        SupplierName = it.SupplierName,
                        Unit = it.Unit,
                        BatchNo = it.BatchNo,
                    })
                    .OrderByDescending(it => it.BatchNo)
                    .ToPage(query);

                return result;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("查询成品库存失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 根据工单号获取可出货订单清单
        /// </summary>
        /// <param name="workorder">工单号</param>
        /// <param name="isHideZero">是否隐藏为0记录</param>
        /// <returns>可出货订单清单</returns>
        public PagedInfo<OrderPurchaseDto> GetShippableOrdersByWorkorder(
            WorkorderMaterialQueryDto query
        )
        {
            try
            {
                // 参数验证
                if (string.IsNullOrEmpty(query.Workorder))
                {
                    throw new ArgumentNullException(nameof(query.Workorder), "工单号不能为空");
                }
                string workorder = query.Workorder;

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单不存在", nameof(workorder));
                }
                var orderPurchaseList = Context
                    .Queryable<OrderPurchase>()
                    .Where(o => o.MaterialCode == workorderInfo.productionCode)
                    .Where(it => it.Orderindicator != 1)
                    //.Where(it => it.Orderindicator != -1)
                    .OrderBy(it => it.DeliveryDate)
                    .Select(
                        o => new OrderPurchaseDto
                        {
                            Id = o.Id,
                            OrderNoMes = o.OrderNoMes,
                            MaterialCode = o.MaterialCode,
                            MaterialName = o.MaterialName,
                            DemandQuantity = o.DemandQuantity,
                            DeliveryQuantity = o.DeliveryQuantity,
                            DeliveryDate = o.DeliveryDate,
                        },
                        true
                    )
                    .ToPage(query);

                // 示例返回空列表
                return orderPurchaseList;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("获取可出货订单清单失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 工单领料接口
        /// </summary>
        /// <param name="request">领料请求参数</param>
        /// <returns>操作结果</returns>
        public bool TakeMaterial(MaterialTakeRequestDto request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    throw new ArgumentNullException(nameof(request), "领料请求参数不能为空");
                }

                if (string.IsNullOrEmpty(request.Workorder))
                {
                    throw new ArgumentNullException(nameof(request.Workorder), "工单号不能为空");
                }

                if (request.Quantity <= 0)
                {
                    throw new ArgumentException("领料数量必须大于0", nameof(request.Quantity));
                }

                var materialInventory = Context
                    .Queryable<MmInventory>()
                    .First(it => it.Id == request.MaterialInventoryId);
                if (materialInventory == null)
                {
                    throw new ArgumentNullException(
                        nameof(request.MaterialInventoryId),
                        "物料库存ID查询失败"
                    );
                }
                // 业务逻辑实现部分留空待后续补充
                // 此处应实现验证库存是否充足，更新库存数量，记录领料记录
                ReportFlowService _reportFlowService = new ReportFlowService();
                string workorder = request.Workorder;
                string workorderRaw = request.WorkorderRaw;
                int processId = 10;
                int finishNum = (int)request.Quantity;
                string stoveCode = request.StoveCode;
                string feedOrder = materialInventory.BatchNo;
                string worker = request.Operator;
                var result = _reportFlowService.FeedProcessReportwork(
                    workorder,
                    processId,
                    finishNum,
                    stoveCode,
                    feedOrder,
                    worker,
                    workorderRaw,
                    materialInventory.Id
                );
                // 示例返回true
                return result;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("领料操作失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 工单批量领料
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public int BatchTakeMaterialByIds(WorkOrderBatchDto parm)
        {
            try
            {
                // 删除参数校验
                if (parm == null)
                {
                    throw new Exception("传入参数parm为空");
                }
                List<string> workorderIds = parm.Ids;
                if (workorderIds.Count == 0)
                {
                    throw new Exception("传入参数Ids为空,无修改工单");
                }
                // 检查是否有采购记录
                var inboundRecordInfo = Context
                    .Queryable<MmRecordInbound>()
                    .Where(it => it.BatchNo == parm.BatchNo)
                    .Where(it => it.TransactionType == "采购入库")
                    .Where(it => it.Remarks != "已撤销" || it.Remarks == null)
                    .First();
                if (inboundRecordInfo == null)
                {
                    throw new Exception($"批次号{parm.BatchNo}无对应采购记录，请检查");
                }
                // 批量领料业务
                int result = 0;
                string standardMaterialCode = string.Empty;
                // 业务处理前校验
                List<ProWorkorder> batchTakeMaterialWorkOrderList = new();
                foreach (string workOrderId in workorderIds)
                {
                    ProWorkorder workOrderInfo = Context
                        .Queryable<ProWorkorder>()
                        .Where(it => it.Id == workOrderId)
                        .First();
                    if (workOrderInfo == null || string.IsNullOrEmpty(workOrderInfo.Workorder))
                    {
                        throw new Exception($"工单异常{workOrderId},未找到工单");
                    }
                    if (workOrderInfo.RouteCode == "10")
                    {
                        throw new Exception("10线工单不可批量领料");
                    }
                    if (string.IsNullOrEmpty(standardMaterialCode))
                    {
                        standardMaterialCode = workOrderInfo.MaterialCode;
                    }
                    else
                    {
                        if (standardMaterialCode != workOrderInfo.MaterialCode)
                        {
                            throw new Exception(
                                $"工单{workOrderInfo.Workorder}原材料与上一个工单不一致,上一个工单{standardMaterialCode}"
                            );
                        }
                    }
                    string workOrder = workOrderInfo.Workorder;
                    // 是否有领料记录
                    bool hasOutMaterialRecord = Context
                        .Queryable<MmRecordOutbound>()
                        .Where(it => it.Workorder == workOrder)
                        .Where(it => it.TransactionType == "领料出库")
                        .Where(it => it.Remarks != "已撤销" || it.Remarks == null)
                        .Any();
                    if (hasOutMaterialRecord)
                    {
                        throw new Exception($"该工单{workOrder}已存在领料记录，无法再次领料");
                    }
                    batchTakeMaterialWorkOrderList.Add(workOrderInfo);
                }
                if (batchTakeMaterialWorkOrderList.Count == 0)
                {
                    throw new Exception($"待领料工单数量异常");
                }
                // 检查库存容量是否足够
                var inventoryInfo = Context
                    .Queryable<MmInventory>()
                    .Where(it => it.BatchNo == parm.BatchNo)
                    .Where(it => it.MaterialCode == batchTakeMaterialWorkOrderList[0].MaterialCode)
                    .Where(it => it.LocationCode == "YCL001")
                    .First();
                if (inventoryInfo.CurrentQty < batchTakeMaterialWorkOrderList.Count * parm.Quantity)
                {
                    throw new Exception(
                        $"该批次库存数不足,目前库存数{inventoryInfo.CurrentQty}，需要{batchTakeMaterialWorkOrderList.Count * parm.Quantity}"
                    );
                }

                foreach (var workorderInfo in batchTakeMaterialWorkOrderList)
                {
                    MaterialTakeRequestDto takeDto = new()
                    {
                        Workorder = workorderInfo.Workorder,
                        WorkorderRaw = string.Empty,
                        Quantity = parm.Quantity,
                        MaterialInventoryId = inventoryInfo.Id,
                        StoveCode = inboundRecordInfo.StoveCode,
                        Operator = parm.Operator,
                    };
                    bool isOk = TakeMaterial(takeDto);
                    if (isOk)
                    {
                        result++;
                    }
                    else
                    {
                        throw new Exception($"领料异常结束，只成功{result}个工单");
                    }
                }
                return result;
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 工单成品入库接口
        /// </summary>
        /// <param name="request">成品入库请求参数</param>
        /// <returns>操作结果</returns>
        public bool StoreProduct(ProductStorageRequestDto request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    throw new ArgumentNullException(nameof(request), "成品入库请求参数不能为空");
                }

                if (string.IsNullOrEmpty(request.Workorder))
                {
                    throw new ArgumentNullException(nameof(request.Workorder), "工单号不能为空");
                }

                if (request.Quantity <= 0)
                {
                    throw new ArgumentException("成品数量必须大于0", nameof(request.Quantity));
                }

                var workorderInfo = Context
                    .Queryable<ProWorkorder>()
                    .First(it => it.Workorder == request.Workorder);
                if (workorderInfo == null)
                {
                    throw new ArgumentException("工单不存在", nameof(request.Workorder));
                }
                var materialTakeInfo = Context
                    .Queryable<MmRecordOutbound>()
                    .Where(sub => sub.Workorder == request.Workorder)
                    .Where(sub => sub.TransactionType == "领料出库")
                    .Where(sub => sub.Remarks != "已撤销" || sub.Remarks == null)
                    .First();
                if (materialTakeInfo == null)
                {
                    throw new Exception("该工单还未领料");
                }
                if (
                    workorderInfo.RouteCode != "10"
                    && Math.Abs(materialTakeInfo.Quantity) < request.Quantity
                )
                {
                    throw new Exception("该工单成品入库数大于领料数");
                }
                ReportFlowService _reportFlowService = new ReportFlowService();
                string workorder = request.Workorder;
                int processId = 70;
                int finishNum = (int)request.Quantity;
                int badNum = 0;
                string worker = request.Operator;
                var result = _reportFlowService.ProcessReportWork(
                    workorder,
                    processId,
                    finishNum,
                    badNum,
                    worker
                );
                // 示例返回true
                return result;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("成品入库操作失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 工单出货接口
        /// </summary>
        /// <param name="request">出货请求参数</param>
        /// <returns>操作结果</returns>
        public bool ShipProduct(ShipmentRequestDto request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    throw new ArgumentNullException(nameof(request), "出货请求参数不能为空");
                }

                if (string.IsNullOrEmpty(request.Workorder))
                {
                    throw new ArgumentNullException(nameof(request.Workorder), "工单号不能为空");
                }

                if (string.IsNullOrEmpty(request.OrderId))
                {
                    throw new ArgumentNullException(nameof(request.OrderId), "订单ID不能为空");
                }

                // 业务逻辑实现部分留空待后续补充
                // 此处应实现验证库存是否充足，更新库存状态，记录出货信息
                OrderPurchase orderPurchase = Context
                    .Queryable<OrderPurchase>()
                    .Where(o => o.Id == request.OrderId)
                    .First();

                ReportFlowService _reportFlowService = new ReportFlowService();
                string workorder = request.Workorder;
                int processId = 90;
                int finishNum = (int)request.Quantity;
                int badNum = 0;
                string customerOrder = orderPurchase.OrderNoMes;
                string worker = request.Operator;
                var result = _reportFlowService.ShipmentProcessReportwork(
                    workorder,
                    processId,
                    finishNum,
                    badNum,
                    customerOrder,
                    worker
                );
                if (result == 0)
                {
                    throw new Exception("数据库操作失败");
                }
                if (result == 2)
                {
                    throw new Exception("订单号不存在");
                }
                if (result == 3)
                {
                    throw new Exception("订单超额");
                }
                if (result == 4)
                {
                    throw new Exception("工单不存在");
                }
                if (result == 5)
                {
                    throw new Exception("主体型号和订单物料不匹配");
                }
                return result == 1;
            }
            catch (Exception ex)
            {
                // 集成现有系统的日志记录
                // Log.Error("出货操作失败", ex);
                throw new Exception(ex.Message);
            }
        }
    }
}