using System;
using System.Collections.Generic;
using System.Linq;
using Google.Protobuf;
using HH.WCS.Mobox3.RiDong.dto;
using HH.WCS.Mobox3.RiDong.models;
using HH.WCS.Mobox3.RiDong.util;

namespace HH.WCS.Mobox3.RiDong.generalMethod;

/// <summary>
/// 货位方法
/// </summary>
public static class LocationMethod
{
    /// <summary>
    /// 获取指定接驳位
    /// </summary>
    /// <param name="input">作业信息</param>
    /// <returns></returns>
    public static Location QueryLocation(OperationDto input)
    {
        var location = new Location();
        int purpose = 0;
        // 入库（根据终点判断）
        if (input.taskType == 1 || input.taskType == 3)
        {
            purpose = 3;

            // 获取当前终点货位
            location = AdoSqlMethod<Location>.QueryFirst(p => p.S_CODE == input.endLocation);
        }
        // 出库（根据起点判断）
        else if (input.taskType == 2 || input.taskType == 4 || input.taskType == 5 || input.taskType == 6 || input.taskType == 7)
        {
            purpose = 4;

            // 获取当前起点货位
            location = AdoSqlMethod<Location>.QueryFirst(p => p.S_CODE == input.startLocation);
        }

        if (location != null)
        {
            // 查询当前出、类型以及对应巷道的接驳位
            var jbwLocation = AdoSqlMethod<Location>
                .QueryFirst(p => p.N_PURPOSE == purpose && p.N_ROADWAY == location.N_ROADWAY);

            if (jbwLocation != null)
            {
                return jbwLocation;
            }
        }

        return null;
    }

    /// <summary>
    /// 获取立体库区货位信息
    /// </summary>
    /// <param name="containerType">容器类型</param>
    /// <returns></returns>
    public static Location QueryStereoscopicStorehouseLocation(string containerType)
    {
        Location location = new Location();
        
        // 排查出该托盘类型对应的循环数据
        var containerPrioritys = Settings.ContainerPrioritysList.First(p=>p.containerType == containerType);

        // 根据容器类型找不同的优先顺序的货位，因为每个托盘的长宽高是不一样的
        switch (containerType)
        {
            case "1":
            case "1a":
            case "2":
            case "2a":
            case "3":
            case "3a":
            case "4":
            case "5":
            case "6":
            case "7":
                location = QueryStereoscopicStorehouseLocation(1, containerPrioritys);
                break;
            case "8":
                location = QueryStereoscopicStorehouseLocation(11,containerPrioritys);
                break;
            case "7a":
                location = QueryStereoscopicStorehouseLocation(12,containerPrioritys);
                break;
            default:
                location = null;
                break;
        }
        return location;
    }

    /// <summary>
    /// 获取立体库区货位信息
    /// </summary>
    /// <param name="containerCode"></param>
    /// <returns></returns>
    public static Location QueryOutLocation(string containerCode)
    {
        var locCntrRel = AdoSqlMethod<LocCntrRel>.QueryFirst(p => p.S_CNTR_CODE == containerCode);

        if (locCntrRel != null)
        {
            var location = AdoSqlMethod<Location>.QueryFirst(p => p.S_CODE == locCntrRel.S_LOC_CODE);

            if (location != null)
            {
                return location;
            }
        }
        return null;
    }

