using HH.Redis.ReisModel;
using HH.WMS.BLL;
using HH.WMS.BLL.Basic;
using HH.WMS.BLL.Common;
using HH.WMS.BLL.OutStock;
using HH.WMS.Common;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Common;
using HH.WMS.WebApi.Areas.Common.Controllers;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;

namespace HH.WMS.WebApi.Areas.OutStock.Controllers
{
    public class SowingController : BaseController
    {
        #region (PDA)二次分播扫波次
        /// <summary>
        /// (PDA)二次分播扫波次
        /// </summary>
        /// <param name="waveNo"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult ScanWave(string waveNo)
        {
            return ValidateToken(t =>
            {
                var waveEntity = BLLCreator.Create<DapperBLL<TN_WM_WAVE_MSTEntity>>().GetSingleEntity(new
                {
                    CN_S_WAVE_NO = waveNo
                });
                if (waveEntity == null)
                {
                    var outMst = BLLCreator.CreateDapper<TN_WM_OUT_MSTEntity>().GetSingleEntity(new
                    {
                        CN_S_OP_NO = waveNo
                    });
                    if (outMst == null)
                        return OperateResult.Error("未能找到单据：" + waveNo + "的波次信息");
                    waveEntity = BLLCreator.Create<DapperBLL<TN_WM_WAVE_MSTEntity>>().GetSingleEntity(new
                    {
                        CN_S_WAVE_NO = outMst.CN_S_WAVE_CODE
                    });
                    if (waveEntity == null)
                        return OperateResult.Error("未能找到单据：" + waveNo + "的波次信息");
                }
                waveNo = waveEntity.CN_S_WAVE_NO;
                if (waveEntity.CN_S_STATE.Equals(Constants.Sorting_Stay) ||
                    waveEntity.CN_S_STATE.Equals(Constants.Sorting_Being))
                    return OperateResult.Error("波次下存在未捡完的分拣单！");
                if (waveEntity.CN_S_STATE.Equals(Constants.Sorting_Sorted) ||
                    waveEntity.CN_S_STATE.Equals(Constants.Wave_Sowing))
                {
                    var waveDtlList = BLLCreator.Create<DapperBLL<TN_WM_WAVE_DTLEntity>>().GetList(new
                    {
                        CN_S_WAVE_NO = waveNo
                    });

                    //return OperateResult.Succeed(null,  waveDtlList.Select(x => x.CN_S_ORDER_NO));
                    return OperateResult.Succeed(null, new
                    {
                        WaveNo = waveNo,
                        Orders = waveDtlList.Select(x => x.CN_S_ORDER_NO)
                    });
                }
                else
                {
                    return OperateResult.Error("当前波次已分播完成！");
                }
            });
        }
        #endregion

