using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.CommonEnum;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.MaterielEnum;
using WIDESEA_Common.OtherEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.Task;
using WIDESEA_Model.Models;

namespace WIDESEA_TaskInfoService
{
    public partial class TaskService
    {
        /// <summary>
        /// 判断是否需要移库
        /// </summary>
        /// <param name="taskNum"></param>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        //public WebResponseContent IsRelocation(int taskNum, string locationCode)
        //{
        //    try
        //    {
        //        Dt_LocationInfo locationInfo = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == locationCode);
        //        if (locationInfo == null)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到对应的货位信息");
        //        }

        //        Dt_Task task = Repository.QueryFirst(x => x.TaskNum == taskNum);
        //        if (task == null)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到任务信息");
        //        }

        //        List<Dt_LocationInfo> littleDepthLocations = _basicService.LocationInfoService.GetGroupLocations(locationInfo);

        //        Dt_LocationInfo? needRelocationItem = littleDepthLocations.Where(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.LocationStatus != LocationStatusEnum.FreeLock.ObjToInt() && x.Depth < locationInfo.Depth).OrderBy(x => x.Depth).FirstOrDefault();

        //        if (needRelocationItem == null)
        //        {
        //            return WebResponseContent.Instance.OK(data: _mapper.Map<WMSTaskDTO>(task));
        //        }
        //        else
        //        {
        //            Dt_StockInfo stockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.LocationCode == needRelocationItem.LocationCode);
        //            if (stockInfo == null)
        //            {
        //                return WebResponseContent.Instance.Error($"未找到对应货位的库存信息");
        //            }

        //            Dt_Task taskTemp = Repository.QueryFirst(x => x.PalletCode == stockInfo.PalletCode);
        //            if (taskTemp != null)
        //            {
        //                return WebResponseContent.Instance.OK(data: _mapper.Map<WMSTaskDTO>(taskTemp));
        //            }

        //            int heightType = 0;
        //            if(needRelocationItem.Layer == 5)
        //            {
        //                heightType = 3;
        //            }
        //            else if(needRelocationItem.Layer == 4)
        //            {
        //                heightType = 2;
        //            }
        //            else if(needRelocationItem.Layer <= 3 && needRelocationItem.Layer >= 1)
        //            {
        //                heightType = 1;
        //            }

        //            Dt_LocationInfo? newLocation = _basicService.LocationInfoService.AssignLocation(needRelocationItem.RoadwayNo, task.PalletType, task.WarehouseId, needRelocationItem.LocationCode);
        //            if (newLocation != null)
        //            {
        //                Dt_Task newTask = new Dt_Task()
        //                {
        //                    Roadway = task.Roadway,
        //                    WarehouseId = task.WarehouseId,
        //                    CurrentAddress = locationCode,
        //                    Grade = 99,
        //                    NextAddress = newLocation.LocationCode,
        //                    OrderNo = "",
        //                    PalletCode = stockInfo.PalletCode,
        //                    PalletType = stockInfo.PalletType,
        //                    SourceAddress = needRelocationItem.LocationCode,
        //                    TargetAddress = newLocation.LocationCode,
        //                    TaskNum = Repository.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
        //                    TaskStatus = 0,
        //                    TaskType = TaskTypeEnum.Relocation.ObjToInt()
        //                };

        //                _unitOfWorkManage.BeginTran();
        //                Repository.AddData(newTask);
        //                {
        //                    LocationStatusEnum lastStatus = (LocationStatusEnum)newLocation.LocationStatus;
        //                    _basicService.LocationInfoService.UpdateLocationStatus(newLocation, task.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
        //                    _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(newLocation, lastStatus, LocationStatusEnum.Lock, LocationChangeType.RelocationAssignLocation, taskNum: newTask.TaskNum);
        //                }
        //                {
        //                    LocationStatusEnum lastStatus = (LocationStatusEnum)needRelocationItem.LocationStatus;
        //                    _basicService.LocationInfoService.UpdateLocationStatus(needRelocationItem, task.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
        //                    _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(needRelocationItem, lastStatus, LocationStatusEnum.Lock, LocationChangeType.RelocationAssignLocation, taskNum: newTask.TaskNum);
        //                }
        //                stockInfo.StockStatus = StockStatusEmun.移库锁定.ObjToInt();
        //                _stockRepository.StockInfoRepository.UpdateData(stockInfo);

        //                _unitOfWorkManage.CommitTran();

