using HH.WMS.BLL.Basic;
using HH.WMS.BLL.OutStock;
using HH.WMS.Common;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Common;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace HH.WMS.BLL.Common
{
    public class WorkflowBLL : DapperBaseBLL
    {
        #region 找站点
        /// <summary>
        /// 找站点
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public OperateResult GetWorkPosition(WorkflowEntity entity)
        {
            try
            {
                //起点货位获取库区
                if (string.IsNullOrEmpty(entity.StartArea) && !string.IsNullOrEmpty(entity.StartBit))
                {
                    var location = BLLCreator.Create<TN_AB_STOCK_LOCATIONBLL>().GetLocationModel(entity.StartBit)
                        ?? new AutoBomLocationEntity();
                    entity.StartArea = location.CN_S_AREA_CODE;

                }
                //终点货位获取库区
                if (string.IsNullOrEmpty(entity.EndArea) && !string.IsNullOrEmpty(entity.EndBit))
                {
                    var location = BLLCreator.Create<TN_AB_STOCK_LOCATIONBLL>().GetLocationModel(entity.EndBit)
                        ?? new AutoBomLocationEntity();
                    entity.EndArea = location.CN_S_AREA_CODE;
                }
                var workAreaPros = BLLCreator.Create<TN_WM_WORK_AREA_PROBLL>().GetWorkAreaPro(entity.Type, entity.StartArea, entity.EndArea);
                if (workAreaPros.Any())
                {
                    var notExpressWork = workAreaPros.FindAll(p => string.IsNullOrEmpty(p.CN_S_EXPRESS));
                    //有条件才会匹配，否则直接返回
                    if (!(workAreaPros.Count == notExpressWork.Count))
                    {
                        workAreaPros = GetMatchPro(entity, workAreaPros);
                    }
                    if (!workAreaPros.Any())
                        workAreaPros = notExpressWork;
                }
                if (workAreaPros.Any())
                {
                    if (entity.ReturnList)
                        return OperateResult.Succeed(null, workAreaPros);
                    return OperateResult.Succeed(null, workAreaPros[0]);
                }
                return OperateResult.Error("未找到站点，请检查配置");
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 匹配有条件的
        /// <summary>
        /// 匹配有条件的
        /// </summary>
        /// <param name="workflowEntity"></param>
        /// <param name="workAreaPros"></param>
        /// <returns></returns>
        public List<TN_WM_WORK_AREA_PROEntity> GetMatchPro(WorkflowEntity workflowEntity, List<TN_WM_WORK_AREA_PROEntity> workAreaPros)
        {
            //托盘
            if (workflowEntity.CirObj == Constants.Tray)
            {
                workflowEntity.TrayType = Constants.Tray;
                var trayItems = BLLCreator.CreateDapper<TN_WM_B_TRAY_ITEM_MSTEntity>().GetList(new
                {
                    CN_S_TRAY_CODE = workflowEntity.CirObjCode
                });
                workflowEntity.IsEmptyTray = "N";
                if (!trayItems.Any())
                {
                    workflowEntity.IsEmptyTray = "Y";
                }
            }
            //周转箱
            if (workflowEntity.CirObj == Constants.TurnoverBox)
            {
                workflowEntity.TrayType = Constants.TurnoverBox;
            }
            //分拣单
            if (workflowEntity.CirObj == Constants.Rule_SortingNo)
            {
                var sortingEntity = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetSingleEntity(new
                {
                    CN_S_SORTING_NO = workflowEntity.CirObjCode
                });
                if (sortingEntity != null)
                    workflowEntity.PickModel = sortingEntity.CN_S_SEEDING_MODE;
            }
            //出库单
            if (workflowEntity.CirObj == Constants.Rule_OutNo)
            {
                var outEntity = BLLCreator.CreateDapper<TN_WM_OUT_MSTEntity>().GetSingleEntity(new
                {
                    CN_S_OP_NO = workflowEntity.CirObjCode
                });
                if (outEntity != null)
                    workflowEntity.SalesStyle = outEntity.CN_S_SALES_STYLE;
            }
            //匹配的记录
            var matchWorkAreaProList = new List<TN_WM_WORK_AREA_PROEntity>();
            foreach (var workAreaPro in workAreaPros)
            {
                string express = workAreaPro.CN_S_EXPRESS;
                if (string.IsNullOrEmpty(express)) continue;
                ConditionConfig conditionEntity = JsonConvert.DeserializeObject<ConditionConfig>(express);
                if (conditionEntity == null) continue;
                bool isMatch = GetConditionValue(workflowEntity, conditionEntity);
                if (isMatch)
                    matchWorkAreaProList.Add(workAreaPro);
            }
            return matchWorkAreaProList;
        }
        #endregion

        #region 返回匹配逻辑bool
        /// <summary>
        /// 返回匹配逻辑bool
        /// </summary>
        /// <param name="workflowEntity"></param>
        /// <param name="conditionEntity"></param>
        /// <returns></returns>
        private bool GetConditionValue(WorkflowEntity workflowEntity, 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(workflowEntity, conditionConfig);
                }
                else
                {
                    //符号的 直接匹配到返回bool
                    RelationConfig relationConfig = JsonConvert.DeserializeObject<RelationConfig>(condition.ToString());
                    bool relationValue = GetRelationValue(workflowEntity, relationConfig);
                    //是or,有一个true,直接返回true
                    if (conditionEntity.Logic == LogicSymBol.Or)
                    {
                        if (relationValue)
                            return true;
                    }
                    //添加bool到List
                    boolList.Add(relationValue);
                }
            }
            switch (conditionEntity.Logic)
            {
                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(WorkflowEntity workflowEntity, RelationConfig relationEntity)
        {
            string taskValue = string.Empty;
            PropertyInfo[] props = workflowEntity.GetType().GetProperties();
            foreach (var prop in props)
            {
                if (prop.Name.Equals(relationEntity.Name))
                {
                    taskValue = Util.ToString(prop.GetValue(workflowEntity, null));
                }
            }
            bool equal = taskValue.Equals(relationEntity.Value);
            switch (relationEntity.Symbol)
            {
                case RelationSymBol.Eq: return equal;
                case RelationSymBol.Ne: return !equal;
            }
            return false;
        }
        #endregion
    }
}