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.Repository;
using DOAN.Service.MES.order.IService;
using Infrastructure.Attribute;
using Infrastructure.Converter;
using Mapster;
using Microsoft.AspNetCore.Http;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;

namespace DOAN.Service.MES.order
{
    /// <summary>
    /// 采购订单Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IOrderPurchaseService), ServiceLifetime = LifeTime.Transient)]
    public class OrderPurchaseService : BaseService<OrderPurchase>, IOrderPurchaseService
    {
        /// <summary>
        /// 查询采购订单列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<OrderPurchaseDto> GetList(OrderPurchaseQueryDto parm)
        {

            // 日期处理
            if (parm != null && parm.ImportDate != null && parm.ImportDate.Length > 0)
            {
                if (parm.ImportDate[0] > DateTime.MinValue)
                {
                    parm.ImportDate[0] = DOANConvertDate.ConvertLocalDate(parm.ImportDate[0]);
                }
                if (parm.ImportDate[1] > DateTime.MinValue)
                {
                    parm.ImportDate[1] = DOANConvertDate.ConvertLocalDate(parm.ImportDate[1]);
                }
            }
            string _orderNoMes = parm.OrderNoMes;
            // 工单查询处理
            if (parm != null && !string.IsNullOrEmpty(parm.WorkOrder))
            {
                var workorderInfo = Context.Queryable<ProWorkorder>()
                    .Where(it => it.Workorder.Contains(parm.WorkOrder))
                    .First();
                if (workorderInfo != null)
                {
                    parm.OrderNoMes = workorderInfo.CustomerOrder;
                }
            }
            // 领料单查询处理
            if (parm != null && !string.IsNullOrEmpty(parm.FeedOrder))
            {
                var workorderInfo = Context.Queryable<ProWorkorder>()
                    .Where(it => it.FeedOrder.Contains(parm.FeedOrder))
                    .First();
                if (workorderInfo != null)
                {
                    parm.OrderNoMes = workorderInfo.CustomerOrder;
                }
            }


            var predicate = QueryExp(parm);

            var response = Queryable()
                .Where(predicate.ToExpression())
                .OrderByDescending(it => it.OrderNoMes)
                //.OrderBy(it => it.OrderNoMes)
                .ToPage<OrderPurchase, OrderPurchaseDto>(parm);

            return response;
        }


        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public OrderPurchase GetInfo(string Id)
        {
            var response = Queryable()
                .Where(x => x.Id == Id)
                .First();

            return response;
        }

        /// <summary>
        /// 添加采购订单
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public OrderPurchase AddOrderPurchase(OrderPurchase model)
        {
            // 订单号唯一性验证
            var existingOrder = Context.Queryable<OrderPurchase>()
                .Where(it => it.OrderNoMes == model.OrderNoMes)
                .First();

            if (existingOrder != null)
            {
                throw new ArgumentException($"订单号 {model.OrderNoMes} 已存在，请使用其他订单号");
            }

            // 设置初始值
            DateTime now = DateTime.Now;
            model.Id = SnowFlakeSingle.Instance.NextId().ToString();

            var materialInfo = Context.Queryable<MmMaterial>().Where(it => it.MaterialCode == model.MaterialCode).First();
            if(materialInfo == null)
            {
                throw new ArgumentException($"物料号 {model.MaterialCode} 不在清单中，请检查");
            }
            model.MaterialName = materialInfo.MaterialName;
            model.ImportDate = now;
            model.DocumentDate = now;
            model.CreatedTime = now;
            model.CreatedBy = "";
            model.UpdatedTime = now;
            model.UpdatedBy = "";
            // 设置默认值
            model.Specordindicator = -1; // 不处理
            model.DeliveryQuantity = 0; // 实际交货数量初始为0
            model.Orderindicator = -1; // 订单未完成（初始状态）
            model.Status = 0; // 状态待处理

            // 使用事务处理
            OrderPurchase result = null;
            UseTran2(() =>
            {
                result = Insertable(model).ExecuteReturnEntity();
            });

            return result;
        }

