using HH.WMS.BLL.Basic;
using HH.WMS.Common;
using HH.WMS.Common.Algorithm;
using HH.WMS.Common.External;
using HH.WMS.DAL.External;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Autobom;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.External;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace HH.WMS.BLL.External
{
    /// <summary>
    /// 
    /// </summary>
    public class TaskTransferBLL : BaseBLL
    {

        #region 获取入作业区列表 + GetInWorkPosition

        /// <summary>
        /// 获取入作业区列表
        /// </summary>
        /// <param name="executeInWorkAreaPara"></param>
        /// <returns></returns>
        public List<TN_AB_B_WORK_AREA_PROEntity> GetInWorkPosition(ExecuteInWorkAreaPara executeInWorkAreaPara)
        {
            //根据起始库区计算作业区
            var workAreaProList = BLLCreator.Create<TN_AB_B_WORK_AREA_PROBLL>().GetRoute("", executeInWorkAreaPara.InWorkAreaEntity.startArea, executeInWorkAreaPara.InWorkAreaEntity.endArea);
            if (workAreaProList.Any())
            {
                //没有条件的记录
                var notExpressWork = workAreaProList.FindAll(p => string.IsNullOrEmpty(p.CN_S_EXPRESS));

                //有条件才会匹配，否则直接返回
                if (workAreaProList.Count != notExpressWork.Count)
                {
                    workAreaProList = GetMatchPro(new TaskTransferEntity()
                    {
                        StartArea = executeInWorkAreaPara.InWorkAreaEntity.startArea,
                        StartBit = executeInWorkAreaPara.InWorkAreaEntity.startBit,
                        CirObjCode = executeInWorkAreaPara.InWorkAreaEntity.trayCode
                    }, workAreaProList);
                    if (workAreaProList.Count == 0)
                        workAreaProList = notExpressWork;
                }
            }
            return workAreaProList;
        }

        #endregion

        #region 获取出作业区列表 + GetOutWorkPosition

        /// <summary>
        /// 获取入作业区列表
        /// </summary>
        /// <param name="executeOutWorkAreaPara"></param>
        /// <returns></returns>
        public List<TN_AB_B_WORK_AREA_PROEntity> GetOutWorkPosition(ExecuteOutWorkAreaPara executeOutWorkAreaPara)
        {
            //根据起始库区计算作业区
            var workAreaProList = BLLCreator.Create<TN_AB_B_WORK_AREA_PROBLL>().GetRoute("", executeOutWorkAreaPara.OutWorkAreaEntity.startArea, executeOutWorkAreaPara.OutWorkAreaEntity.endArea);
            if (workAreaProList.Any())
            {
                //没有条件的记录
                var notExpressWork = workAreaProList.FindAll(p => string.IsNullOrEmpty(p.CN_S_EXPRESS));

                //有条件才会匹配，否则直接返回
                if (workAreaProList.Count != notExpressWork.Count)
                {
                    workAreaProList = GetMatchPro(new TaskTransferEntity
                    {
                        StartArea = executeOutWorkAreaPara.OutWorkAreaEntity.startArea,
                        StartBit = executeOutWorkAreaPara.OutWorkAreaEntity.startBit,
                        CirObjCode = executeOutWorkAreaPara.OutWorkAreaEntity.trayCode
                    }, workAreaProList);
                    if (workAreaProList.Count == 0)
                        workAreaProList = notExpressWork;
                }
            }
            return workAreaProList;
        }

        #endregion

        #region 获取改道作业区列表 + GetWayWorkPosition

        /// <summary>
        /// 获取入作业区列表
        /// </summary>
        /// <param name="executeInWorkAreaPara"></param>
        /// <returns></returns>
        public MsgEntity GetWayWorkPosition(TaskTransferEntity entity)
        {
            MsgEntity msg = new MsgEntity();

            if (string.IsNullOrEmpty(entity.StartArea) && !string.IsNullOrEmpty(entity.StartBit))
            {
                AutoBomLocationEntity location = BLLCreator.Create<TN_AB_STOCK_LOCATIONBLL>().GetLocationModel(entity.StartBit);
                if (location != null)
                {
                    entity.StartArea = location.CN_S_AREA_CODE;
                }
            }
            if (string.IsNullOrEmpty(entity.EndArea) && !string.IsNullOrEmpty(entity.EndBit))
            {
                AutoBomLocationEntity location = BLLCreator.Create<TN_AB_STOCK_LOCATIONBLL>().GetLocationModel(entity.EndBit);
                if (location != null)
                {
                    entity.EndArea = location.CN_S_AREA_CODE;
                }
            }

            List<TN_AB_B_WORK_AREA_PROEntity> workAreaProList = BLLCreator.Create<TN_AB_B_WORK_AREA_PROBLL>()
                .GetRoute(entity.WorkType,
                          entity.StartArea,
                          entity.EndArea);


            if (workAreaProList.Any())
            {
                var notExpressWork = workAreaProList.FindAll(p => string.IsNullOrEmpty(p.CN_S_EXPRESS));
                //有条件才会匹配，否则直接返回
                if (!(workAreaProList.Count == workAreaProList.FindAll(p => string.IsNullOrEmpty(p.CN_S_EXPRESS)).Count))
                {
                    workAreaProList = GetMatchPro(entity, workAreaProList);
                }
                if (!workAreaProList.Any())
                    workAreaProList = notExpressWork;
            }
            msg.Success = workAreaProList.Any();
            msg.Data = workAreaProList;
            if (!msg.Success)
                msg.Msg = "请确认货位是否为空筒和半筒位置编码！";
            return msg;
        }

        #endregion

        #region 分组匹配条件

        /// <summary>
        /// 分组匹配条件
        /// </summary>
        /// <param name="taskEntity"></param>
        /// <param name="workAreaProList"></param>
        /// <returns></returns>
        private List<TN_AB_B_WORK_AREA_PROEntity> GetMatchPro(TaskTransferEntity taskEntity, List<TN_AB_B_WORK_AREA_PROEntity> workAreaProList)
        {
            taskEntity.TrayCode = taskEntity.CirObjCode;
            taskEntity.TrayType = "托盘";
            taskEntity.CirObj = Constants.TU_Tray;
            taskEntity.WorkType = Constants.WorkType_UpperReachesIn;

            List<TN_AB_B_WORK_AREA_PROEntity> matchWorkAreaProList = new List<TN_AB_B_WORK_AREA_PROEntity>();
            foreach (var workAreaPro in workAreaProList)
            {
                string express = workAreaPro.CN_S_EXPRESS;
                if (string.IsNullOrEmpty(express)) continue;
                ConditionConfig conditionEntity = JsonConvert.DeserializeObject<ConditionConfig>(express);
                if (conditionEntity == null) continue;
                bool isMatch = GetConditionValue(taskEntity, conditionEntity);
                if (isMatch)
                    matchWorkAreaProList.Add(workAreaPro);
            }
            return matchWorkAreaProList;
        }
        #endregion

        #region 返回匹配逻辑bool
        /// <summary>
        /// 返回匹配逻辑bool
        /// </summary>
        /// <param name="taskEntity"></param>
        /// <param name="conditionEntity"></param>
        /// <returns></returns>
        private bool GetConditionValue(TaskTransferEntity taskEntity, ConditionConfig conditionEntity)
        {
            //逻辑List 下的所有bool值
            List<bool> boolList = new List<bool>();
            foreach (var condition in conditionEntity.List)
            {
                //可能为逻辑 或者 为符号
                JObject _condition = condition as JObject;
                if (_condition["List"] != null)
                {
                    //有逻辑的 带List
                    ConditionConfig conditionConfig = JsonConvert.DeserializeObject<ConditionConfig>(condition.ToString());
                    //继续
                    return GetConditionValue(taskEntity, conditionConfig);
                }
                else
                {
                    //符号的 直接匹配到返回bool
                    RelationConfig relationConfig = JsonConvert.DeserializeObject<RelationConfig>(condition.ToString());
                    bool relationValue = GetRelationValue(taskEntity, relationConfig);
                    //是or,有一个true,直接返回true
                    if (conditionEntity.LType == LogicSymBol.Or)
                    {
                        if (relationValue)
                            return true;
                    }
                    //添加bool到List
                    boolList.Add(relationValue);
                }
            }
            switch (conditionEntity.LType)
            {
                case LogicSymBol.And:
                    return !boolList.Contains(false);
                case LogicSymBol.Or:
                    return boolList.Contains(true);
            }
            return false;
        }
        #endregion

        #region 返回匹配关系bool
        /// <summary>
        /// 返回匹配关系bool
        /// </summary>
        /// <param name="taskEntity"></param>
        /// <param name="relationEntity"></param>
        /// <returns></returns>
        private bool GetRelationValue(TaskTransferEntity taskEntity, RelationConfig relationEntity)
        {
            string taskValue = string.Empty;
            PropertyInfo[] props = taskEntity.GetType().GetProperties();
            foreach (var prop in props)
            {
                if (prop.Name.Equals(relationEntity.Name))
                {
                    //特殊处理的条件
                    switch (prop.Name)
                    {
                        case "IsFullTray"://整托
                            taskEntity.IsFullTray = "N";
                            if (taskEntity.IsTrayAll.HasValue)
                            {
                                taskEntity.IsFullTray = taskEntity.IsTrayAll.Value ? "Y" : "N";
                            }
                            break;
                        case "IsEmptyTray"://空托
                            taskEntity.IsEmptyTray = "N";
                            if (taskEntity.ConditionDefine.IsEmptyTray.HasValue)
                            {
                                taskEntity.IsEmptyTray = taskEntity.ConditionDefine.IsEmptyTray.Value ? "Y" : "N";
                            }
                            else
                            {
                                if (taskEntity.CirObj == "托盘" && !string.IsNullOrEmpty(taskEntity.CirObjCode))
                                {
                                    var _trayItemRel = CreateDAL<TN_WM_B_TRAY_ITEM_RELDAL>().GetItemRelModel("WHERE CN_S_ITEM_CODE='" + taskEntity.CirObjCode + "'");
                                    if (!_trayItemRel.Any())
                                    {
                                        taskEntity.IsEmptyTray = "Y";
                                    }
                                }
                            }
                            break;
                        case "ItemState"://物料状态
                            taskEntity.ItemState = "";
                            if (!string.IsNullOrEmpty(taskEntity.ConditionDefine.ItemState))
                            {
                                taskEntity.ItemState = taskEntity.ConditionDefine.ItemState;
                            }
                            else
                            {
                                if (taskEntity.CirObj == "物料" && !string.IsNullOrEmpty(taskEntity.CirObjCode))
                                {
                                    var _trayItemRel = CreateDAL<TN_WM_B_TRAY_ITEM_RELDAL>().GetItemRelModel("WHERE CN_S_TRAY_CODE='" + taskEntity.CirObjCode + "'");
                                    if (_trayItemRel.Any())
                                    {
                                        taskEntity.ItemState = _trayItemRel[0].CN_S_ITEM_STATE;
                                    }
                                }
                            }
                            break;
                    }
                    taskValue = Util.ToString(prop.GetValue(taskEntity, null));
                }
            }
            bool equal = taskValue.Equals(relationEntity.Value);
            switch (relationEntity.RType)
            {
                case RelationSymBol.Eq: return equal;
                case RelationSymBol.Ne: return !equal;
            }
            return false;
        }
        #endregion

        #region 设置是否合并，拣货模式
        /// <summary>
        ///设置是否合并，拣货模式
        /// </summary>
        /// <param name="sortingList"></param>
        /// <param name="taskEntity"></param>
        private void SetTaskEntity(List<TN_WM_SORTING_LISTEntity> sortingList, TaskTransferEntity taskEntity)
        {
            if (sortingList.Any())
            {
                IEnumerable<IGrouping<string, TN_WM_SORTING_LISTEntity>> ig = sortingList.GroupBy(p => p.CN_S_GROUP);
                taskEntity.PickModel = sortingList[0].CN_S_SEEDING_MODE;
                taskEntity.NeedMerge = "N";
                foreach (var _ig in ig)
                {
                    if (_ig.Count() > 1)
                    {
                        taskEntity.NeedMerge = "Y";
                        break;
                    }
                }
            }
        }
        #endregion
    }
}