using Microsoft.Data.SqlClient;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.Stocktaking;

namespace WCS.BLL.Services.Service
{
    public class StockTakingService : IStockTakingService
    {
        #region SysStockTakingOrder
        public async Task<ResponseBase> SysStockTakingOrder(SysStockTakingOrderRequest request)
        {
            //先判断盘点单据号是否已存在（避免前端多次提交后生成多个的情况）
            var stocktakingOrder = await DbHelp.db.Queryable<StockTakingOrder>()
                                                  .Where(t => t.StocktakingOrderNumber == request.StocktakingOrderNumber)
                                                  .FirstAsync();
            if (stocktakingOrder != null)
                return new SysStockTakingOrderResponse()
                {
                    Code = 201,
                    Message = $"操作失败：盘点单据{stocktakingOrder.StocktakingOrderNumber}已存在！"
                };
            else
            {
                //分成三类
                switch (request.StocktakingOrderType)
                {
                    case "shelfCodes":
                        return await SysStockTakingOrderByShelfCodes(request);
                    case "matCodes":
                        return await SysStockTakingOrderByMatCodes(request);
                    case "snList":
                        return await SysStockTakingOrderSnList(request);
                    default:
                        return new SysStockTakingOrderResponse()
                        {
                            Code = 201,
                            Message = $"操作失败：[{request.StocktakingOrderType}]不支持的操作！!"
                        };
                }
            }
        }

        public async Task<ResponseBase> SysStockTakingOrderByShelfCodes(SysStockTakingOrderRequest request)
        {
            //校验参数
            if (request.List == null || request.List.Count == 0)
                return new SysStockTakingOrderResponse()
                {

                    Code = 201,
                    Message = $"操作失败：缺少必要参数"
                };
            //先判断是否有这些货架
            var shelfs = ShelfManager.Shelves
                                     .Where(t => request.List.Contains(t.ShelfCode))
                                     .ToList();
            if (shelfs.Count < request.List.Count)
            {
                foreach (var shelf in shelfs)
                {
                    request.List.RemoveAll(t => t == shelf.ShelfCode);
                }
                return new SysStockTakingOrderResponse()
                {
                    Code = 201,
                    Message = $"操作失败：货架[{string.Join(",", request.List)}]不存在！"
                };
            }
            try
            {
                //获取库存数据 生成盘点单据
                var inventoryDetails = await DbHelp.db.Queryable<InventoryDetail>()
                                            .Includes(t => t.StoreInfo)
                                            .Where(t => request.List.Contains(t.StoreInfo.ShelfCode))
                                            .ToListAsync();
                if (inventoryDetails == null || inventoryDetails.Count == 0)
                {
                    return new SysStockTakingOrderResponse()
                    {
                        Code = 201,
                        Message = $"操作失败：未找到需要盘点的库存数据！"
                    };
                }

                await DbHelp.db.BeginTranAsync();

                //盘点单据保存
                var stockTakingOrder = new StockTakingOrder()
                {
                    StocktakingOrderNumber = request.StocktakingOrderNumber,
                    StocktakingOrderSource = request.StocktakingOrderSource,
                    CreateUser = request.UserName
                };
                var stockTakingOrderId = await DbHelp.db.Insertable(stockTakingOrder).ExecuteReturnIdentityAsync();
                stockTakingOrder.Id = stockTakingOrderId;
                //盘点物料明细保存
                foreach (var inventoryDetail in inventoryDetails)
                {
                    var stockTakingOrderMatDetail = new StockTakingOrderMatDetail()
                    {
                        StocktakingOrderId = stockTakingOrderId,
                        StocktakingOrderNumber = request.StocktakingOrderNumber,

                        StoreId = inventoryDetail.StoreId,
                        StoreCode = inventoryDetail.StoreCode,

                        MatSN = inventoryDetail.MatSN,
                        MatCode = inventoryDetail.MatCode,
                        MatName = inventoryDetail.MatName,
                        MatBatch = inventoryDetail.MatBatch,
                        MatSpec = inventoryDetail.MatSpec,
                        MatQty = inventoryDetail.MatQty,
                        MatCustomer = inventoryDetail.MatCustomer,
                        MatSupplier = inventoryDetail.MatSupplier,

                        IsStocktaking = false,
                        StocktakingQty = inventoryDetail.MatQty,
                        UpdateUser = request.UserName
                    };
                    await DbHelp.db.Insertable(stockTakingOrderMatDetail).ExecuteReturnIdentityAsync();
                }
                await DbHelp.db.CommitTranAsync();
                return new SysStockTakingOrderResponse()
                {
                    Data = new SysStockTakingOrderData() { StocktakingOrderNumber = request.StocktakingOrderNumber },
                    Code = 200,
                    Message = $"Success"
                };
            }
            catch (Exception ex)
            {
                return new SysStockTakingOrderResponse()
                {
                    Code = 201,
                    Message = $"操作失败：{ex.Message}"
                };
            }
        }