    /// <summary>
    /// 根据优先顺序获取可用货位
    /// </summary>
    /// <param name="priority"></param>
    /// <param name="containerPrioritys"></param>
    /// <returns></returns>
    private static Location QueryStereoscopicStorehouseLocation(int priority, Settings.ContainerPrioritys containerPrioritys)
    {
        var sqlSugarClient = AdoSqlMethod<object>.QuerySqlSugarClient();

        if (priority == 11)
        {
            // 查询出所有该优先级的可用货位
            var locations = sqlSugarClient.Queryable<Location>()
                .Where(p => p.N_PRIORITY == priority && p.N_CURRENT_NUM == 0 && p.N_LOCK_STATE == 0 && p.N_PURPOSE == 1).ToList();
            
            // 优先查询今日份任务中未完成的（等待，执行中）
            var notQueryList = AdoSqlMethod<Operation>.QueryList(p=>p.N_B_STATE < 2 && p.T_CREATE.Date == DateTime.Today);

            if (notQueryList.Count > 0)
            {
                var groupBy = notQueryList.GroupBy(p=>p.N_ROADWAY);

                foreach (var item in groupBy)
                {
                    if (item.Key == 1 || item.Key == 2 || item.Key == 3 ||
                        item.Key == 4)
                    {
                        locations = locations.Where(p=>p.N_ROADWAY != item.Key).ToList();
                    }
                    else if (item.Key == 5 && item.ToList().Count >= 3)
                    {
                        locations = locations.Where(p=>p.N_ROADWAY != item.Key).ToList();
                    }
                }
            }
            
            // 存在该优先级的可用货位
            if (locations.Count > 0)
            {
                // 一次五条任务均分巷道
                // return SelectOptimalLocation(locations);

                // 3组均分
                return SelectOptimalLocationTwo(locations, priority);

                // 5组均分
                // return SelectOptimaLocationThree(locations, priority);

                // 随机分配
                // return SelectOptimaLocationRandom(locations, priority);
            }
        }
        else if(priority == 12)
        {
            // 查询出所有该优先级的可用货位
            var locations = sqlSugarClient.Queryable<Location>()
                .Where(p => p.N_PRIORITY == priority && p.N_CURRENT_NUM == 0 && p.N_LOCK_STATE == 0 && p.N_PURPOSE == 1).ToList();
                
            // 存在该优先级的可用货位
            if (locations.Count > 0)
            {
                // 一次五条任务均分巷道
                // return SelectOptimalLocation(i);

                // 3组均分
                return SelectOptimalLocationTwo(locations, priority);

                // 5组均分
                // return SelectOptimaLocationThree(locations, i);

                // 随机分配
                // return SelectOptimaLocationRandom(locations, i);
            }
        }
        else
        {
            foreach (var i in containerPrioritys.priority)
            {
                // 查询出所有该优先级的可用货位
                var locations = sqlSugarClient.Queryable<Location>()
                    .Where(p => p.N_PRIORITY == i && p.N_CURRENT_NUM == 0 && p.N_LOCK_STATE == 0 && p.N_PURPOSE == 1).ToList();
                
                // 优先查询今日份任务中未完成的（等待，执行中）
                var notQueryList = AdoSqlMethod<Operation>.QueryList(p=>p.N_B_STATE < 2 && p.T_CREATE.Date == DateTime.Today);

                if (notQueryList.Count > 0)
                {
                    var groupBy = notQueryList.GroupBy(p=>p.N_ROADWAY);

                    foreach (var item in groupBy)
                    {
                        if (item.Key == 1 || item.Key == 2 || item.Key == 3 ||
                            item.Key == 4)
                        {
                            locations = locations.Where(p=>p.N_ROADWAY != item.Key).ToList();
                        }
                        else if (item.Key == 5 && item.ToList().Count >= 3)
                        {
                            locations = locations.Where(p=>p.N_ROADWAY != item.Key).ToList();
                        }
                    }
                }
                
                
                // 存在该优先级的可用货位
                if (locations.Count > 0)
                {
                    // 一次五条任务均分巷道
                    // return SelectOptimalLocation(i);

                    // 3组均分
                    return SelectOptimalLocationTwo(locations, i);

                    // 5组均分
                    // return SelectOptimaLocationThree(locations, i);

                    // 随机分配
                    // return SelectOptimaLocationRandom(locations, i);
                }
            }
        }
        
        return null;
    }

    /// <summary>
    /// 根据优先顺序获取可用货位（一次五条任务均分巷道）
    /// </summary>
    /// <param name="locations"></param>
    /// <returns></returns>
    public static Location SelectOptimalLocation(IEnumerable<Location> locations)
    {
        // 将该优先级的所有货位进行分组(根据巷道)
        var list = locations.OrderBy(p => p.N_ROADWAY).GroupBy(p => p.N_ROADWAY).ToList();

        foreach (var item in list)
        {
            var rowList = AdoSqlMethod<Location>.QueryCount(r => r.N_ROADWAY == item.Key && r.N_LOCK_STATE != 0);

            // 说明没有任务，此时可以随机一个给一个货位数据
            if (rowList == 0)
            {
                return item.ToList().OrderBy(p => p.N_LAYER).ThenBy(p => p.N_COL).First();
            }
        }

        return null;
    }