        #region 二次分播扫物料
        /// <summary>
        /// 二次分播扫物料
        /// </summary>
        /// <param name="uniqueCode"></param>
        /// <param name="waveNo"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult SowingItem(string uniqueCode, string waveNo)
        {
            return ValidateToken(t =>
            {
                ScanCodeClass scanCode = BLLCreator.Create<MONGO_KEYTYPE_MAPBLL>().AnalysisCode(uniqueCode);
                if (scanCode == null)
                    return OperateResult.Error("未找到该条码！");
                if (scanCode.Type != "2" && scanCode.Type != "4")
                {
                    return OperateResult.Error("扫描条码不合法！");
                }
                TN_WM_B_UNIQUE_BARCODEEntity barCodeEntity = new TN_WM_B_UNIQUE_BARCODEEntity();
                if (scanCode.Type == "2")
                {
                    barCodeEntity = scanCode.uniqueCode;
                }
                else
                {
                    var currentItemEntity = scanCode.Item.itemEntity;
                    barCodeEntity.CN_S_ITEM_CODE = currentItemEntity.CN_S_ITEM_CODE;
                    barCodeEntity.CN_S_ITEM_NAME = currentItemEntity.CN_S_ITEM_NAME;
                    barCodeEntity.CN_F_PACKING_QTY = currentItemEntity.CN_F_MIN_PACK_QTY == 0 ? 1 : currentItemEntity.CN_F_MIN_PACK_QTY;
                }

                if (scanCode.Type == "4" && barCodeEntity.CN_F_PACKING_QTY < 1)
                {
                    var itemEntity = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItem(barCodeEntity.CN_S_ITEM_CODE);
                    if (itemEntity != null)
                        barCodeEntity.CN_F_PACKING_QTY = itemEntity.CN_F_MIN_PACK_QTY == 0 ? 1 : itemEntity.CN_F_MIN_PACK_QTY;
                    else
                        barCodeEntity.CN_F_PACKING_QTY = 1;
                }
                var outMstList = BLLCreator.Create<DapperBLL<TN_WM_OUT_MSTEntity>>().GetList(new
                {
                    CN_S_WAVE_CODE = waveNo
                });
                var outDtlList = BLLCreator.Create<DapperBLL<TN_WM_OUT_DTLEntity>>().GetList(new
                {
                    CN_S_OP_NO = outMstList.Select(x => x.CN_S_OP_NO).ToList()
                });
                outDtlList = outDtlList.FindAll(x =>
                {
                    if (scanCode.Type == "4")
                    {
                        barCodeEntity.CN_S_ITEM_STATE = x.CN_S_ITEM_STATE;
                        barCodeEntity.CN_S_OWNER = outMstList.Find(y => y.CN_S_OP_NO == x.CN_S_OP_NO).CN_S_OWNER;
                        barCodeEntity.CN_S_BATCH_NO = x.CN_S_PRODUCTION_BATCH;
                    }
                    return x.CN_S_ITEM_CODE == barCodeEntity.CN_S_ITEM_CODE &&
                            x.CN_S_ITEM_STATE.Equals(barCodeEntity.CN_S_ITEM_STATE) &&
                            outMstList.Find(y => y.CN_S_OP_NO == x.CN_S_OP_NO).CN_S_OWNER.Equals(barCodeEntity.CN_S_OWNER) &&
                            (string.IsNullOrEmpty(x.CN_S_PRODUCTION_BATCH) || x.CN_S_PRODUCTION_BATCH.Equals(barCodeEntity.CN_S_BATCH_NO));
                });
                if (!outDtlList.Any())
                    return OperateResult.Error("未找到该物料匹配的出库单！");

                outMstList.ForEach(x => x.OutDtlList = outDtlList.FindAll(y => y.CN_S_OP_NO == x.CN_S_OP_NO));

                var orderSortingList = BLLCreator.Create<DapperBLL<TN_WM_ORDER_SORTING_RELEntity>>().GetList(new
                {
                    CN_S_ORDER_NO = outMstList.Select(x => x.CN_S_OP_NO).ToList(),
                    CN_C_ISPACK = Constants.N
                }).FindAll(x =>
                {
                    if (scanCode.Type == "4")
                    {
                        barCodeEntity.CN_S_ITEM_STATE = x.CN_S_ITEM_STATE;
                        barCodeEntity.CN_S_OWNER = x.CN_S_OWNER;
                        barCodeEntity.CN_S_BATCH_NO = x.CN_S_PRODUCTION_BATCH;
                    }
                    return x.CN_S_ITEM_CODE == barCodeEntity.CN_S_ITEM_CODE &&
                           x.CN_S_ITEM_STATE.Equals(barCodeEntity.CN_S_ITEM_STATE) &&
                           x.CN_S_OWNER.Equals(barCodeEntity.CN_S_OWNER) &&
                           (string.IsNullOrEmpty(x.CN_S_PRODUCTION_BATCH) || x.CN_S_PRODUCTION_BATCH.Equals(barCodeEntity.CN_S_BATCH_NO));
                });

                var barCodeQty = barCodeEntity.CN_F_PACKING_QTY;
                if (orderSortingList.Any())
                {
                    foreach (var orderSorting in orderSortingList)
                    {
                        var orderSortingQty = orderSorting.CN_F_QUANTITY;
                        var currentOrderSorting = outMstList.Find(x => x.CN_S_OP_NO.Equals(orderSorting.CN_S_ORDER_NO));
                        if (currentOrderSorting != null)
                        {
                            if (currentOrderSorting.OutDtlList.Any())
                            {
                                currentOrderSorting.OutDtlList[0].CN_F_SOWING_QUANTITY += orderSortingQty;
                            }
                        }
                    }
                }

                bool largerOut = false;
                var batchesOutMst = new TN_WM_OUT_MSTEntity();
                foreach (var outMst in outMstList)
                {
                    var qty = outMst.OutDtlList.Sum(x => x.CN_F_QUANTITY) - outMst.OutDtlList.Sum(x => x.CN_F_SOWING_QUANTITY);
                    if (barCodeQty <= qty)
                    {
                        batchesOutMst = outMst;
                        largerOut = false;
                        break;
                    }
                    else
                    {
                        largerOut = true;
                    }
                }
                if (largerOut)
                    return OperateResult.Error("包装数量大于出库物料数量！");

                if (scanCode.Type == "4")
                {
                    barCodeEntity.CN_F_QUANTITY = Convert.ToInt32(barCodeEntity.CN_F_PACKING_QTY);
                    barCodeEntity.CN_S_OWNER = batchesOutMst.CN_S_OWNER;
                    barCodeEntity.CN_S_ITEM_STATE = batchesOutMst.OutDtlList[0].CN_S_ITEM_STATE;
                    barCodeEntity.CN_S_BATCH_NO = batchesOutMst.OutDtlList[0].CN_S_PRODUCTION_BATCH;
                    barCodeEntity.CN_S_MEASURE_UNIT = batchesOutMst.OutDtlList[0].CN_S_MEASURE_UNIT;
                    barCodeEntity.CN_S_MODEL = batchesOutMst.OutDtlList[0].CN_S_MODEL;
                    barCodeEntity.CN_S_CODE = "";
                }
                var orderSortingEntity = CreateOrderSorting(barCodeEntity, batchesOutMst.CN_S_OP_NO, t);

                var result = BLLCreator.Create<DapperBLL<TN_WM_ORDER_SORTING_RELEntity>>().Add(orderSortingEntity);

                if (!result.Success)
                    return result;
                var resultData = new
                {
                    OutNo = orderSortingEntity.CN_S_ORDER_NO,
                    ItemName = orderSortingEntity.CN_S_ITEM_NAME,
                    ItemCode = orderSortingEntity.CN_S_ITEM_CODE,
                    ItemModel = barCodeEntity.CN_S_MODEL,
                    ItemNum = barCodeEntity.CN_F_PACKING_QTY
                };
                return OperateResult.Succeed(null, resultData);
            });
        }
        #endregion