        //                return WebResponseContent.Instance.OK(data: _mapper.Map<WMSTaskDTO>(newTask));
        //            }
        //            else
        //            {
        //                return WebResponseContent.Instance.Error($"未找到可分配货位,请查看该巷道【{task.Roadway}】是否还有空闲可使用货位");
        //            }
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        _unitOfWorkManage.RollbackTran();
        //        return WebResponseContent.Instance.Error(ex.Message);
        //    }
        //}
        public WebResponseContent RelocationTaskCompleted(Dt_Task task)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseId == task.WarehouseId);
                if (warehouse.WarehouseCode == WarehouseEnum.LLDCP.ToString() || warehouse.WarehouseCode == WarehouseEnum.LLDFL.ToString()) //成品/辅料完成
                {
                    Dt_ProStockInfo proStockInfo = _stockRepository.ProStockInfoRepository.Db.Queryable<Dt_ProStockInfo>().Where(x => x.PalletCode == task.PalletCode && x.LocationCode == task.SourceAddress).Includes(x => x.proStockInfoDetails).First();
                    if (proStockInfo == null)
                    {
                        return content.Error($"未找到对应的库存信息");
                    }
                    Dt_LocationInfo locationInfoStart = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.SourceAddress);
                    if (locationInfoStart == null)
                    {
                        return content.Error($"未找到对应的起点货位信息");
                    }
                    Dt_LocationInfo locationInfoEnd = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.TargetAddress);
                    if (locationInfoEnd == null)
                    {
                        return content.Error($"未找到对应的终点货位信息");
                    }
                    task.TaskStatus = TaskStatusEnum.Finish.ObjToInt();
                    _unitOfWorkManage.BeginTran();
                    proStockInfo.LocationCode = locationInfoEnd.LocationCode;
                    proStockInfo.StockStatus = StockStatusEmun.入库完成.ObjToInt();
                    _stockRepository.ProStockInfoRepository.UpdateData(proStockInfo);
                    _basicService.LocationInfoService.UpdateLocationStatus(locationInfoStart, proStockInfo.PalletType, LocationStatusEnum.Free, proStockInfo.WarehouseId);
                    _basicService.LocationInfoService.UpdateLocationStatus(locationInfoEnd, proStockInfo.PalletType, LocationStatusEnum.InStock, proStockInfo.WarehouseId);
                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId > 0 ? WIDESEA_Core.Enums.OperateTypeEnum.人工完成 : WIDESEA_Core.Enums.OperateTypeEnum.自动完成);
                    _unitOfWorkManage.CommitTran();
                }
                else
                {
                    Dt_StockInfo stockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == task.PalletCode && x.LocationCode == task.SourceAddress);
                    if (stockInfo == null)
                    {
                        return content.Error($"未找到对应的库存信息");
                    }

                    Dt_LocationInfo locationInfoStart = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.SourceAddress);
                    if (locationInfoStart == null)
                    {
                        return content.Error($"未找到对应的起点货位信息");
                    }

                    Dt_LocationInfo locationInfoEnd = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.TargetAddress);
                    if (locationInfoEnd == null)
                    {
                        return content.Error($"未找到对应的终点货位信息");
                    }
                    task.TaskStatus = TaskStatusEnum.Finish.ObjToInt();
                    _unitOfWorkManage.BeginTran();
                    stockInfo.LocationCode = locationInfoEnd.LocationCode;
                    stockInfo.StockStatus = StockStatusEmun.入库完成.ObjToInt();
                    _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                    _basicService.LocationInfoService.UpdateLocationStatus(locationInfoStart, stockInfo.PalletType, LocationStatusEnum.Free, stockInfo.WarehouseId);
                    _basicService.LocationInfoService.UpdateLocationStatus(locationInfoEnd, stockInfo.PalletType, LocationStatusEnum.InStock, stockInfo.WarehouseId);
                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId > 0 ? WIDESEA_Core.Enums.OperateTypeEnum.人工完成 : WIDESEA_Core.Enums.OperateTypeEnum.自动完成);
                    _unitOfWorkManage.CommitTran();
                }
                content.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 移库
        /// </summary>
        /// <param name="startAddress"></param>
        /// <param name="endAddress"></param>
        /// <param name="roadWay"></param>
        /// <returns></returns>
        public WebResponseContent IsRelocation(RelocationDTO relocation)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                //获取货位
                Dt_LocationInfo startLocationInfo = _basicRepository.LocationInfoRepository.QueryFirst(x => x.Row == relocation.StartRow && x.Columns == relocation.StartColumn && x.Layer == relocation.StartLayer && x.RoadwayNo == relocation.RoadWay);
                Dt_LocationInfo endLocationInfo = _basicRepository.LocationInfoRepository.QueryFirst(x => x.Row == relocation.TargetRow && x.Columns == relocation.TargetColumn && x.Layer == relocation.TargetLayer && x.RoadwayNo == relocation.RoadWay);
                
                //判断条件
                if (startLocationInfo != null && startLocationInfo.LocationStatus == LocationStatusEnum.InStock.ObjToInt() && startLocationInfo.EnableStatus == EnableStatusEnum.Normal.ObjToInt() && endLocationInfo != null && endLocationInfo.LocationStatus == LocationStatusEnum.Free.ObjToInt() && endLocationInfo.EnableStatus == EnableStatusEnum.Normal.ObjToInt())
                {
                    Dt_StockInfo stockInfo = _stockRepository.StockInfoRepository.QueryFirst(x => x.LocationCode == startLocationInfo.LocationCode);
                    Dt_ProStockInfo proStockInfo = _stockRepository.ProStockInfoRepository.QueryFirst(x => x.LocationCode == startLocationInfo.LocationCode);
                    bool IsCPRoadway = relocation.RoadWay.Contains("CP");
                    bool IsYLRoadway = relocation.RoadWay.Contains("YL");
                    if ((IsCPRoadway && proStockInfo==null) || (IsYLRoadway && stockInfo == null))
                    {
                        throw new Exception($"未找到{relocation.RoadWay}移库库存");
                    }
                    Dt_StockInfo stockInfoEnd = _stockRepository.StockInfoRepository.QueryFirst(x => x.LocationCode == endLocationInfo.LocationCode);
                    Dt_ProStockInfo proStockEnd = _stockRepository.ProStockInfoRepository.QueryFirst(x => x.LocationCode == endLocationInfo.LocationCode);
                    if ((IsCPRoadway && proStockEnd != null) || (IsYLRoadway && stockInfoEnd != null))
                    {
                        throw new Exception($"{relocation.RoadWay}目标库存已存在");
                    }
                    if (relocation.RoadWay.Contains("YLDual"))
                    {
                        if (startLocationInfo.LocationType != endLocationInfo.LocationType)
                        {
                            throw new Exception($"混合巷道{relocation.RoadWay}起始与目标货位类型不符,请查看货位状态");
                        }
                        if (stockInfo.PalletType != endLocationInfo.LocationType)
                        {
                            throw new Exception($"混合巷道{relocation.RoadWay}移库库存与目标货位类型不符,请查看货位状态");
                        }
                        if ((relocation.TargetLayer == 7 || relocation.TargetLayer == 8) && stockInfo.CheckThickness>700)
                        {
                            throw new Exception($"目标货位限高700,移库库存高度{stockInfo.CheckThickness}超出");
                        }

                        if (relocation.TargetColumn >= 7 && relocation.TargetLayer != 7 && relocation.TargetLayer != 8 && endLocationInfo.LocationType==LocationTypeEnum.MediumPallet.ObjToInt())
                        {
                            ////获取更改库位
                            Dt_LocationInfo? nearLocation1;
                            Dt_LocationInfo? nearLocation2;

                            nearLocation1 = _basicRepository.LocationInfoRepository.QueryFirst(x => x.LocationType == LocationTypeEnum.SmallPallet.ObjToInt() && x.LocationStatus == LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.Disable.ObjToInt() && x.Row == endLocationInfo.Row && x.Layer == endLocationInfo.Layer && x.Columns == endLocationInfo.Columns - 1);
                            nearLocation2 = _basicRepository.LocationInfoRepository.QueryFirst(x => x.LocationType == LocationTypeEnum.SmallPallet.ObjToInt() && x.LocationStatus == LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.Disable.ObjToInt() && x.Row == endLocationInfo.Row && x.Layer == endLocationInfo.Layer && x.Columns == endLocationInfo.Columns + 1);
                            if (nearLocation1 == null || nearLocation2 == null)
                            {
                                throw new Exception($"目标货位{endLocationInfo.LocationCode}为大货类型,两侧小货位存在占用或禁用状态,请查看货位状态");
                            }
                        }
                    }
                    else if (relocation.RoadWay.Contains("YL"))
                    {
                        if ((endLocationInfo.Columns < 56 && startLocationInfo.Columns>=56) && stockInfo.CheckThickness > 1300)
                        {
                            throw new Exception($"移库货位物料高度{stockInfo.CheckThickness}超出1300,目标货位存放规则超出");
                        }
                    }
                    //生成任务
                    Dt_Task newTask = new Dt_Task()
                    {
                        Roadway = relocation.RoadWay,
                        WarehouseId = IsCPRoadway ? proStockInfo.WarehouseId:stockInfo.WarehouseId,
                        CurrentAddress = startLocationInfo.LocationCode,
                        Grade = 99,
                        NextAddress = endLocationInfo.LocationCode,
                        OrderNo = "",
                        PalletCode = IsCPRoadway ? proStockInfo.PalletCode : stockInfo.PalletCode,
                        PalletType = IsCPRoadway ? proStockInfo.PalletType : stockInfo.PalletType,
                        SourceAddress = startLocationInfo.LocationCode,
                        TargetAddress = endLocationInfo.LocationCode,
                        TaskNum = Repository.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                        TaskStatus = TaskStatusEnum.SC_Execute.ObjToInt(),
                        TaskType = TaskTypeEnum.Relocation.ObjToInt()
                    };
                    
                    _unitOfWorkManage.BeginTran();
                    Repository.AddData(newTask);
                    if (!IsCPRoadway)
                    {
                        stockInfo.StockStatus = StockStatusEmun.移库锁定.ObjToInt();
                        _basicService.LocationInfoService.UpdateLocationStatus(startLocationInfo, stockInfo.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                        _basicService.LocationInfoService.UpdateLocationStatus(endLocationInfo, stockInfo.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                        _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                    }
                    else
                    {
                        proStockInfo.StockStatus = StockStatusEmun.移库锁定.ObjToInt();
                        _basicService.LocationInfoService.UpdateLocationStatus(startLocationInfo, proStockInfo.PalletType, LocationStatusEnum.Lock, proStockInfo.WarehouseId);
                        _basicService.LocationInfoService.UpdateLocationStatus(endLocationInfo, proStockInfo.PalletType, LocationStatusEnum.Lock, proStockInfo.WarehouseId);
                        _stockService.ProStockInfoService.Repository.UpdateData(proStockInfo);
                    }
                    _unitOfWorkManage.CommitTran();
                    PushTasksToWCS(new List<Dt_Task> { newTask });
                    content.OK("成功");
                }
                else
                {
                    content.Error("移库或目标货位不满足移库条件,请查看两货位状态");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 原料巷道间移库任务 todo:临时
        /// </summary>
        public WebResponseContent RelocationRoadWay(string roadWay, int Count)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                //获取对应库存
                List<Dt_StockInfo> stockInfos = _stockRepository.StockInfoRepository.QueryData(x =>  x.MaterielWide <2200 && x.StockStatus == StockStatusEmun.入库完成.ObjToInt()).OrderBy(x => x.CreateDate).Take(Count).ToList();

                //获取货位
                List<Dt_LocationInfo> locationInfos = _basicRepository.LocationInfoRepository.QueryData(x => stockInfos.Select(x => x.LocationCode).Contains(x.LocationCode));
                foreach (var item in stockInfos)
                {
                    Dt_LocationInfo? locationInfo = locationInfos.FirstOrDefault(x => x.LocationCode == item.LocationCode);
                    if (locationInfo != null && locationInfo.EnableStatus == EnableStatusEnum.Normal.ObjToInt() && locationInfo.LocationStatus == LocationStatusEnum.InStock.ObjToInt())
                    {
                        item.StockStatus = StockStatusEmun.出库锁定.ObjToInt();
                    }
                    else
                    {
                        return content.Error($"货位状态不正确");
                    }
                }
                
                List<Dt_Task> tasks = GetTasks(stockInfos, TaskTypeEnum.OutPick);
                if (tasks == null || tasks.Count <= 0)
                {
                    return content.Error($"生成任务失败");
                }
                tasks.ForEach(x =>
                {
                    x.TargetAddress = roadWay;
                });
                //判断是否有出库单信息
                _unitOfWorkManage.BeginTran();
                //更新库存状态
                _stockRepository.StockInfoRepository.UpdateData(stockInfos);
                //更新货位状态
                _basicRepository.LocationInfoRepository.UpdateLocationStatus(locationInfos, LocationStatusEnum.Lock);
                //加入货位变动记录
                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfos, LocationStatusEnum.Lock, LocationChangeType.OutboundAssignLocation, taskNums: tasks.Select(x => x.TaskNum).ToList());
                //新建任务
                BaseDal.AddData(tasks);
                _unitOfWorkManage.CommitTran();
                PushTasksToWCS(tasks);
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
    }
}