    // /// <summary>
    // /// 货位分配逻辑（伪均分）
    // /// </summary>
    // /// <param name="locations">货位数据集合</param>
    // /// <param name="priority">货位数据集合</param>
    // /// <returns></returns>
    // private static Location SelectOptimalLocationTwo(IEnumerable<Location> locations, int priority)
    // {
    //     // 对数据进行分组(1组、2组、3组)，这里是所有符合条件的货位数据
    //     var groups = locations.GroupBy(p => p.S_GROUP).ToList();
    //     
    //     // 查询最新的任务，判断该任务的分组，（过滤掉对应组的排数据）
    //     var operations = AdoSqlMethod<Operation>.QueryFirstByDecs(p=>p.T_CREATE);
    //     
    //     // 符合条件的货位集合
    //     var locationDtos = new List<LocationDto>();
    //     
    //     // 循环groups
    //     foreach (var grouping in groups)
    //     {
    //         var locationDto = new LocationDto();
    //         locationDto.Group = grouping.Key;
    //         locationDto.Eligibility = grouping.Count();
    //         locationDto.Locklocation = AdoSqlMethod<Location>.QueryCount(p =>
    //             p.N_PURPOSE == 1 && p.S_GROUP == grouping.Key && p.N_PRIORITY == priority &&
    //             (p.N_CURRENT_NUM == 1 || p.N_LOCK_STATE == 1));
    //         
    //         int group = 0;
    //         
    //         if(grouping.Key == "1组")
    //             group = 1;
    //         if(grouping.Key == "2组")
    //             group = 2;
    //         if(grouping.Key == "3组")
    //             group = 3;
    //
    //         // 有可用货位，同时上面已经出现过巷道的任务了
    //         if (operations.Count(p => p.S_EXT_ATTR2 == group) > 0)
    //         {
    //             // 满货位数量+2000（让该分组货位变成最大值）
    //             locationDto.Locklocation += 2000;
    //         }
    //         
    //         locationDtos.Add(locationDto);
    //     }
    //     
    //     // 查找locationDtos中满货位数量最少的分组
    //     var locationgroup = locationDtos.OrderBy(p=>p.Locklocation).First();
    //     
    //     // 判断该对象是哪个分组
    //     if (locationgroup.Group == "1组")
    //     {
    //         // 获取1组中的数据
    //         var locations1 = groups.First(p=>p.Key == "1组").ToList();
    //         
    //         // 根据巷道分组
    //         var roadwaylist = locations1.GroupBy(p=>p.N_ROADWAY).ToList();
    //
    //         // 长度大于2，说明1和2巷道都有数据
    //         if (roadwaylist.Count > 2)
    //         {
    //             // 查询1和2巷道里满货位最少的数据
    //             int num1 = AdoSqlMethod<Location>.QueryCount(p =>
    //                 p.N_PURPOSE == 1 && p.N_ROADWAY == 1 && p.N_PRIORITY == priority &&
    //                 (p.N_CURRENT_NUM == 1 || p.N_LOCK_STATE == 1));
    //         
    //             // 查询1和2巷道里满货位最少的数据
    //             int num2 = AdoSqlMethod<Location>.QueryCount(p =>
    //                 p.N_PURPOSE == 1 && p.N_ROADWAY == 2 && p.N_PRIORITY == priority &&
    //                 (p.N_CURRENT_NUM == 1 || p.N_LOCK_STATE == 1));
    //             
    //             // 获取最少的
    //             var min = Math.Min(num1, num2);
    //
    //             // 如果最少数量和巷道2是一致的，则返回2巷道里的货位
    //             if (min == num2)
    //             {
    //                 return roadwaylist.First(p=>p.Key == 2).OrderBy(p => p.N_LAYER)
    //                     .ThenBy(p => p.N_COL)
    //                     .First();
    //             }
    //             if (min == num1)
    //             {
    //                 return roadwaylist.First(p=>p.Key == 1).OrderBy(p => p.N_LAYER)
    //                     .ThenBy(p => p.N_COL)
    //                     .First();
    //             }
    //         }
    //     }
    //     // 判断该对象是哪个分组
    //     if (locationgroup.Group == "2组")
    //     {
    //         // 获取1组中的数据
    //         var locations1 = groups.First(p=>p.Key == "2组").ToList();
    //         
    //         // 根据巷道分组
    //         var roadwaylist = locations1.GroupBy(p=>p.N_ROADWAY).ToList();
    //
    //         // 长度大于2，说明1和2巷道都有数据
    //         if (roadwaylist.Count > 2)
    //         {
    //             // 查询1和2巷道里满货位最少的数据
    //             int num1 = AdoSqlMethod<Location>.QueryCount(p =>
    //                 p.N_PURPOSE == 1 && p.N_ROADWAY == 3 && p.N_PRIORITY == priority &&
    //                 (p.N_CURRENT_NUM == 1 || p.N_LOCK_STATE == 1));
    //         
    //             // 查询1和2巷道里满货位最少的数据
    //             int num2 = AdoSqlMethod<Location>.QueryCount(p =>
    //                 p.N_PURPOSE == 1 && p.N_ROADWAY == 4 && p.N_PRIORITY == priority &&
    //                 (p.N_CURRENT_NUM == 1 || p.N_LOCK_STATE == 1));
    //             
    //             // 获取最少的
    //             var min = Math.Min(num1, num2);
    //
    //             // 如果最少数量和巷道2是一致的，则返回2巷道里的货位
    //             if (min == num2)
    //             {
    //                 return roadwaylist.First(p=>p.Key == 4).OrderBy(p => p.N_LAYER)
    //                     .ThenBy(p => p.N_COL)
    //                     .First();
    //             }
    //             if (min == num1)
    //             {
    //                 return roadwaylist.First(p=>p.Key == 3).OrderBy(p => p.N_LAYER)
    //                     .ThenBy(p => p.N_COL)
    //                     .First();
    //             }
    //         }
    //     }
    //     // 判断该对象是哪个分组
    //     if (locationgroup.Group == "3组")
    //     {
    //         // 获取3组中的数据
    //         var locations1 = groups.First(p=>p.Key == "3组").ToList();
    //      
    //         return locations1.OrderBy(p => p.N_LAYER)
    //             .ThenBy(p => p.N_COL)
    //             .First();
    //     }
    //     
    //     return null;
    // }

