using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.APIEnum;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Core.Enums;
using WIDESEAWCS_Core.Helper;
<<<<<<< HEAD
=======
using WIDESEAWCS_DTO.TaskInfo;
>>>>>>> main
using WIDESEAWCS_IBasicInfoRepository;
using WIDESEAWCS_IPackInfoRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_TaskInfoService
{
    public class PackaxisTaskService : ServiceBase<Dt_PackaxisTask, IPackaxisTaskRepository>, IPackaxisTaskService
    {
        private readonly IPackinfoRepository _packinfoRepository;
        private readonly IStationPackInfoRepository _stationPackInfoRepository;
        private readonly IStationPackDetailRepository _stationPackDetailRepository;
        private readonly IPackaxisRepository _packaxisRepository;
        private readonly IStationMangerRepository _stationMangerRepository;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        public PackaxisTaskService(IPackaxisTaskRepository BaseDal,IPackinfoRepository packinfoRepository, IStationPackInfoRepository stationPackInfoRepository, IStationPackDetailRepository stationPackDetailRepository, IPackaxisRepository packaxisRepository, IStationMangerRepository stationMangerRepository, IUnitOfWorkManage unitOfWorkManage) : base(BaseDal)
        {
            _packinfoRepository = packinfoRepository;
            _stationPackInfoRepository = stationPackInfoRepository;
            _stationPackDetailRepository = stationPackDetailRepository;
            _packaxisRepository = packaxisRepository;
            _stationMangerRepository = stationMangerRepository;
            _unitOfWorkManage = unitOfWorkManage;
        }
        /// <summary>
        /// 分配码垛任务
        /// </summary>
        /// <param name="barCode"></param>
        /// <param name="deviceCode"></param>
        /// <returns></returns>
        public WebResponseContent ReqPackTask(string barCode,string deviceCode)
        {
            WebResponseContent content= new WebResponseContent();
            try
            {
                Dt_Packinfo packinfo = _packinfoRepository.QueryFirst(x=>x.BarCode==barCode && x.PackStatus==StationOccupiedEnum.None.ObjToInt());
                if (packinfo==null)
                {
                    return content.Error($"未找到条码{barCode}");
                }
                List<Dt_StationPackInfo> stationPackInfos = _stationPackInfoRepository.QueryData();
                Dt_StationPackInfo? stationPackInfo=stationPackInfos.FirstOrDefault(x=>x.PackType==packinfo.PackType && x.OrderNo==packinfo.OrderNo && x.AssignNum<x.PackNum);
                //如果订单相同、垛型一致并且分配数量少于码垛结托数量则分配到一起
                if (stationPackInfo!=null)
                {
                    Dt_PackaxisTask packaxisTask = new Dt_PackaxisTask()
                    {
                        DeviceCode=deviceCode,
                        SourceAddress= "2421",
                        BarCode=barCode,
                        CurrentAddress= "2421",
                        TargetAddress=stationPackInfo.StationCode,
                        NextAddress=stationPackInfo.LineCode,
                        TaskState =TaskStatusEnum.Line_Executing.ObjToInt(),
                        PackLength=packinfo.Length,
                        PackWidth=packinfo.Width,
                        PackHeight=packinfo.Height,
                        PackType=packinfo.PackType,
                        Dispatchertime=DateTime.Now,
                    };
                    stationPackInfo.AssignNum += 1;
                    stationPackInfo.ExecutingNum += 1;
                    packinfo.PackStatus = StationOccupiedEnum.Sure.ObjToInt();
                    _unitOfWorkManage.BeginTran();
                    //更新码垛执行工位
                    _stationPackInfoRepository.UpdateData(stationPackInfo);
                    //更新待码垛信息表
                    _packinfoRepository.UpdateData(packinfo);
                    //添加码垛任务
                    BaseDal.AddData(packaxisTask);
                    _unitOfWorkManage.CommitTran();
                    return content.OK(barCode, packaxisTask);
                }
                else//分配新工位
                {
                    //获取当前空盘准备的码垛工位
                    List<string> stations = _stationMangerRepository.QueryData(x => x.StationDeviceCode == "CLC_CP" && x.IsOccupied == StationOccupiedEnum.None.ObjToInt()).Select(x => x.StationCode).ToList();
                    //获取码垛配置表查询有配置的码垛工位
                    List<Dt_Packaxis> packaxes = _packaxisRepository.QueryData(x => x.PackType == packinfo.PackType);
                    if (packaxes.Count==0)
                    {
                        return content.Error("未找到码垛坐标配置");
                    }
                    List<string> packStations = packaxes.Select(x => x.StationCode).ToList();
                    Dt_StationPackInfo? packInfoAssign = stationPackInfos.Where(x => x.PackType == 0 && x.AssignNum == 0 && stations.Contains(x.StationCode) && packStations.Contains(x.StationCode)).OrderByDescending(x => x.StationCode).FirstOrDefault();
                    if (packInfoAssign == null)
                    {
                        return content.Error("未找到可分配垛位");
                    }
                    packInfoAssign.PackType = packinfo.PackType;
                    packInfoAssign.OrderNo = packinfo.OrderNo;
                    packInfoAssign.MakeCode = packinfo.MakeCode;
                    packInfoAssign.MaterielCode = packInfoAssign.MaterielCode;
                    packInfoAssign.PackNum = packaxes.FirstOrDefault(x=>x.StationCode== packInfoAssign.StationCode).PackNum;
                    Dt_PackaxisTask packaxisTask = new Dt_PackaxisTask()
                    {
                        DeviceCode = deviceCode,
                        SourceAddress = "2421",
                        BarCode = barCode,
                        CurrentAddress = "2421",
                        TargetAddress = packInfoAssign.StationCode,
                        NextAddress = packInfoAssign.LineCode,
                        TaskState = TaskStatusEnum.Line_Executing.ObjToInt(),
                        PackLength = packinfo.Length,
                        PackWidth = packinfo.Width,
                        PackHeight = packinfo.Height,
                        PackType = packinfo.PackType,
                        Dispatchertime = DateTime.Now,
                    };
                    packInfoAssign.AssignNum += 1;
                    packInfoAssign.ExecutingNum += 1;
                    packinfo.PackStatus = StationOccupiedEnum.Sure.ObjToInt();
                    _unitOfWorkManage.BeginTran();
                    //更新码垛执行工位
                    _stationPackInfoRepository.UpdateData(packInfoAssign);
                    //更新待码垛信息表
                    _packinfoRepository.UpdateData(packinfo);
                    //添加码垛任务
                    BaseDal.AddData(packaxisTask);
                    _unitOfWorkManage.CommitTran();
                    return content.OK(barCode, packaxisTask);
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 码垛结托并上传码垛工位码垛明细数据
        /// </summary>
        /// <param name="stationCode"></param>
        /// <returns></returns>
        public WebResponseContent BoxingInBound(string stationCode)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_StationPackInfo stationPackInfo = _stationPackInfoRepository.QueryFirst(x => x.StationCode == stationCode);
                if (stationPackInfo.OverNum != stationPackInfo.AssignNum)
                {
                    throw new Exception($"分配数量{stationPackInfo.AssignNum}，完成数量{stationPackInfo.OverNum}数量不符");
                }
                List<Dt_StationPackDetail> stationPackDetails = _stationPackDetailRepository.QueryData(x => x.StationPackId == stationPackInfo.id);
                if (stationPackDetails.Count <= 0)
                {
                    throw new Exception($"{stationCode}未找到码垛明细");
                }
                List<string> barCodes = stationPackDetails.Select(x => x.BoxCode).ToList();
                List<Dt_Packinfo> packinfos = _packinfoRepository.QueryData(x => barCodes.Contains(x.BarCode)).ToList();
                stationPackInfo.PackType = 0;
                stationPackInfo.OrderNo = "";
                stationPackInfo.MakeCode = "";
                stationPackInfo.MaterielCode = "";
                stationPackInfo.PackNum = 0;
                stationPackInfo.OverNum = 0;
                stationPackInfo.AssignNum = 0;
                stationPackInfo.ExecutingNum = 0;
                _unitOfWorkManage.BeginTran();
                _stationPackInfoRepository.UpdateData(stationPackInfo);
                _stationPackDetailRepository.DeleteData(stationPackDetails);
                _packinfoRepository.DeleteAndMoveIntoHty(packinfos, App.User?.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                //同步到WMS
                string address = AppSettings.Get("WMSApiAddress");
                string response = HttpHelper.Post($"{address}/api/Task/BoxingInBound?stationCode=" + stationCode, barCodes.Serialize());
                WebResponseContent? responseContent = JsonConvert.DeserializeObject<WebResponseContent>(response) ?? throw new Exception($"未收到返回结果");
                if (!responseContent.Status)
                {
                    throw new Exception(responseContent.Message);
                }
                _unitOfWorkManage.CommitTran();
                content.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 码垛任务完成
        /// </summary>
        /// <param name="taskNum"></param>
        /// <param name="packaxisTask"></param>
        /// <returns></returns>
        public WebResponseContent TaskCompleted(int taskNum=0,Dt_PackaxisTask? packaxisTask=null)
        {
            try
            {
                
                Dt_PackaxisTask? packaxisTaskFinish = null;
                if (packaxisTask!=null)
                {
                    packaxisTaskFinish= packaxisTask;
                }
                else
                {
                    packaxisTaskFinish = BaseDal.QueryFirst(x => x.PackTaskNum == taskNum);
                    packaxisTaskFinish.TaskState = TaskStatusEnum.Finish.ObjToInt();
                }
                if (packaxisTaskFinish != null)
                {
                    Dt_StationPackInfo stationPackInfo = _stationPackInfoRepository.QueryFirst(x => x.StationCode == packaxisTaskFinish.TargetAddress);
                    stationPackInfo.ExecutingNum -= 1;
                    stationPackInfo.OverNum += 1;
                    Dt_StationPackDetail stationPackDetail = new Dt_StationPackDetail()
                    {
                        StationPackId = stationPackInfo.id,
                        BoxCode = packaxisTaskFinish.BarCode
                    };
                    _unitOfWorkManage.BeginTran();
                    _stationPackInfoRepository.UpdateData(stationPackInfo);
                    _stationPackDetailRepository.AddData(stationPackDetail);
                    BaseDal.DeleteAndMoveIntoHty(packaxisTaskFinish, App.User?.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _unitOfWorkManage.CommitTran();
                }
                else
                {
                    return WebResponseContent.Instance.Error("未找到任务");
                }
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
<<<<<<< HEAD
=======
        /// <summary>
        /// 删除码垛任务信息
        /// </summary>
        /// <param name="packTaskNum"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent PickaixsTaskDele(int PackTaskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {

                    Dt_PackaxisTask packaxisTask = BaseDal.QueryFirst(x => x.PackTaskNum == PackTaskNum);
                    if(packaxisTask == null)
                    {
                        return WebResponseContent.Instance.Error("未找到任务");
                    }
                    else 
                    {
                        Dt_Packinfo packinfo = _packinfoRepository.QueryFirst(x => x.BarCode == packaxisTask.BarCode);
                        packinfo.PackStatus = 0;
                        _packinfoRepository.UpdateData(packinfo);
                        BaseDal.DeleteAndMoveIntoHty(packaxisTask, App.User?.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工删除);
                      content.Status = true;
                    }
            }
            catch (Exception e)
            {
                return WebResponseContent.Instance.Error(e.Message);
            }
            return content;
        }


>>>>>>> main
    }
}