using AngleSharp.Dom;
using AngleSharp.Io;
using Mapster;
using Masuit.Tools;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WIDESEA_Cache;
using WIDESEA_Core.Const;
using WIDESEA_DTO.AGV;
using WIDESEA_DTO.WMS;
using WIDESEA_IServices;
using WIDESEA_IStorageSocketRepository;
using WIDESEA_IStorageSocketServices;
using WIDESEA_IStoragIntegrationServices;
using WIDESEA_Model.Models.AGV;
using WIDESEA_StorageSocketServices;
using WIDESEA_StorageTaskRepository;
using WIDESEAWCS_BasicInfoRepository;
using WIDESEAWCS_BasicInfoService;
using WIDESEAWCS_Model.Models;

namespace WIDESEA_StorageTaskServices;

public partial class Dt_TaskService : ServiceBase<Dt_Task, IDt_TaskRepository>, IDt_TaskService
{
    private readonly LogFactory LogFactory = new LogFactory();
    private readonly IUnitOfWorkManage _unitOfWorkManage;
    private readonly IStockInfoRepository _stockInfoRepository;
    private readonly IDt_StationManagerRepository _stationManagerRepository;
    private readonly IDt_StationManagerService _stationManagerService;
    private readonly IDt_Task_HtyRepository _task_HtyRepository;
    private readonly IMapper _mapper;
    private readonly ILocationInfoRepository _locationRepository;
    private readonly IDt_HandAutomaticRepository _handAutomaticRepository;

    public Dt_TaskService(IDt_TaskRepository BaseDal,
                                IUnitOfWorkManage unitOfWorkManage,
                                IStockInfoRepository stockInfoRepository,
                                IDt_Task_HtyRepository task_HtyRepository,
                                IMapper mapper,
                                ILocationInfoRepository locationRepository,
                                IStockInfoDetailRepository stockInfoDetailRepository,
                                IDt_StationManagerRepository stationManagerRepository,
                                IDt_HandAutomaticRepository handAutomaticRepository,
                                IDt_StationManagerService stationManagerService) : base(BaseDal)
    {
        _unitOfWorkManage = unitOfWorkManage;
        _stockInfoRepository = stockInfoRepository;
        _task_HtyRepository = task_HtyRepository;
        _mapper = mapper;
        _locationRepository = locationRepository;
        _stationManagerRepository = stationManagerRepository;
        _handAutomaticRepository = handAutomaticRepository;
        _stationManagerService = stationManagerService;
    }