    #region 货位分配（根据匹配的货位进行均分循环）

    /// <summary>
    /// 货位分配逻辑（伪均分）
    /// </summary>
    /// <param name="locations">货位数据集合</param>
    /// <param name="priority">货位数据集合</param>
    /// <returns></returns>
    private static Location SelectOptimalLocationTwo(IEnumerable<Location> locations, int priority)
    {
        // 对数据进行分组(1组、2组、3组)，这里是所有符合条件的货位数据
        var groups = locations.GroupBy(p => p.S_GROUP).ToList();
        
        // 查询最新的任务，判断该任务的分组，（过滤掉对应组的排数据）
        var operations = AdoSqlMethod<Operation>.QueryFirstByDecs(p => p.T_CREATE);

        // 符合条件的货位集合
        var locationDtos = GetLocationDtos(groups, operations, priority);

        // 查找locationDtos中满货位数量最少的分组
        var locationGroup = locationDtos.OrderBy(p => p.Locklocation).First();

        return GetOptimalLocation(locationGroup, groups, priority);
    }

    /// <summary>
    /// 对已经产生了任务的前两个分组的满货位进行数据操作
    /// </summary>
    /// <param name="groups"></param>
    /// <param name="operations"></param>
    /// <param name="priority"></param>
    /// <returns></returns>
    private static List<LocationDto> GetLocationDtos(List<IGrouping<string, Location>> groups, List<Operation> operations, int priority)
    {
        var locationDtos = new List<LocationDto>();
        
        foreach (var grouping in groups)
        {
            var locationDto = new LocationDto
            {
                Group = grouping.Key,
                Eligibility = grouping.Count(),
                Locklocation = AdoSqlMethod<Location>.QueryCount(p =>
                    p.N_PURPOSE == 1 && p.S_GROUP == grouping.Key && p.N_PRIORITY == priority &&
                    (p.N_CURRENT_NUM == 1 || p.N_LOCK_STATE == 1))
            };

            int groupNumber = GetGroupNumber(grouping.Key);

            // 有可用货位，同时上面已经出现过巷道的任务了
            if (operations.Count(p => p.S_EXT_ATTR2 == groupNumber) > 0)
            {
                // 满货位数量+2000（让该分组货位变成最大值）
                locationDto.Locklocation += 2000;
            }

            locationDtos.Add(locationDto);
        }
        return locationDtos;
    }

    /// <summary>
    /// 根据分组key转换成对应的数值类型
    /// </summary>
    /// <param name="groupKey"></param>
    /// <returns></returns>
    private static int GetGroupNumber(string groupKey)
    {
        switch (groupKey)
        {
            case "1组":
                return 1;
            case "2组":
                return 2;
            case "3组":
                return 3;
            default:
                return 0;
        }
    }