        /// <summary>
        /// 修改采购订单
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateOrderPurchase(OrderPurchase model)
        {
            // 订单号唯一性验证
            var existingOrder = Context.Queryable<OrderPurchase>()
                .Where(it => it.OrderNoMes == model.OrderNoMes && it.Id != model.Id)
                .First();

            if (existingOrder != null)
            {
                throw new ArgumentException($"订单号 {model.OrderNoMes} 已存在，请使用其他订单号");
            }

            var materialInfo = Context.Queryable<MmMaterial>().Where(it => it.MaterialCode == model.MaterialCode).First();
            if (materialInfo == null)
            {
                throw new ArgumentException($"物料号 {model.MaterialCode} 不在清单中，请检查");
            }
            model.MaterialName = materialInfo.MaterialName;

            // 使用事务处理
            int result = 0;
            UseTran2(() =>
            {
                result = Update(model, true);
            });

            return result;
        }

        /// <summary>
        /// 查询导出表达式
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        private static Expressionable<OrderPurchase> QueryExp(OrderPurchaseQueryDto parm)
        {
            var predicate = Expressionable.Create<OrderPurchase>()
                .AndIF(!string.IsNullOrEmpty(parm.OrderNoMes), it => it.OrderNoMes.Contains(parm.OrderNoMes))
                .AndIF(!string.IsNullOrEmpty(parm.PurchaseOrderErp), it => it.PurchaseOrderErp.Contains(parm.PurchaseOrderErp))
                .AndIF(!string.IsNullOrEmpty(parm.MaterialCode), it => it.MaterialCode.Contains(parm.MaterialCode))
                .AndIF(parm.ImportDate != null && parm.ImportDate[0] > DateTime.MinValue, it => it.ImportDate >= parm.ImportDate[0])
                .AndIF(parm.ImportDate != null && parm.ImportDate[1] > DateTime.MinValue, it => it.ImportDate <= parm.ImportDate[1])
                .AndIF(parm.Orderindicator > -1, it => it.Orderindicator == parm.Orderindicator)
                ;

            return predicate;
        }