        public async Task<ResponseBase> SysStockTakingOrderByMatCodes(SysStockTakingOrderRequest request)
        {
            //校验参数
            if (request.List == null || request.List.Count == 0)
                return new SysStockTakingOrderResponse()
                {

                    Code = 201,
                    Message = $"操作失败：缺少必要参数"
                };
            //获取库存数据 生成盘点单据
            var inventoryDetails = await DbHelp.db.Queryable<InventoryDetail>()
                                            .Where(t => request.List.Contains(t.MatCode))
                                            .ToListAsync();
            if (inventoryDetails == null || inventoryDetails.Count == 0)
            {
                return new SysStockTakingOrderResponse()
                {
                    Code = 201,
                    Message = $"操作失败：未找到需要盘点的库存数据！"
                };
            }
            try
            {
                await DbHelp.db.BeginTranAsync();

                //盘点单据保存
                var stockTakingOrder = new StockTakingOrder()
                {
                    StocktakingOrderNumber = request.StocktakingOrderNumber,
                    StocktakingOrderSource = request.StocktakingOrderSource,
                    CreateUser = request.UserName
                };
                var stockTakingOrderId = await DbHelp.db.Insertable(stockTakingOrder).ExecuteReturnIdentityAsync();
                stockTakingOrder.Id = stockTakingOrderId;
                //盘点物料明细保存
                foreach (var inventoryDetail in inventoryDetails)
                {
                    var stockTakingOrderMatDetail = new StockTakingOrderMatDetail()
                    {
                        StocktakingOrderId = stockTakingOrderId,
                        StocktakingOrderNumber = request.StocktakingOrderNumber,

                        StoreId = inventoryDetail.StoreId,
                        StoreCode = inventoryDetail.StoreCode,

                        MatSN = inventoryDetail.MatSN,
                        MatCode = inventoryDetail.MatCode,
                        MatName = inventoryDetail.MatName,
                        MatBatch = inventoryDetail.MatBatch,
                        MatSpec = inventoryDetail.MatSpec,
                        MatQty = inventoryDetail.MatQty,
                        MatCustomer = inventoryDetail.MatCustomer,
                        MatSupplier = inventoryDetail.MatSupplier,

                        IsStocktaking = false,
                        StocktakingQty = inventoryDetail.MatQty,
                        UpdateUser = request.UserName
                    };
                    await DbHelp.db.Insertable(stockTakingOrderMatDetail).ExecuteReturnIdentityAsync();
                }
                await DbHelp.db.CommitTranAsync();
                return new SysStockTakingOrderResponse()
                {
                    Data = new SysStockTakingOrderData() { StocktakingOrderNumber = request.StocktakingOrderNumber },
                    Code = 200,
                    Message = $"Success"
                };
            }
            catch (Exception ex)
            {
                return new SysStockTakingOrderResponse()
                {
                    Code = 201,
                    Message = $"操作失败：{ex.Message}"
                };
            }
        }