    /// <summary>
    /// 判断最终从那个巷道中获取货位
    /// </summary>
    /// <param name="locationGroup"></param>
    /// <param name="groups"></param>
    /// <param name="priority"></param>
    /// <returns></returns>
    private static Location GetOptimalLocation(LocationDto locationGroup, List<IGrouping<string, Location>> groups, int priority)
    {
        switch (locationGroup.Group)
        {
            case "1组":
                return GetOptimalLocationInGroup(groups, "1组", new[] { 1, 2 }, priority);
            case "2组":
                return GetOptimalLocationInGroup(groups, "2组", new[] { 3, 4 }, priority);
            case "3组":
                var locations3 = groups.First(p => p.Key == "3组").ToList();
                return locations3.OrderBy(p => p.N_LAYER)
                    .ThenBy(p => p.N_COL)
                    .First();
            default:
                return null;
        }
    }

    /// <summary>
    /// 获取货位
    /// </summary>
    /// <param name="groups"></param>
    /// <param name="groupKey"></param>
    /// <param name="roadways"></param>
    /// <param name="priority"></param>
    /// <returns></returns>
    private static Location GetOptimalLocationInGroup(List<IGrouping<string, Location>> groups, string groupKey, int[] roadways, int priority)
    {
        var locationsInGroup = groups.First(p => p.Key == groupKey).ToList();
        var roadwayList = locationsInGroup.GroupBy(p => p.N_ROADWAY).ToList();

        // 长度大于2，说明1和2巷道都有数据
        if (roadwayList.Count == 2)
        {
            int[] numArray = new int[roadways.Length];
            
            for (int i = 0; i < roadways.Length; i++)
            {
                int group = roadways[i];
                
                numArray[i] = AdoSqlMethod<Location>.QueryCount(p =>
                    p.N_PURPOSE == 1 && p.N_ROADWAY == group && p.N_PRIORITY == priority &&
                    (p.N_CURRENT_NUM == 1 || p.N_LOCK_STATE == 1));
            }

            int minIndex = Array.IndexOf(numArray, numArray.Min());
            int minRoadway = roadways[minIndex];

            return roadwayList.First(p => p.Key == minRoadway).ToList().OrderBy(p => p.N_LAYER)
                .ThenBy(p => p.N_COL)
                .First();
        }
        
        if(roadwayList.Count == 1)
        {
            var locations = roadwayList.First().ToList();
            
            return locations.OrderBy(p => p.N_LAYER)
                .ThenBy(p => p.N_COL)
                .First();
        }

        return null;
    }

    #endregion
    
    
    /// <summary>
    /// 货位均分（平均分配）
    /// </summary>
    /// <param name="locations"></param>
    /// <param name="priority"></param>
    /// <returns></returns>
    private static Location SelectOptimaLocationThree(IEnumerable<Location> locations, int priority)
    {
        // 将该优先级的所有货位进行分组(根据巷道)
        var list = locations.GroupBy(p => p.N_ROADWAY).ToList();

        // 初始化最小键和最小值
        int minKey = 0;
        double minValue = 9999;

        // 查下每个巷道中的满货位的数量
        foreach (var item in list)
        {
            var queryCount = AdoSqlMethod<Location>.QueryCount(p =>
                p.N_PURPOSE == 1 && p.N_ROADWAY == item.Key && p.N_PRIORITY == priority &&
                (p.N_CURRENT_NUM == 1 || p.N_LOCK_STATE == 1));

            if (queryCount < minValue)
            {
                minValue = queryCount;
                // 获取每个巷道中的存储位，数量为1，以及有入库锁的数量
                minKey = item.Key;
            }
        }

        return list[minKey].ToList().OrderBy(p => p.N_LAYER).ThenBy(p => p.N_COL).First();
    }

    /// <summary>
    /// 货位分配（随机分配）
    /// </summary>
    /// <param name="locations"></param>
    /// <param name="priority"></param>
    /// <returns></returns>
    private static Location SelectOptimaLocationRandom(IEnumerable<Location> locations, int priority)
    {
        var list = locations.ToList();

        // 创建随机数生成器
        Random random = new Random();

        // 生成随机索引
        int randomIndex = random.Next(list.Count);

        // 获取随机元素
        return list[randomIndex];
    }
}