        #region 分播关联实体
        /// <summary>
        /// 分播关联实体
        /// </summary>
        /// <param name="barCodeEntity"></param>
        /// <param name="outNo"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        private TN_WM_ORDER_SORTING_RELEntity CreateOrderSorting(TN_WM_B_UNIQUE_BARCODEEntity barCodeEntity, string outNo, RedisUserEntity t)
        {
            TN_WM_ORDER_SORTING_RELEntity orderSortingEntity = new TN_WM_ORDER_SORTING_RELEntity()
            {
                CN_GUID = Guid.NewGuid().ToString(),
                CN_S_ORDER_NO = outNo,
                CN_S_ITEM_CODE = barCodeEntity.CN_S_ITEM_CODE,
                CN_S_ITEM_NAME = barCodeEntity.CN_S_ITEM_NAME,
                CN_S_ITEM_STATE = barCodeEntity.CN_S_ITEM_STATE,
                CN_S_PRODUCTION_BATCH = barCodeEntity.CN_S_BATCH_NO,
                CN_F_QUANTITY = barCodeEntity.CN_F_QUANTITY,
                CN_F_RECHECK = barCodeEntity.CN_F_QUANTITY,
                CN_S_OWNER = barCodeEntity.CN_S_OWNER,
                CN_S_PACKING_CODE = "",
                CN_S_PACK_CODE = barCodeEntity.CN_S_CODE,
                CN_S_UNIQUE_CODE = barCodeEntity.CN_S_CODE,
                CN_S_IN_OP_FROM = "",
                CN_S_IN_FROM_NO = "",
                CN_N_IN_ROW_NO = 0,
                CN_S_MEASURE_UNIT = barCodeEntity.CN_S_MEASURE_UNIT,

                CN_S_SERIAL_NO = "",
                CN_S_GROUP = "",
                CN_S_TURNOVERBOX_CODE = "",
                CN_S_SORTING_CAR = "",
                CN_C_ISPACK = Constants.N,
                CN_S_ISSOWING = Constants.Y,
                CN_S_CREATOR = t.CN_S_LOGIN,
                CN_S_CREATOR_BY = t.CN_S_NAME,
                CN_T_CREATE = DateTime.Now,
                CN_S_MODIFY = t.CN_S_LOGIN,
                CN_S_MODIFY_BY = t.CN_S_NAME,
                CN_T_MODIFY = DateTime.Now
            };
            return orderSortingEntity;
        }
        #endregion

        #region 确认分播
        /// <summary>
        /// 确认分播
        /// </summary>
        /// <param name="waveNo"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult ConfirmSowing(string waveNo)
        {
            return ValidateToken(t =>
            {
                return BLLCreator.Create<TN_WM_WAVE_MSTBLL>().ConfirmSowing(waveNo);
            });
        }
        #endregion
    }
}