        public async Task<ResponseBase> SysStockTakingOrderSnList(SysStockTakingOrderRequest request)
        {
            //校验参数
            if (request.List == null || request.List.Count == 0)
                return new SysStockTakingOrderResponse()
                {

                    Code = 201,
                    Message = $"操作失败：缺少必要参数"
                };
            //获取库存数据 生成盘点单据
            var inventoryDetails = await DbHelp.db.Queryable<InventoryDetail>()
                                            .Where(t => request.List.Contains(t.MatSN))
                                            .ToListAsync();
            if (inventoryDetails == null || inventoryDetails.Count == 0)
            {
                return new SysStockTakingOrderResponse()
                {
                    Code = 201,
                    Message = $"操作失败：未找到需要盘点的库存数据！"
                };
            }
            try
            {
                await DbHelp.db.BeginTranAsync();

                //盘点单据保存
                var stockTakingOrder = new StockTakingOrder()
                {
                    StocktakingOrderNumber = request.StocktakingOrderNumber,
                    StocktakingOrderSource = request.StocktakingOrderSource,
                    CreateUser = request.UserName
                };
                var stockTakingOrderId = await DbHelp.db.Insertable(stockTakingOrder).ExecuteReturnIdentityAsync();
                stockTakingOrder.Id = stockTakingOrderId;
                //盘点物料明细保存
                foreach (var inventoryDetail in inventoryDetails)
                {
                    var stockTakingOrderMatDetail = new StockTakingOrderMatDetail()
                    {
                        StocktakingOrderId = stockTakingOrderId,
                        StocktakingOrderNumber = request.StocktakingOrderNumber,

                        StoreId = inventoryDetail.StoreId,
                        StoreCode = inventoryDetail.StoreCode,

                        MatSN = inventoryDetail.MatSN,
                        MatCode = inventoryDetail.MatCode,
                        MatName = inventoryDetail.MatName,
                        MatBatch = inventoryDetail.MatBatch,
                        MatSpec = inventoryDetail.MatSpec,
                        MatQty = inventoryDetail.MatQty,
                        MatCustomer = inventoryDetail.MatCustomer,
                        MatSupplier = inventoryDetail.MatSupplier,

                        IsStocktaking = false,
                        StocktakingQty = inventoryDetail.MatQty,
                        UpdateUser = request.UserName
                    };
                    await DbHelp.db.Insertable(stockTakingOrderMatDetail).ExecuteReturnIdentityAsync();
                }
                await DbHelp.db.CommitTranAsync();
                return new SysStockTakingOrderResponse()
                {
                    Data = new SysStockTakingOrderData() { StocktakingOrderNumber = request.StocktakingOrderNumber },
                    Code = 200,
                    Message = $"Success"
                };
            }
            catch (Exception ex)
            {
                return new SysStockTakingOrderResponse()
                {
                    Code = 201,
                    Message = $"操作失败：{ex.Message}"
                };
            }
        }
        #endregion

