using System;
using System.Collections.Generic;
using System.Linq;
using SqlSugar;
using WMS.Entity.Context;
using WMS.Entity.SysEntity;

namespace WMS.BLL.Logic
{
    /// <summary>
    /// 分配库位
    /// </summary>
    public class AllotLocation
    {
        /// <summary>
        /// 获取合适的库位
        /// </summary>
        /// <param name="houseNo">仓库号</param>
        /// <param name="areaNo">区域号(子母托盘区)</param>
        /// <param name="roadwayNo">巷道号(可空)</param>
        /// <returns></returns>
        public SysStorageLocat GetSuiTableLocate(string houseNo, string areaNo, string roadwayNo = "")
        {
            try
            {
                var db = DataContext.Db;

                // 1.先判断仓库（应对多仓库）、再判断是否指定巷道号

                var house = db.Queryable<SysWareHouse>().First(m => m.WareHouseNo == houseNo);
                if (house == null)
                {
                    throw new Exception($"未查询到{houseNo}仓库信息");
                }

                //数据字典(获取字典中仓库类型)
                var dic = db.Queryable<SysDictionary>().First(m => m.Id.ToString() == house.Type);
                switch (dic.DictName)
                {
                    //是否指定巷道
                    case "立体库" when !string.IsNullOrWhiteSpace(roadwayNo):
                        {
                            var roadwayList = new List<SysStorageRoadway>();
                            var roadway = db.Queryable<SysStorageRoadway>().First(m => m.RoadwayNo == roadwayNo);
                            if (roadway == null)
                            {
                                throw new Exception($"未查询到{roadwayNo}巷道信息");
                            }
                            if (roadway.Status == "1")
                            {
                                throw new Exception($"{roadwayNo}巷道已停用");
                            }
                            roadwayList.Add(roadway);
                            var locate = GetLocateByRoadways(roadwayList, areaNo);
                            if (locate == null)
                            {
                                throw new Exception($"{roadwayNo}巷道没有合适的空储位");
                            }
                            return locate;
                        }
                    //立体库没有指定巷道（循环巷道根据优先级分配）
                    case "立体库" when string.IsNullOrWhiteSpace(roadwayNo):
                        {
                            var roadwayList = db.Queryable<SysStorageRoadway>().Where(m => m.WareHouseNo == houseNo && m.Status == "0").OrderBy(m => new { m.Priority, m.RoadwayNo }).ToList();

                            var locate = GetLocateByRoadways(roadwayList, areaNo);
                            if (locate == null)
                            {
                                throw new Exception($"{houseNo}仓库已启用的巷道中没有合适的空储位");
                            }
                            return locate;
                        }
                    //没有仓库类型
                    default:
                        throw new Exception($"未查询到{houseNo}仓库类型信息，无法为其分配储位");
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 获取合适空储位信息（根据巷道集合判断）
        /// </summary>
        /// <param name="roadways">巷道集合</param>
        /// <param name="areaNo">区域号(子母托盘区)</param>
        /// <returns></returns>
        private SysStorageLocat GetLocateByRoadways(List<SysStorageRoadway> roadways, string areaNo)
        {
            try
            {
                var db = DataContext.Db;
                #region 入库分配规则

                var funSet = db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "储位分配上下" && m.IsEnable == "NO");
                var funSet2 = db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "储位分配左右" && m.IsEnable == "NO");
                var funSet3 = db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "储位跳巷分配" && m.IsEnable == "NO");

                var topOrBom = 1; // 储位分配上下 0 上 1 下
                var leftOrRight = 0; // 储位分配上下 0 左 1 右
                var laneAllot = 0; //储位跳巷分配 0:跳着分配(一个一个分配)1:巷道按照优先级分配，同优先级顺序分配(一个巷道满了再分配下一个的巷道储位)
                if (funSet != null)
                {
                    switch (funSet.SetValue)
                    {
                        case "Top":
                            topOrBom = 0;//立库储位分配由上往下分配
                            break;
                        case "Bottom":
                            topOrBom = 1;//立库储位分配由下往上分配
                            break;
                        default:
                            topOrBom = 1;// 默认：由下往上
                            break;
                    }
                }
                if (funSet2 != null)
                {
                    switch (funSet2.SetValue)
                    {
                        case "Left":
                            leftOrRight = 0;//立库储位分配由上往下分配
                            break;
                        case "Right":
                            leftOrRight = 1;//立库储位分配由下往上分配
                            break;
                        default:
                            leftOrRight = 1;// 默认：由下往上
                            break;
                    }
                }
                if (funSet3 != null)
                {
                    switch (funSet3.SetValue)
                    {
                        case "JumpLaneAllot":
                            laneAllot = 0;//立库储位分配 巷道同优先级巷道跳着分配(一个一个分配)
                            break;
                        case "RankLaneAllot":
                            laneAllot = 1;//立库储位分配 巷道按照优先级分配，同优先级顺序分配(一个巷道满了再分配下一个的巷道储位)
                            break;
                        default:
                            laneAllot = 1;// 默认 跳着分配
                            break;
                    }
                }
                #endregion

                #region MyRegion

                SysStorageLocat locate = null; // 储位信息
                List<SysRoadwayUseLog> log = null; //巷道最后一次使用记录

                if (laneAllot == 0)//跳巷道平均分配
                {
                    //如果同级巷道有多条则查上次位置日志
                    if (roadways.Count > 1)
                    {
                        log = db.Queryable<SysRoadwayUseLog>().OrderByDescending(l => l.Id).ToList();
                    }
                    //取各巷道所有排第一个合适位
                    foreach (var l in roadways)
                    {
                        //如果上次是当前巷道则跳出
                        if (log != null && l.RoadwayNo == log[0].RoadwayNo)
                        {
                            continue;
                        }
                        //如果上上次是当前巷道则跳出
                        if (log != null && l.RoadwayNo == log[1].RoadwayNo)
                        {
                            continue;
                        }
                        //取当前巷最优位置
                        locate = GetLocateByRoadway(l.RoadwayNo, topOrBom, leftOrRight, areaNo);
                        //当前巷有位置则退出
                        if (locate != null)
                        {
                            break;
                        }
                    }
                    //如果跳巷道并且未找到合适空储位,则跳到最后一次使用的巷道查询
                    if (locate == null)
                    {
                        if (log != null)
                        {
                            locate = GetLocateByRoadway(log[0].RoadwayNo, topOrBom, leftOrRight, areaNo);
                        }
                    }
                }
                else//按照巷道优先级分配
                {
                    foreach (var item in roadways)
                    {
                        locate = GetLocateByRoadway(item.RoadwayNo, topOrBom, leftOrRight, areaNo);
                    }
                }

                #endregion

                return locate;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 取当前巷最优位置
        /// </summary>
        /// <param name="roadwayNo">巷道号</param>
        /// <param name="topOrBom">储位分配上下 0 上 1 下</param>
        /// <param name="leftOrRight">储位分配上下 0 左 1 右</param>
        /// <param name="areaNo">区域号(子母托盘区)</param>
        /// <returns></returns>
        private SysStorageLocat GetLocateByRoadway(string roadwayNo, int topOrBom, int leftOrRight, string areaNo)
        {
            var db = DataContext.Db;
            var str = "''";
            //查询该巷道并且标志为正常的的储位
            do
            {
                var sql = $@"select * from SysStorageLocat where IsDel = 0 and Flag = 0 and [Status] = 0 and RoadwayNo = '{roadwayNo}' and LocatNo not in({str}) ";
                sql += !string.IsNullOrWhiteSpace(areaNo) ? $"and AreaNo = '{areaNo}' " : "";
                sql += "order by ";
                sql += "Row , Depth desc, ";
                sql += topOrBom == 0 ? "Layer desc, " : "Layer, ";
                sql += leftOrRight == 0 ? "[Column]; " : "[Column] desc; ";


                var locateList = db.Ado.SqlQuery<SysStorageLocat>(sql);
                var data = locateList.FirstOrDefault();
                if (data != null)
                {
                    var isOk = LocateIsOk(data);
                    if (isOk)
                    {
                        return data;
                    }
                    else
                    {
                        if (str.Length > 0)
                        {
                            str += ",";
                        }
                        str += $"'{data.LocatNo}'";
                    }
                }
                else
                {
                    return null;
                }
            } while (true);

        }


        public bool LocateIsOk(SysStorageLocat model)
        {
            var db = DataContext.Db;
            if (model.Depth == "01")
            {
                //获取深度为2的储位信息
                var locate = db.Queryable<SysStorageLocat>().First(m =>
                    m.IsDel == "0" && m.LocateGroup == model.LocateGroup && m.Depth == "02");

                //里面储位必须是有物品且必须是正常的
                if (locate.Status == "1" && locate.Flag == "0")
                {
                    return true;
                }
                else
                {
                    return false;
                }

            }
            else
            {
                //获取深度为1的储位信息
                var locate = db.Queryable<SysStorageLocat>().First(m =>
                    m.IsDel == "0" && m.LocateGroup == model.LocateGroup && m.Depth == "01");
                if (locate == null)
                {
                    return true;
                }
                else
                {
                    //前面储位状态为空且不能是损坏状态的
                    if (locate.Status == "0" && locate.Flag != "2")
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
        }


    }
}