using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Text;
using WIDESEA_DTO.Agv;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Enums;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.LogHelper;
using WIDESEAWCS_DTO.Agv;
using WIDESEAWCS_IBasicInfoRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_Tasks;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using WIDESEAWCS_Tasks.DBNames;

namespace WIDESEAWCS_Server.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class AGVController : ControllerBase
    {
        private readonly IStationMangerRepository _stationMangerRepository;
        private readonly ITaskService _taskService;
        private readonly ITaskRepository _taskRepository;

        public AGVController(IStationMangerRepository stationMangerRepository, ITaskService taskService, ITaskRepository taskRepository)
        {
            _stationMangerRepository = stationMangerRepository;
            _taskService = taskService;
            _taskRepository = taskRepository;
        }

        

        /// <summary>
        /// 安全信号申请 AGV-WCS
        /// </summary>
        /// <param name="secureApplyModel"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("AgvSecureApply"), AllowAnonymous]
        public AgvResponse AgvSecureApply([FromBody] AgvSecureApplyDTO secureApplyModel)
        {
            AgvResponse agvResponse = new AgvResponse();
            try
            {
                var task = _taskRepository.QueryFirst(x => secureApplyModel.ReceiveTaskID.ObjToInt() == x.TaskNum);
                if (task == null) throw new Exception("未找到任务");
                if (task.TaskType == TaskTypeEnum.Outbound.ObjToInt())
                {
                    var content = TakeRequest(task.CurrentAddress);
                    if (!content.Status)
                    {
                        throw new Exception(content.Message);
                    }
                }
                else
                {
                    var content = PutRequest(task.NextAddress, task.PalletType);
                    if (!content.Status)
                    {
                        throw new Exception(content.Message);
                    }
                }
                task.TaskState = TaskStatusEnum.AGV_Puting.ObjToInt();
                var up = _taskRepository.UpdateData(task);
                agvResponse.OK("成功","0");
            }
            catch (Exception ex)
            {
                agvResponse.Error(ex.Message);
            }
            return agvResponse;
        }
        /// <summary>
        /// 提升机申请 AGV-WCS
        /// </summary>
        /// <param name="secureApplyModel"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("AgvHoisterApply"), AllowAnonymous]
        public AgvResponse AgvHoisterApply([FromBody] AgvHoisterApplyDTO agvHoisterApplyDTO)
        {
            AgvResponse agvResponse = new AgvResponse();
            try
            {
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == agvHoisterApplyDTO.HoisterCode);
                if (device == null)
                {
                    return agvResponse.Error($"未找到对应设备{agvHoisterApplyDTO.HoisterCode}");
                }
                OtherDevice otherDevice = (OtherDevice)device;
                //获取设备协议
                DeviceProDTO? deviceProRead = otherDevice.DeviceProDTOs.Where(x => x.DeviceChildCode == device.DeviceCode && x.DeviceProParamType == nameof(R_HoisterDB)).OrderBy(x => x.DeviceProOffset).FirstOrDefault();
                DeviceProDTO? deviceProWrite = otherDevice.DeviceProDTOs.Where(x => x.DeviceChildCode == device.DeviceCode && x.DeviceProParamType == nameof(W_HoisterDB)).OrderBy(x => x.DeviceProOffset).FirstOrDefault();
                if (deviceProRead == null || deviceProWrite == null)
                {
                    return agvResponse.Error($"未找到设备{device.DeviceCode}协议");
                }
                //获取读取和写入
                R_HoisterInfo r_HoisterInfo = otherDevice.Communicator.ReadCustomer<R_HoisterInfo>(deviceProRead.DeviceProAddress);
                W_HoisterInfo w_HoisterInfo = otherDevice.Communicator.ReadCustomer<W_HoisterInfo>(deviceProWrite.DeviceProAddress);
                if (r_HoisterInfo == null || w_HoisterInfo == null)
                {
                    return agvResponse.Error($"未读取到设备{device.DeviceCode}信号");
                }
                if (r_HoisterInfo.R_HoisterSysStatus!=3)
                {
                    return agvResponse.Error($"设备状态不为自动");
                }
                QuartzLogger.WriteLogToFile("Info_" + device.DeviceCode, $"r_HoisterInfo:{r_HoisterInfo.Serialize()}{Environment.NewLine}w_HoisterInfo:{w_HoisterInfo.Serialize()}{Environment.NewLine}");
                bool IsSuccess = false;
                switch (agvHoisterApplyDTO.Request)
                {
                    case "1":
                        //判断提升机是否在当前层 如果当前层，关门状态，无货待命直接写入开门信号
                        if (r_HoisterInfo.R_HoisterCurrent == agvHoisterApplyDTO.CurrentLayer && r_HoisterInfo.R_HoisterLoadStatus == 2 && r_HoisterInfo.R_HoisterDoorStatus == 2)
                        {
                            otherDevice.SetValue(W_HoisterDB.W_HoisterDoorStatus, 1);
                            IsSuccess = true;
                        }
                        else if (r_HoisterInfo.R_HoisterCurrent == agvHoisterApplyDTO.CurrentLayer && r_HoisterInfo.R_HoisterLoadStatus == 2 && r_HoisterInfo.R_HoisterDoorStatus == 1)
                        {
                            IsSuccess = true;
                        }
                        else if (r_HoisterInfo.R_HoisterCurrent != agvHoisterApplyDTO.CurrentLayer && r_HoisterInfo.R_HoisterLoadStatus == 2 && r_HoisterInfo.R_HoisterDoorStatus == 1)
                        {
                            otherDevice.SetValue(W_HoisterDB.W_HoisterDoorStatus, 2);
                        }
                        //判断提升机不在当前层 如果不在当前层，关门状态，无货待命直接写入移动开门信号(当前)
                        else if (r_HoisterInfo.R_HoisterCurrent != agvHoisterApplyDTO.CurrentLayer && r_HoisterInfo.R_HoisterLoadStatus == 2 && r_HoisterInfo.R_HoisterDoorStatus == 2)
                        {
                            otherDevice.SetValue(W_HoisterDB.W_HoisterTarget, agvHoisterApplyDTO.CurrentLayer);
                            otherDevice.SetValue(W_HoisterDB.W_HoisterTask, 99);
                        }
                        return IsSuccess ? agvResponse.OK($"请求{agvHoisterApplyDTO.Request}成功,任务{agvHoisterApplyDTO.ReceiveTaskID}","1"): agvResponse.Error($"请求{agvHoisterApplyDTO.Request}失败,任务{agvHoisterApplyDTO.ReceiveTaskID}");
                    case "2":
                        //判断提升机是否在当前层 如果当前层，开门状态，无货待命 放行
                        if (r_HoisterInfo.R_HoisterCurrent == agvHoisterApplyDTO.CurrentLayer && r_HoisterInfo.R_HoisterLoadStatus == 2 && r_HoisterInfo.R_HoisterDoorStatus == 1)
                        {
                            IsSuccess = true;
                        }
                        return IsSuccess ? agvResponse.OK($"请求{agvHoisterApplyDTO.Request}成功,任务{agvHoisterApplyDTO.ReceiveTaskID}", "2") : agvResponse.Error($"请求{agvHoisterApplyDTO.Request}失败,任务{agvHoisterApplyDTO.ReceiveTaskID}");
                    case "3":
                        //判断提升机是否在当前层 如果当前层，开门状态，有货待命写入关门信号
                        if (r_HoisterInfo.R_HoisterCurrent == agvHoisterApplyDTO.CurrentLayer && r_HoisterInfo.R_HoisterLoadStatus == 1 && r_HoisterInfo.R_HoisterDoorStatus == 1 && w_HoisterInfo.W_HoisterDoorStatus!=2)
                        {
                            otherDevice.SetValue(W_HoisterDB.W_HoisterDoorStatus, 2);
                        }
                        //判断提升机是否在当前层 如果当前层，关门状态，有货待命写入移动开门信号(目的)
                        if (r_HoisterInfo.R_HoisterCurrent == agvHoisterApplyDTO.CurrentLayer && r_HoisterInfo.R_HoisterLoadStatus == 1 && r_HoisterInfo.R_HoisterDoorStatus == 2)
                        {
                            otherDevice.SetValue(W_HoisterDB.W_HoisterTarget, agvHoisterApplyDTO.TargetLayer);
                            otherDevice.SetValue(W_HoisterDB.W_HoisterDoorStatus, 1);
                            otherDevice.SetValue(W_HoisterDB.W_HoisterTask, 99);
                            IsSuccess = true;
                        }
                        return IsSuccess ? agvResponse.OK($"请求{agvHoisterApplyDTO.Request}成功,任务{agvHoisterApplyDTO.ReceiveTaskID}", "3") : agvResponse.Error($"请求{agvHoisterApplyDTO.Request}失败,任务{agvHoisterApplyDTO.ReceiveTaskID}");
                    case "4":
                        //判断提升机是否在目的层 如果目的层，开门状态，有货待命 放行
                        if (r_HoisterInfo.R_HoisterCurrent == agvHoisterApplyDTO.TargetLayer && r_HoisterInfo.R_HoisterLoadStatus == 1 && r_HoisterInfo.R_HoisterDoorStatus == 1)
                        {
                            IsSuccess = true;
                        }
                        return IsSuccess ? agvResponse.OK($"请求{agvHoisterApplyDTO.Request}成功,任务{agvHoisterApplyDTO.ReceiveTaskID}", "4") : agvResponse.Error($"请求{agvHoisterApplyDTO.Request}失败,任务{agvHoisterApplyDTO.ReceiveTaskID}");
                    case "5":
                        //判断提升机是否在目的层 如果目的层，开门状态，无货待命写入关门信号
                        if (r_HoisterInfo.R_HoisterCurrent == agvHoisterApplyDTO.TargetLayer && r_HoisterInfo.R_HoisterLoadStatus == 2 && r_HoisterInfo.R_HoisterDoorStatus == 1)
                        {
                            otherDevice.SetValue(W_HoisterDB.W_HoisterDoorStatus, 2);
                            IsSuccess = true;
                        }
                        return IsSuccess ? agvResponse.OK($"请求{agvHoisterApplyDTO.Request}成功,任务{agvHoisterApplyDTO.ReceiveTaskID}", "5") : agvResponse.Error($"请求{agvHoisterApplyDTO.Request}失败,任务{agvHoisterApplyDTO.ReceiveTaskID}");
                    default:
                        return agvResponse.Error($"未找到对应请求,Request:{agvHoisterApplyDTO.Request}");
                }
            }
            catch (Exception ex)
            {
                agvResponse.Error($"请求{agvHoisterApplyDTO.Request}失败,错误{ex.Message},任务{agvHoisterApplyDTO.ReceiveTaskID}");
            }
            return agvResponse;
        }
        /// <summary>
        /// AGV任务更新/完成
        /// </summary>
        /// <param name="agvUpdateModel"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("AgvCallback"), AllowAnonymous]
        public AgvResponse AgvCallback([FromBody] AgvUpdateDTO agvUpdateModel)
        {
            AgvResponse agvResponse = new AgvResponse();
            try
            {
                var task = _taskRepository.QueryFirst(x => agvUpdateModel.ReceiveTaskID == x.TaskNum.ToString());
                if (task == null) throw new Exception($"未找到任务,任务号【{agvUpdateModel.ReceiveTaskID}】");
                switch (agvUpdateModel.GoodsState)
                {
                    //case 1://出库根据这个信号判断取货完成
                    //    if (task.TaskType == TaskTypeEnum.Outbound.ObjToInt())
                    //    {
                    //        var content = TakeFinish(task.CurrentAddress);
                    //        if (!content.Status) throw new Exception(content.Message);
                    //        task.TaskState = TaskStatusEnum.AGV_Finish.ObjToInt();
                    //        var up = _taskRepository.DeleteAndMoveIntoHty(task, OperateTypeEnum.自动完成);
                    //        _taskService.TaskCompleted(task.TaskNum);
                    //    }
                    //    break;
                    case 2://入库根据这个信号判断放货完成
                        if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                        {
                            Dt_StationManger dt_Station = _stationMangerRepository.QueryFirst(x => x.StationCode == task.NextAddress);
                            if (dt_Station == null)
                            {
                                throw new Exception($"{task.NextAddress}AGV站台未定义");
                            }
                            task.CurrentAddress = dt_Station.StationCode;
                            task.NextAddress = "";
                            task.TaskState = TaskStatusEnum.AGV_Finish.ObjToInt();
                            task.DeviceCode = dt_Station.StationDeviceCode;
                            var up = _taskRepository.UpdateData(task);
                            return agvResponse.OK("成功","0");
                        }
                        break;
                    default:
                        throw new Exception($"未定义方法名【{agvUpdateModel.TaskState}】");
                }
            }
            catch (Exception ex)
            {
                agvResponse.Error(ex.Message);
            }
            return agvResponse;
            //return _taskService.AgvUpdateTask(agvUpdateModel);
        }

        /// <summary>
        /// 放货请求
        /// </summary>
        /// <param name="code"></param>
        /// <param name="palletType"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PutRequest"), AllowAnonymous]
        public WebResponseContent PutRequest(string code, int palletType)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.StationCode == code);
                if (stationManger == null)
                {
                    return content.Error($"未找到站台配置");
                }
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManger.StationDeviceCode);
                if (device == null)
                {
                    return content.Error($"未找到对应设备");
                }

                OtherDevice otherDevice = (OtherDevice)device;

                short Command = otherDevice.GetValue<R_ConveyorLineCPDB, short>(R_ConveyorLineCPDB.Command, stationManger.StationCode);
                if (Command == 3)
                {
                    content.OK("允许放料");
                }
                else
                {
                    return content.Error("禁止放料");
                }
                return content;
            }
            catch (Exception ex)
            {
                return content.Error(ex.Message);
            }
        }

        //[HttpPost, HttpGet, Route("PutFinish"), AllowAnonymous]
        /// <summary>
        /// 放货完成
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PutFinish"), AllowAnonymous]
        public WebResponseContent PutFinish(string code)
        {
            try
            {
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.AGVStationCode == code);
                if (stationManger == null)
                {
                    return WebResponseContent.Instance.Error($"未找到站台配置");
                }
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManger.StationDeviceCode);
                if (device == null)
                {
                    return WebResponseContent.Instance.Error($"未找到对应设备");
                }

                OtherDevice otherDevice = (OtherDevice)device;
                otherDevice.SetValue(GroundStationDBName.W_PutFinish, true, stationManger.StationCode);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        //[HttpPost, HttpGet, Route("TakeRequest"), AllowAnonymous]
        /// <summary>
        /// 取货请求
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("TakeRequest"), AllowAnonymous]
        public WebResponseContent TakeRequest(string code)
        {
            try
            {
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.AGVStationCode == code);
                if (stationManger == null)
                {
                    return WebResponseContent.Instance.Error($"未找到站台配置");
                }
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManger.StationDeviceCode);
                if (device == null)
                {
                    return WebResponseContent.Instance.Error($"未找到对应设备");
                }

                OtherDevice otherDevice = (OtherDevice)device;

                bool canPut = otherDevice.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanTake, stationManger.StationCode);
                if (canPut)
                {
                    otherDevice.SetValue(GroundStationDBName.W_TakeRequest, true, stationManger.StationCode);
                    return WebResponseContent.Instance.OK();
                }
                else
                {
                    otherDevice.SetValue(GroundStationDBName.W_TakeRequest, true, stationManger.StationCode);
                    Thread.Sleep(1000);
                    canPut = otherDevice.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanTake, stationManger.StationCode);
                    if (canPut)
                    {
                        return WebResponseContent.Instance.OK();
                    }
                    else
                    {
                        return WebResponseContent.Instance.Error($"取货申请中");
                    }
                }
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        //[HttpPost, HttpGet, Route("TakeFinish"), AllowAnonymous]
        /// <summary>
        /// 取货完成
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("TakeFinish"), AllowAnonymous]
        public WebResponseContent TakeFinish(string code)
        {
            try
            {
                Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.AGVStationCode == code);
                if (stationManger == null)
                {
                    return WebResponseContent.Instance.Error($"未找到站台配置");
                }
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManger.StationDeviceCode);
                if (device == null)
                {
                    return WebResponseContent.Instance.Error($"未找到对应设备");
                }

                OtherDevice otherDevice = (OtherDevice)device;
                otherDevice.SetValue(GroundStationDBName.W_TakeFinish, true, stationManger.StationCode);
                Thread.Sleep(1000);
                otherDevice.SetValue(GroundStationDBName.W_TakeFinish, false, stationManger.StationCode);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
    }
}