        public async Task<PageQueryResponse<StockTakingOrder>> getStockTakingOrders(GetStockTakingOrdersRequest request)
        {
            try
            {

                var recordsQueryable = DbHelp.db.Queryable<StockTakingOrder>()
                                                .WhereIF(!string.IsNullOrEmpty(request.StocktakingOrderNumber), t => t.StocktakingOrderNumber.Contains(request.StocktakingOrderNumber))
                                                .WhereIF(!string.IsNullOrEmpty(request.StocktakingOrderSource), t => t.StocktakingOrderSource!=null && t.StocktakingOrderSource.Contains(request.StocktakingOrderSource));

                switch (request.StocktakingOrderStatus)
                {
                    case Model.ApiModel.Stocktaking.StocktakingOrderStatus.未盘点:
                        recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == StocktakingOrderStatus.未盘点);
                        break;
                    case Model.ApiModel.Stocktaking.StocktakingOrderStatus.部分盘点:
                        recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == StocktakingOrderStatus.部分盘点);
                        break;
                    case Model.ApiModel.Stocktaking.StocktakingOrderStatus.已提交:
                        recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == StocktakingOrderStatus.已提交);
                        break;
                    case Model.ApiModel.Stocktaking.StocktakingOrderStatus.盘点完成:
                        recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == StocktakingOrderStatus.盘点完成);
                        break;
                    default:
                        break;
                }

                var totalCount = await recordsQueryable.CountAsync();
                var records = await recordsQueryable
                                    .Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
                                    .Select<StockTakingOrder>()
                                    .ToListAsync();
                //生成序号
                for (int i = 0; i < records.Count; i++)
                {
                    records[i].RowNumber = (request.PageNumber - 1) * 10 + i + 1;
                }

                return new PageQueryResponse<StockTakingOrder>()
                {
                    Code = 200,
                    Message = $"success",
                    Data = new PageQueryResponseData<StockTakingOrder>()
                    {
                        TotalCount = totalCount,
                        MaxPage = request.PageSize == 0 ? 0 : (int)Math.Ceiling((decimal)totalCount / request.PageSize),
                        Count = records.Count,
                        Lists = records.ToList()
                    }
                };

            }
            catch (Exception ex)
            {
                return new PageQueryResponse<StockTakingOrder>()
                {
                    Code = 300,
                    Message = $"操作失败:{ex.Message}",
                };
            }
        }

        public async Task<ResponseBase> getStockTakingOrderMatDetail(GetStockTakingOrderMatDetailRequest request)
        {
            #region 查询盘点单
            StockTakingOrder order = null;
            if (request.StockTakingOrderId != 0)
            {
                order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.Id == request.StockTakingOrderId).FirstAsync();
                if (order == null)
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"查询失败：不存在Id为{request.StockTakingOrderId}的出库单！",
                    };
                }
            }
            else if (!string.IsNullOrEmpty(request.StockTakingOrderNumber))
            {
                order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.StocktakingOrderNumber == request.StockTakingOrderNumber)
                                                                     .FirstAsync();
                if (order == null)
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"查询失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
                    };
                }
            }
            else
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"查询失败：缺少必要参数！",
                };
            }
            #endregion

            //查询物料明细
            var stockTakingOrderMatDetail = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
                                        .Where(t => t.StocktakingOrderId == order.Id)
                                        .ToListAsync();

            return new ResponseCommon<List<StockTakingOrderMatDetail>>()
            {
                Code = 200,
                Message = "success",
                Data = stockTakingOrderMatDetail
            };
        }

        public async Task<ResponseBase> startStockTakingOrder(GetStockTakingOrderMatDetailRequest request)
        {
            try
            {
                #region 查询盘点单
                StockTakingOrder order = null;
                if (request.StockTakingOrderId != 0)
                {
                    order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.Id == request.StockTakingOrderId).FirstAsync();
                    if (order == null)
                    {
                        return new ResponseCommon()
                        {
                            Code = 201,
                            Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
                        };
                    }
                }
                else if (!string.IsNullOrEmpty(request.StockTakingOrderNumber))
                {
                    order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.StocktakingOrderNumber == request.StockTakingOrderNumber)
                                                                         .FirstAsync();
                    if (order == null)
                    {
                        return new ResponseCommon()
                        {
                            Code = 201,
                            Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
                        };
                    }
                }
                else
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"操作失败：缺少必要参数！",
                    };
                }
                #endregion

                #region 查询物料明细
                //查询物料明细
                var stockTakingOrderMatDetail = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
                                            .Where(t => t.StocktakingOrderId == order.Id)
                                            .ToListAsync();
                //TO DO 货架按物料进入盘点模式
                var shelf = ShelfManager.Shelves.First();
                shelf.GoInStocktaking();
                shelf.OrderNumber = order.StocktakingOrderNumber;
                #endregion

                return new ResponseCommon()
                {
                    Code = 200,
                    Message = $"success",
                    Data = shelf.ShelfCode
                };
            }
            catch (Exception ex)
            {
                return new ResponseCommon()
                {
                    Code = 300,
                    Message = $"操作失败，{ex.Message}",
                };
            }
        }

        public async Task<ResponseBase> endStockTakingOrder(GetStockTakingOrderMatDetailRequest request)
        {
            try
            {
                #region 查询盘点单
                StockTakingOrder order = null;
                if (request.StockTakingOrderId != 0)
                {
                    order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.Id == request.StockTakingOrderId).FirstAsync();
                    if (order == null)
                    {
                        return new ResponseCommon()
                        {
                            Code = 201,
                            Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
                        };
                    }
                }
                else if (!string.IsNullOrEmpty(request.StockTakingOrderNumber))
                {
                    order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.StocktakingOrderNumber == request.StockTakingOrderNumber)
                                                                         .FirstAsync();
                    if (order == null)
                    {
                        return new ResponseCommon()
                        {
                            Code = 201,
                            Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
                        };
                    }
                }
                else
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"操作失败：缺少必要参数！",
                    };
                }
                #endregion

                #region 查询当前盘点盘已启动的货架
                var shelfs = ShelfManager.Shelves.Where(t => t.CurrentMode == HardWare.Mode.盘点模式 && t.OrderNumber == order.StocktakingOrderNumber).ToList();
                shelfs.ForEach(t =>
                {
                    t.GoOutStocktaking();
                });
                #endregion

                return new ResponseCommon()
                {
                    Code = 200,
                    Message = $"success",
                    Data = shelfs.Select(t => t.ShelfCode).ToList(),
                };
            }
            catch (Exception ex)
            {
                return new ResponseCommon()
                {
                    Code = 300,
                    Message = $"操作失败，{ex.Message}",
                };
            }
        }

        public async Task<ResponseBase> queryMatInfoInStocktakingOrder(QueryMatInfoInStocktakingOrderRequest request)
        { 
            //判断是否有这个物料
            var storeInfo = await DbHelp.db.Queryable<InventoryDetail>()
                                           .LeftJoin<StoreInfo>((id,si)=>id.StoreId == si.Id)
                                            .Where((id, si) => id.MatSN == request.MatSN)
                                            .Select((id, si) => si)
                                            .FirstAsync();
            if (storeInfo == null)
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"不存在物料[{request.MatSN}]",
                };
            }
            //判断货架是否进入入库模式
            var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == storeInfo.ShelfCode).FirstOrDefault();
            if (shelf == null)
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"物料[{request.MatSN}不是本次需要盘点的物料！！！]",
                };
            }
            //进入入库模式的那个单据是否有对应的单据明细
            var stockTakingOrder = await DbHelp.db.Queryable<StockTakingOrder>()
                                                  .Where(t => t.StocktakingOrderNumber == shelf.OrderNumber)
                                                  .FirstAsync();
            if (stockTakingOrder == null)
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"未找到对应盘点单据{shelf.OrderNumber}",
                };
            }
            //返回具体的单据信息
            var stockTakinbgOrder = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
                                                   .Where(t => t.StocktakingOrderId == stockTakingOrder.Id)
                                                   .Where(t => t.MatSN == request.MatSN)
                                                   .FirstAsync();
            return new ResponseCommon<StockTakingOrderMatDetail>()
            { 
                Code = 200,
                Message = "success",
                Data = stockTakinbgOrder
            };

        }

        public async Task<ResponseBase> confirmStocktakingOrder(ConfirmStocktakingOrderRequest request)
        {
            //获取盘点物料明细
            var stockTakingMatDetail =await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
                                                .Where(t => t.Id == request.Id)
                                                .FirstAsync();
            if (stockTakingMatDetail == null)
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"不存在的盘点明细",
                };
            }

            //修改盘点吗明细数量
            stockTakingMatDetail.StocktakingQty = request.Qty;
            stockTakingMatDetail.IsStocktaking = true;
            await DbHelp.db.Updateable(stockTakingMatDetail).ExecuteCommandAsync();
            return new ResponseCommon()
            {
                Code = 200,
                Message = $"success",
            };
        }

        public async Task<ResponseBase> commitStockTakingOrder(GetStockTakingOrderMatDetailRequest request)
        {
            try
            {
                #region 查询盘点单
                StockTakingOrder order = null;
                if (request.StockTakingOrderId != 0)
                {
                    order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.Id == request.StockTakingOrderId).FirstAsync();
                    if (order == null)
                    {
                        return new ResponseCommon()
                        {
                            Code = 201,
                            Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
                        };
                    }
                }
                else if (!string.IsNullOrEmpty(request.StockTakingOrderNumber))
                {
                    order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.StocktakingOrderNumber == request.StockTakingOrderNumber)
                                                                         .FirstAsync();
                    if (order == null)
                    {
                        return new ResponseCommon()
                        {
                            Code = 201,
                            Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
                        };
                    }
                }
                else
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"操作失败：缺少必要参数！",
                    };
                }
                #endregion

                #region 判断单据状态
                if (order.StocktakingOrderStatus != StocktakingOrderStatus.已提交)
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"单据已提交，请勿重复提交！",
                    };
                }
                else if (order.StocktakingOrderStatus != StocktakingOrderStatus.盘点完成)
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"单据未盘点完成！！！",
                    };
                }
                #endregion
                //To do 进行提交！

                return new ResponseCommon()
                {
                    Code = 200,
                    Message = $"success",
                };
            }
            catch (Exception ex)
            {
                return new ResponseCommon()
                {
                    Code = 300,
                    Message = $"操作失败，{ex.Message}",
                };
            }
        }
    }
}