        public int ImportData(IFormFile formFile, string username, bool? uploadType)
        {
            List<OrderPurchase> orderPurchases = new List<OrderPurchase>();
            DateTime importDate = DateTime.MinValue;
            using (var stream = formFile.OpenReadStream())
            {
                try
                {
                    IWorkbook workbook = new XSSFWorkbook(stream);
                    ISheet sheet = workbook.GetSheetAt(0);
                    IRow secondRow = sheet.GetRow(1);
                    NPOI.SS.UserModel.ICell cell = secondRow.GetCell(1);


                    // 将单元格的数字值转换为DateTime
                    importDate = cell?.DateCellValue ?? DateTime.MinValue;
                    importDate = importDate.Date;

                    // 遍历每一行
                    for (int row = 4; row <= sheet.LastRowNum; row++)
                    {
                        IRow currentRow = sheet.GetRow(row);
                        if (currentRow != null) // 确保行不为空
                        {
                            OrderPurchase model = new OrderPurchase();
                            model.Id = SnowFlakeSingle.Instance.NextId().ToString();
                            model.OrderNoMes = currentRow.GetCell(0)?.ToString();
                            model.PurchaseOrderErp = currentRow.GetCell(1)?.ToString();
                            model.Poitem = currentRow.GetCell(2)?.ToString();
                            model.Variety = currentRow.GetCell(3)?.ToString();

                            string specordindicator = currentRow.GetCell(4)?.ToString();
                            if (!string.IsNullOrEmpty(specordindicator) && specordindicator == "是")
                            {
                                model.Specordindicator = 1;
                            }
                            else if (!string.IsNullOrEmpty(specordindicator) && specordindicator == "否")
                            {
                                model.Specordindicator = 0;
                            }
                            else
                            {
                                model.Specordindicator = -1;
                            }

                            model.KdType = currentRow.GetCell(5)?.ToString();
                            model.DocumentDate = currentRow.GetCell(6)?.DateCellValue; // 直接赋值，如果为 null 则保持 null
                            model.Seller = currentRow.GetCell(7)?.ToString();
                            model.SalesArea = currentRow.GetCell(8)?.ToString();
                            model.MaterialName = currentRow.GetCell(9)?.ToString();
                            model.MaterialCode = currentRow.GetCell(10)?.ToString();

                            var demandQuantityCell = currentRow.GetCell(11);
                            model.DemandQuantity = demandQuantityCell != null && demandQuantityCell.CellType == CellType.Numeric ? (int)demandQuantityCell.NumericCellValue : 0;

                            model.DeliveryDate = currentRow.GetCell(12)?.DateCellValue; // 直接赋值，如果为 null 则保持 null

                            var deliveryQuantityCell = currentRow.GetCell(13);
                            model.DeliveryQuantity = deliveryQuantityCell != null && deliveryQuantityCell.CellType == CellType.Numeric ? (int)deliveryQuantityCell.NumericCellValue : 0;

                            model.StartDate = currentRow.GetCell(14)?.DateCellValue; // 直接赋值，如果为 null 则保持 null
                            model.EndDate = currentRow.GetCell(15)?.DateCellValue; // 直接赋值，如果为 null 则保持 null

                            string Orderindicator = currentRow.GetCell(16)?.ToString();
                            if (!string.IsNullOrEmpty(Orderindicator) && Orderindicator == "是")
                            {
                                model.Orderindicator = 1;
                            }
                            else if (!string.IsNullOrEmpty(Orderindicator) && Orderindicator == "否")
                            {
                                model.Orderindicator = 0;
                            }
                            else
                            {
                                model.Orderindicator = -1;
                            }

                            model.RouteCode = currentRow.GetCell(17)?.ToString();
                            model.Remark = currentRow.GetCell(18)?.ToString();
                            model.ImportDate = importDate;
                            model.CreatedTime = importDate;
                            model.CreatedBy = username;

                            orderPurchases.Add(model);

                        }
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
            }
            // 追加导入
            if (uploadType == true)
            {
                int result = 0;
                UseTran2(() =>
                {

                    result = Context.Insertable(orderPurchases).ExecuteCommand();
                });
                return result;
            }
            if (orderPurchases.Count > 0)
            {
                int result = 0;
                UseTran2(() =>
                {
                    Context.Deleteable<OrderPurchase>().Where(x => x.ImportDate == importDate).ExecuteCommand();
                    result = Context.Insertable(orderPurchases).ExecuteCommand();
                });
                return result;

            }
            else
            {
                return 0;
            }
        }

        public List<OrderPurchaseExcelDto> SelectOrderList(OrderPurchaseQueryDto parm)
        {
            // 日期处理
            if (parm != null && parm.ImportDate != null && parm.ImportDate.Length > 0)
            {
                if (parm.ImportDate[0] > DateTime.MinValue)
                {
                    parm.ImportDate[0] = DOANConvertDate.ConvertLocalDate(parm.ImportDate[0]);
                }
                if (parm.ImportDate[1] > DateTime.MinValue)
                {
                    parm.ImportDate[1] = DOANConvertDate.ConvertLocalDate(parm.ImportDate[1]);
                }
            }
            string _orderNoMes = parm.OrderNoMes;
            // 工单查询处理
            if (parm != null && !string.IsNullOrEmpty(parm.WorkOrder))
            {
                var workorderInfo = Context.Queryable<ProWorkorder>()
                    .Where(it => it.Workorder.Contains(parm.WorkOrder))
                    .First();
                if (workorderInfo != null)
                {
                    parm.OrderNoMes = workorderInfo.CustomerOrder;
                }
            }
            // 领料单查询处理
            if (parm != null && !string.IsNullOrEmpty(parm.FeedOrder))
            {
                var workorderInfo = Context.Queryable<ProWorkorder>()
                    .Where(it => it.FeedOrder.Contains(parm.FeedOrder))
                    .First();
                if (workorderInfo != null)
                {
                    parm.OrderNoMes = workorderInfo.CustomerOrder;
                }
            }
            var predicate = QueryExp(parm);
            var response = Queryable()
                .Where(predicate.ToExpression())
                .OrderBy(it => it.OrderNoMes)
                .Select(it => new OrderPurchaseExcelDto
                {
                    Id = it.Id,
                    OrderNoMes = it.OrderNoMes,
                    ImportDate = it.ImportDate,
                    MaterialCode = it.MaterialCode,
                    MaterialName = it.MaterialName,
                    DocumentDate = it.DocumentDate,
                    DemandQuantity = it.DemandQuantity,
                    DeliveryDate = it.DeliveryDate,
                    DeliveryQuantity = it.DeliveryQuantity,
                    Orderindicator = it.Orderindicator,
                    StartDate = it.StartDate,
                    EndDate = it.EndDate,
                    Remark = it.Remark
                }).ToList();

            return response;
        }

    }
}