    #region 外部接口方法
    public WebResponseContent InboundTask(TaskDTO taskDTO)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var HandAutomatic = _handAutomaticRepository.QueryFirst(x => true && x.HandAutomatic == "Automatic");
            if (HandAutomatic != null)
            {
                return content.Error("当前不是手动模式");
            }
            var station = _stationManagerRepository.QueryFirst(x => x.HostName == taskDTO.SourceAddress && x.stationType == 1);
            if (station == null)
            {
                return content.Error("未找到入库站台信息");
            }
            Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == taskDTO.PalletCode);
            if (task != null)
            {
                return content.Error("该托盘已存在任务");
            }
            var location = GetLocation();
            Dt_Task taskNew = new Dt_Task()
            {
                TaskNum = BaseDal.GetTaskNo().Result,
                PalletCode = taskDTO.PalletCode,
                Dispatchertime = DateTime.Now,
                Grade = 1,
                SeqNo = Convert.ToInt32(0),
                CommandID = Convert.ToInt32(0),
                SourceAddress = station.stationName,
                TargetAddress = location.LocationCode,
                CurrentAddress = station.stationName,
                NextAddress = location.LocationCode,
                TaskType = (int)TaskInboundTypeEnum.Inbound,
                TaskState = (int)TaskInStatusEnum.InNew,
                Roadway = "PDA",
            };
            task_call task_Call = new task_call()
            {
                d_task_type = "16" ,
                d_floor = "1",
                d_involed1 = taskNew.SourceAddress,
                d_involed2 = InsertHyphenEveryTwoChars(taskNew.TargetAddress),
                d_involed5 = taskNew.TaskNum.ToString(),
            };
            location.LocationStatus = (int)LocationEnum.Lock;
            _locationRepository.UpdateData(location);
            BaseDal.AddData(taskNew);
            SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            return content.OK();
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent SamplingInboundTask(TaskDTO taskDTO)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var HandAutomatic = _handAutomaticRepository.QueryFirst(x => true && x.HandAutomatic == "Automatic");
            if (HandAutomatic != null)
            {
                return content.Error("当前不是手动模式");
            }
            var station = _stationManagerRepository.QueryFirst(x => x.HostName == taskDTO.SourceAddress && x.stationType == 1);
            if (station == null)
            {
                return content.Error("未找到入库站台信息");
            }
            Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == taskDTO.PalletCode);
            if (task != null)
            {
                return content.Error("该托盘已存在任务");
            }
            var stock = _stockInfoRepository.QueryFirst(x => x.PalletCode == taskDTO.PalletCode);
            if (stock == null)
            {
                return content.Error("该托盘库存不存在");
            }
            var location = _locationRepository.QueryFirst(x => x.LocationCode == stock.LocationCode);
            
            Dt_Task taskNew = new Dt_Task()
            {
                TaskNum = BaseDal.GetTaskNo().Result,
                PalletCode = taskDTO.PalletCode,
                Dispatchertime = DateTime.Now,
                Grade = 1,
                SeqNo = Convert.ToInt32(0),
                CommandID = Convert.ToInt32(0),
                SourceAddress = station.stationName,
                TargetAddress = stock.LocationCode,
                CurrentAddress = station.stationName,
                NextAddress = stock.LocationCode,
                TaskType = (int)TaskInboundTypeEnum.InQuality,
                TaskState = (int)TaskInStatusEnum.InNew,
                Roadway = "PDA",
            };
            task_call task_Call = new task_call()
            {
                d_task_type = "16",
                d_floor = "1",
                d_involed1 = taskNew.SourceAddress,
                d_involed2 = InsertHyphenEveryTwoChars(taskNew.TargetAddress),
                d_involed5 = taskNew.TaskNum.ToString(),
            };
            location.LocationStatus = (int)LocationEnum.Lock;
            _locationRepository.UpdateData(location);
            BaseDal.AddData(taskNew);
            SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            return content.OK();
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    public WebResponseContent OutboundTask(TaskDTO taskDTO)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var HandAutomatic = _handAutomaticRepository.QueryFirst(x => true && x.HandAutomatic == "Automatic");
            if (HandAutomatic != null)
            {
                return content.Error("当前不是手动模式");
            }
            StationStatus stationOut = _stationManagerService.GetStationStatus("B001");
            if (stationOut == null)
            {
                return content.Error("获取出库站台信息失败，请重新出库");
            }
            Dt_StationManager station;
            if (stationOut.WorkstationO == "0")
            {
                station = _stationManagerRepository.QueryFirst(x => x.stationName == "B001::1" && x.stationType == 2);
            }
            else if (stationOut.WorkstationT == "0")
            {
                station = _stationManagerRepository.QueryFirst(x => x.stationName == "B001::2" && x.stationType == 2);
            }
            else
            {
                return content.Error("出库站台状态不是空闲，请确认再下发出库任务");
            }
            if (station == null)
            {
                return content.Error("未找到出库站台信息");
            }
            var stock = _stockInfoRepository.QueryFirst(x => x.LocationCode == taskDTO.SourceAddress);
            if (stock == null)
            {
                return content.Error("该托盘库存不存在");
            }
            Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == stock.PalletCode);
            if (task != null)
            {
                return content.Error("该托盘已存在任务");
            }
            
            var location = _locationRepository.QueryFirst(x => x.LocationCode == stock.LocationCode);
            if (location.LocationStatus != (int)LocationEnum.InStock)
            {
                return content.Error("该库位不是有货状态，请确认状态再下发任务！");
            }

            Dt_Task taskNew = new Dt_Task()
            {
                TaskNum = BaseDal.GetTaskNo().Result,
                PalletCode = taskDTO.PalletCode,
                Dispatchertime = DateTime.Now,
                Grade = 1,
                SeqNo = Convert.ToInt32(0),
                CommandID = Convert.ToInt32(0),
                SourceAddress = station.stationName,
                TargetAddress = stock.LocationCode,
                CurrentAddress = station.stationName,
                NextAddress = stock.LocationCode,
                TaskType = (int)TaskOutboundTypeEnum.Outbound,
                TaskState = (int)TaskOutStatusEnum.OutNew,
                Roadway = "PDA",
            };
            task_call task_Call = new task_call()
            {
                d_task_type = "32",
                d_floor = "1",
                d_involed1 = InsertHyphenEveryTwoChars(taskNew.SourceAddress),
                d_involed2 = taskNew.TargetAddress,
                d_involed5 = taskNew.TaskNum.ToString(),
            };
            location.LocationStatus = (int)LocationEnum.Lock;
            _locationRepository.UpdateData(location);
            BaseDal.AddData(taskNew);
            SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            return content.OK();
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    public WebResponseContent SamplingOutboundTask(TaskDTO taskDTO)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var HandAutomatic = _handAutomaticRepository.QueryFirst(x => true && x.HandAutomatic == "Automatic");
            if (HandAutomatic != null)
            {
                return content.Error("当前不是手动模式");
            }
            StationStatus stationOut = _stationManagerService.GetStationStatus("B002");
            if (stationOut == null)
            {
                return content.Error("获取出库站台信息失败，请重新出库");
            }
            Dt_StationManager station;
            if (stationOut.WorkstationO == "0")
            {
                station = _stationManagerRepository.QueryFirst(x => x.stationName == "B002::1" && x.stationType == 1);
            }
            else if (stationOut.WorkstationT == "0")
            {
                station = _stationManagerRepository.QueryFirst(x => x.stationName == "B002::2" && x.stationType == 1);
            }
            else
            {
                return content.Error("出库站台状态不是空闲，请确认再下发出库任务");
            }
            if (station == null)
            {
                return content.Error("未找到出库站台信息");
            }
            var stock = _stockInfoRepository.QueryFirst(x => x.LocationCode == taskDTO.SourceAddress);
            if (stock == null)
            {
                return content.Error("该库位库存不存在");
            }
            Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == stock.PalletCode);
            if (task != null)
            {
                return content.Error("该托盘已存在任务");
            }

            var location = _locationRepository.QueryFirst(x => x.LocationCode == stock.LocationCode);
            if (location.LocationStatus != (int)LocationEnum.InStock)
            {
                return content.Error("该库位不是有货状态，请确认状态再下发任务！");
            }

            Dt_Task taskNew = new Dt_Task()
            {
                TaskNum = BaseDal.GetTaskNo().Result,
                PalletCode = taskDTO.PalletCode,
                Dispatchertime = DateTime.Now,
                Grade = 1,
                SeqNo = Convert.ToInt32(0),
                CommandID = Convert.ToInt32(0),
                SourceAddress = station.stationName,
                TargetAddress = stock.LocationCode,
                CurrentAddress = station.stationName,
                NextAddress = stock.LocationCode,
                TaskType = (int)TaskOutboundTypeEnum.OutQuality,
                TaskState = (int)TaskOutStatusEnum.OutNew,
                Roadway = "PDA",
            };
            task_call task_Call = new task_call()
            {
                d_task_type = "32",
                d_floor = "1",
                d_involed1 = InsertHyphenEveryTwoChars(taskNew.SourceAddress),
                d_involed2 = taskNew.TargetAddress,
                d_involed5 = taskNew.TaskNum.ToString(),
            };
            location.LocationStatus = (int)LocationEnum.Lock;
            _locationRepository.UpdateData(location);
            BaseDal.AddData(taskNew);
            SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            return content.OK();
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }

    public string InsertHyphenEveryTwoChars(string input)
    {
        if (string.IsNullOrEmpty(input))
        {
            return input;
        }

        StringBuilder result = new StringBuilder();

        for (int i = 0; i < input.Length; i += 2)
        {
            // 添加两个字符
            result.Append(input.Substring(i, 2));

            // 如果不是最后两个字符，添加一个连字符
            if (i + 2 < input.Length)
            {
                result.Append('-');
            }
        }

        return result.ToString();
    }

    public DtLocationInfo GetLocation()
    {
        List<DtLocationInfo> locations = _locationRepository.QueryData(x => x.LocationStatus == (int)LocationEnum.Free);
        return locations.OrderBy(x => x.Layer).ThenBy(x => x.Column).ThenBy(x => x.Row).FirstOrDefault();
    }

    public WebResponseContent TaskComplete(int? TaskNum)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var task = BaseDal.QueryFirst(x => x.TaskNum == TaskNum);
            if (task != null)
            {
                switch (task.TaskType)
                {
                    case (int)TaskInboundTypeEnum.Inbound:
                        LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务", "");
                        return CompleteInboundTask(task);

                    case (int)TaskOutboundTypeEnum.Outbound:
                        //case (int)TaskStationTypeEnum..:

                        LogFactory.GetLog("任务完成").InfoFormat(true, "出库任务", "");
                        return CompleteOutboundTask(task);

                    case (int)TaskRelocationTypeEnum.Relocation:
                        return CompleteRelocationboundTask(task);

                    case (int)TaskOutboundTypeEnum.OutQuality:
                        return CompleteSamplingOutboundTask(task);

                    case (int)TaskInboundTypeEnum.InQuality:
                        return CompleteSamplingInboundTask(task);

                    default:
                        return content.Error("任务类型不存在");
                }
            }
            else
            {
                return content.Error("未找到任务");
            }
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    public WebResponseContent TaskStatus(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            if (task != null)
            {
                switch (task.TaskType)
                {
                    case (int)TaskInboundTypeEnum.Inbound:
                    case (int)TaskInboundTypeEnum.InQuality:
                        task.TaskState = (int)TaskInStatusEnum.AGV_InExecuting;
                        BaseDal.Update(task);
                        break;

                    case (int)TaskOutboundTypeEnum.Outbound:
                    case (int)TaskOutboundTypeEnum.OutQuality:
                        task.TaskState = (int)TaskInStatusEnum.AGV_InExecuting;
                        BaseDal.Update(task);
                        break;

                    case (int)TaskRelocationTypeEnum.Relocation:
                        task.TaskState = (int)TaskInStatusEnum.AGV_InExecuting;
                        BaseDal.Update(task);
                        break;
                    default:
                        return content.Error("任务类型不存在");
                }
                return content.OK();
            }
            else
            {
                return content.Error("未找到任务");
            }
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent CompleteInboundTask(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();
            task.TaskState = 215;
            var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == task.TargetAddress);
            locationInf.LocationStatus = 2;
            var stock = new DtStockInfo()
            {
                PalletCode = task.PalletCode,
                LocationCode = task.TargetAddress,
                CreateDate = DateTime.Now,
                Creater = "system",
                LocationId = locationInf.Id,
            };
            _stockInfoRepository.AddData(stock);
            _locationRepository.UpdateData(locationInf);
            TaskMoveHty(task);
            _unitOfWorkManage.CommitTran();

            LogFactory.GetLog("入库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();

            LogFactory.GetLog("入库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent CompleteSamplingInboundTask(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();
            task.TaskState = 215;
            var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == task.TargetAddress);
            locationInf.LocationStatus = (int)LocationEnum.InStock;
            _locationRepository.UpdateData(locationInf);
            TaskMoveHty(task);
            _unitOfWorkManage.CommitTran();

            LogFactory.GetLog("抽检入库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("抽检入库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent CompleteOutboundTask(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();
            task.TaskState = 135;
            var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
            locationInf.LocationStatus = 0;
            var stock = _stockInfoRepository.QueryFirst(x => x.PalletCode == task.PalletCode);
            if(stock!=null)
            {
                DtStockInfo_Hty stockInfo_Hty = stock.Adapt<DtStockInfo_Hty>();
                stockInfo_Hty.ModifyDate = DateTime.Now;

                AddStockInfoHty(stockInfo_Hty);

                _stockInfoRepository.DeleteData(stock);
            }
            _locationRepository.UpdateData(locationInf);
            TaskMoveHty(task);

            _unitOfWorkManage.CommitTran();
            LogFactory.GetLog("出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran(); 
            LogFactory.GetLog("出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    

    public WebResponseContent CompleteSamplingOutboundTask(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();

            task.TaskState = 135;
            TaskMoveHty(task);

            _unitOfWorkManage.CommitTran();
            LogFactory.GetLog("抽检出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("抽检出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent CompleteRelocationboundTask(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();
            task.TaskState = 315;
            var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == task.TargetAddress);
            var location = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
            locationInf.LocationStatus = 2;
            location.LocationStatus = 0;

            var stock = _stockInfoRepository.QueryFirst(x => x.PalletCode == task.PalletCode);

            stock.LocationCode = locationInf.LocationCode;
            stock.LocationId = locationInf.Id;


            _stockInfoRepository.UpdateData(stock);
            _locationRepository.UpdateData(locationInf);
            _locationRepository.UpdateData(location);
            TaskMoveHty(task);
            _unitOfWorkManage.CommitTran();
            LogFactory.GetLog("移库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("移库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }
    public WebResponseContent TaskMoveHty(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();
            var taskHtyNG = CreateHistoricalTask(task);

            var taskNum = task.TaskNum.ToString();
            var isTaskHtyAdd = _task_HtyRepository.AddData(taskHtyNG) > 0;
            var isTaskDelete = Delete(task.TaskId);
            var AgvTask = SqlSugarHelper.DbAGV.Queryable<task_call>().Where(x => x.d_involed5 == taskNum).First();
            if (AgvTask != null)
            {
                SqlSugarHelper.DbAGV.Deleteable(AgvTask).ExecuteCommand();
            }
            _unitOfWorkManage.CommitTran();
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("删除任务").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    #endregion 外部接口方法

    #region private 内部方法

    /// <summary>
    /// 创建历史任务记录
    /// </summary>
    /// <param name="task"></param>
    /// <returns></returns>
    public Dt_Task_Hty CreateHistoricalTask(Dt_Task task, bool isHand = false)
    {
        task.CurrentAddress = task.NextAddress;

        // 创建历史任务
        var taskHty = _mapper.Map<Dt_Task_Hty>(task);
        taskHty.FinishTime = DateTime.Now;
        taskHty.TaskId = 0;
        taskHty.OperateType = isHand ? (int)OperateTypeEnum.人工删除 : App.User.UserName != null ? (int)OperateTypeEnum.人工完成 : (int)OperateTypeEnum.自动完成;
        taskHty.SourceId = task.TaskId;
        if (isHand)
        {
            taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";
        }
        return taskHty;
    }
    /// <summary>
    /// 删除一个任务
    /// </summary>
    /// <param name="id">任务ID</param>
    /// <returns>是否删除成功</returns>
    public bool Delete(int id)
    {
        return BaseDal.Delete(id);
    }
    private void AddStockInfoHty(DtStockInfo_Hty dtStock)
    {
        var isStockAdd = SqlSugarHelper.DbWMS.InsertNav(dtStock).IncludesAllFirstLayer().ExecuteCommand();
        if (!isStockAdd)
        {
            throw new Exception("库存历史信息添加失败");
        }
    }

    #endregion private 内部方法
}