using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using ServiceCenter;
using ServiceCenter.Redis;
using ServiceCenter.SqlSugars;
using System.Net.NetworkInformation;
using System.Text;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol.DataStructure;
using WCS.Entity.Protocol.SRM;
using WCS.WorkEngineering.Extensions;
using WCS.WorkEngineering.Systems;
using WCS.WorkEngineering.WebApi.Models.WCS.Request;
using WCS.WorkEngineering.WebApi.Models.WCS.Response;
using WCS.WorkEngineering.WebApi.Models.WMS.Response;

namespace WCS.WorkEngineering.WebApi.Controllers
{
    /// <summary>
    /// WCS相关接口控制器
    /// </summary>
    [ApiController]
    [Route("api/[controller]/[action]")]
    public class WcsController : ControllerBase, IDeviceWriter
    {
        /// <summary>
        ///  任务处理接口
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<HandleTaskResponse> HandleTask([FromBody] HandleTaskRequest req)
        {
            SRes<HandleTaskResponse> response = new SRes<HandleTaskResponse>() { ResCode = ResponseStatusCodeEnum.Sucess, ResDataList = new List<HandleTaskResponse>() };

            //取消任务
            if (req.Type == HandleTaskTypeEnum.取消任务)
            {
                foreach (var item in req.TaskIds)
                {
                    SqlSugarHelper.Do(db =>
                    {
                        var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
                        if (task != null)
                        {
                            //验证wms是否能取消
                            var res = WmsApi.HandleTaskVerify(new List<int>() { task.ID }, 106);
                            if (res.ResCode == Models.WMS.Response.ResponseStatusCodeEnum.Sucess)
                            {
                                switch (task.Type)
                                {
                                    case TaskType.SetPlate:
                                        if (task.Status != Entity.TaskStatus.WaitingToExecute)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"只能取消待执行状态组盘任务",
                                            });
                                            return;
                                        }
                                        break;

                                    case TaskType.EnterDepot:
                                        if (task.Status != Entity.TaskStatus.WaitingToExecute)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"只能取消待执行状态入库任务",
                                            });
                                            return;
                                        }
                                        break;

                                    case TaskType.OutDepot:
                                        if (task.Status != Entity.TaskStatus.WaitingToExecute)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"只能取消待执行状态出库任务",
                                            });
                                            return;
                                        }
                                        break;

                                    case TaskType.TransferDepot:
                                        break;

                                    case TaskType.Delivery:
                                        if (task.Status != Entity.TaskStatus.WaitingToExecute)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"只能取消待执行搬运任务",
                                            });
                                            return;
                                        }
                                        break;

                                    case TaskType.EmptyInit:
                                        if (task.Status != Entity.TaskStatus.WaitingToExecute)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"只能取消待执行状态空轮初始化任务",
                                            });
                                            return;
                                        }
                                        break;
                                }
                                //取消任务
                                var cancelRes = WmsApi.CarryTaskInfo(new List<int>() { task.ID }, 106);
                                if (cancelRes.ResCode == Models.WMS.Response.ResponseStatusCodeEnum.Sucess)
                                {
                                    //找到对应的AGV任务
                                    var agv = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.ID == task.AgvTaskID).SplitTable(v => v.Take(2)).First();
                                    if (agv != null)
                                    {
                                        agv.Status = AGVTaskStatus.Cancel;
                                        agv.AgvStatus = AGVTaskStatus.Cancel;
                                        db.Default.Updateable(agv).SplitTable().ExecuteCommand();
                                    }
                                    //更新任务状态
                                    task.Status = Entity.TaskStatus.Cancel;
                                    task.EditTime = DateTime.Now;
                                    task.EditWho = req.User;
                                    task.ManualRemarks = req.ManualRemarks;
                                    task.AddWCS_TASK_DTL(db, "未知", "任务取消");
                                    db.Default.Updateable(task).ExecuteCommand();
                                    task.CompleteOrCancelTasks(db);
                                    response.ResDataList.Add(new HandleTaskResponse()
                                    {
                                        IsSuccess = true,
                                        TaskNo = item,
                                        Message = $"完成",
                                    });
                                }
                                else
                                {
                                    response.ResDataList.Add(new HandleTaskResponse()
                                    {
                                        IsSuccess = false,
                                        TaskNo = item,
                                        Message = $"取消任务失败，{cancelRes.ResMsg}",
                                    });
                                }
                            }
                            else
                            {
                                response.ResDataList.Add(new HandleTaskResponse()
                                {
                                    IsSuccess = false,
                                    TaskNo = item,
                                    Message = $"取消任务失败，{res.ResMsg}",
                                });
                            }
                        }
                        else
                        {
                            response.ResDataList.Add(new HandleTaskResponse()
                            {
                                IsSuccess = false,
                                TaskNo = item,
                                Message = $"未找到对应任务{item}"
                            });
                        }
                    });
                }
            }
            // 完成任务
            else if (req.Type == HandleTaskTypeEnum.完成任务)
            {
                SqlSugarHelper.Do(db =>
                {
                    foreach (var item in req.TaskIds)
                    {
                        var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
                        if (task != null)
                        {
                            if (task.Type == TaskType.OutDepot && task.Floor == 1)
                            {
                                task.Status = Entity.TaskStatus.Finish;
                                task.EditWho = req.User;
                                task.ManualRemarks = req.ManualRemarks;
                                task.AddWCS_TASK_DTL(db, "未知", "手动完成任务");
                                task.CompleteOrCancelTasks(db);
                                db.Default.Updateable(task).ExecuteCommand();
                            }
                            else
                            {
                                response.ResDataList.Add(new HandleTaskResponse()
                                {
                                    IsSuccess = false,
                                    TaskNo = item,
                                    Message = $"未实现当前任务的完成功能"
                                });
                            }
                        }
                        else
                        {
                            response.ResDataList.Add(new HandleTaskResponse()
                            {
                                IsSuccess = false,
                                TaskNo = item,
                                Message = $"未找到对应任务{item}"
                            });
                        }
                    }
                });

            }
            else if (req.Type == HandleTaskTypeEnum.重新下发AGV任务)
            {
                SqlSugarHelper.Do(db =>
                {
                    foreach (var item in req.TaskIds)
                    {
                        var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
                        if (task != null)
                        {
                            //只有WCS是AGV执行中 AGV是确认 才能从新下发
                            switch (task.Type)
                            {
                                case TaskType.SetPlate:
                                    response.ResDataList.Add(new HandleTaskResponse()
                                    {
                                        IsSuccess = false,
                                        TaskNo = item,
                                        Message = $"组盘任务无AGV执行流程",
                                    });
                                    return;

                                case TaskType.EnterDepot:
                                    switch (task.Floor)
                                    {
                                        case 1:
                                            break;

                                        case 2:
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"二楼入库任务重新下发AGV未实现",
                                            });
                                            break;
                                    }
                                    break;

                                case TaskType.OutDepot:
                                    switch (task.Floor)
                                    {
                                        case 1:
                                            break;

                                        case 2:
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"二楼出库任务重新下发AGV未实现",
                                            });
                                            break;
                                    }
                                    break;

                                case TaskType.TransferDepot:
                                    response.ResDataList.Add(new HandleTaskResponse()
                                    {
                                        IsSuccess = false,
                                        TaskNo = item,
                                        Message = $"组盘任务无AGV执行流程",
                                    });
                                    return;

                                case TaskType.Delivery:
                                    switch (task.Floor)
                                    {
                                        case 1:
                                            break;

                                        case 2:
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"二楼搬运任务重新下发AGV未实现",
                                            });
                                            return;
                                    }
                                    break;

                                case TaskType.EmptyInit:
                                    response.ResDataList.Add(new HandleTaskResponse()
                                    {
                                        IsSuccess = false,
                                        TaskNo = item,
                                        Message = $"空轮初始化无AGV执行流程",
                                    });
                                    return;
                            }

                            //找到对应的AGV任务
                            var agv = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.ID == task.AgvTaskID).SplitTable(v => v.Take(2)).First();
                            if (agv != null)
                            {
                                agv.Status = AGVTaskStatus.NewBuild;
                                agv.AgvStatus = AGVTaskStatus.NewBuild;
                                db.Default.Updateable(agv).SplitTable().ExecuteCommand();
                            }
                            task.Status = Entity.TaskStatus.WaitingToExecute;
                            task.AddWCS_TASK_DTL(db, "AGV", "重新下发AGV任务");
                            db.Default.Updateable(task).ExecuteCommand();
                        }
                        else
                        {
                            response.ResDataList.Add(new HandleTaskResponse()
                            {
                                IsSuccess = false,
                                TaskNo = item,
                                Message = $"未找到对应任务{item}"
                            });
                        }
                    }
                });
            }

            return response;
        }

        /// <summary>
        ///  设备信息写入接口
        /// </summary>
        /// <param name="deviceType">需要写入信息的设备类型</param>
        /// <param name="devCode">设备编号</param>
        /// <param name="protocol">设备协议类名</param>
        /// <param name="propName">写入字段名</param>
        /// <param name="value">值</param>
        [HttpPost]
        public void Write(DeviceTypeEnum deviceType, string devCode, string protocol, string propName, string value)
        {
            World.GetSystemInstance<DeviceWriteSystem>().Invoke(new DeviceWriteInfo
            {
                DeviceType = deviceType,
                Code = devCode,
                Protocol = protocol,
                Property = propName,
                Value = value
            });
        }

        /// <summary>
        ///  设备信息写入接口
        /// </summary>
        /// <param name="deviceType">需要写入信息的设备类型</param>
        /// <param name="devCode">设备编号</param>
        /// <param name="protocol">设备协议类名</param>
        /// <param name="propName">写入字段名</param>
        /// <param name="value">值</param>
        [HttpPost]
        public void GetDevList()
        {
            var a = RedisHub.Monitor.LRange("Packs", 0, 80000);
            List<DeviceDataPack> packs = new List<DeviceDataPack>();
            foreach (var item in a)
            {
                packs.Add(JsonConvert.DeserializeObject<DeviceDataPack>(item));
            }
        }

        /// <summary>
        ///  获取设备配置信息接口
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public List<Device> GetDeviceList()
        {
            return Device.All.ToList();
        }

        /// <summary>
        ///  获取设备信息
        /// </summary>
        /// <param name="name">设备名称</param>
        /// <returns></returns>
        [HttpGet]
        public object GetDeviceInfo(string name)
        {
            var obj = World.GetSystemInstance<GetDeviceSystem>().Invoke(name);

            return obj;
        }

        /// <summary>
        ///  堆垛机测试
        /// </summary>
        /// <param name="srmcod">堆垛机编号</param>
        /// <param name="typeEnum">任务类型</param>
        /// <param name="value1">起始行</param>
        /// <param name="value2">起始列</param>
        /// <param name="value3">起始层</param>
        /// <param name="value4">目标行</param>
        /// <param name="value5">目标列</param>
        /// <param name="value6">目标层</param>
        [HttpPost]
        public void SrmDeBug(string srmcod, SrmTaskTypeEnum typeEnum, short value1, short value2, short value3, short value4, short value5, short value6)
        {
            World.GetSystemInstance<SrmDebugSystem>().Invoke(new SrmDebugInfo
            {
                SrmCode = srmcod,
                srmTaskType = typeEnum,
                SLine = value1,
                SCol = value2,
                SLayer = value3,
                ELine = value4,
                ECol = value5,
                ELayer = value6
            });
        }

        #region 设备IP相关

        /// <summary>
        ///  获取设备Ip集合
        /// </summary>
        /// <returns>设备Ip集合</returns>
        [HttpGet]
        public List<string> GetDeviceIpList()
        {
            if (!ServiceHub.DeviceIPList.Any()) throw new Exception("未配置任何Ip");
            return ServiceHub.DeviceIPList;
        }

        /// <summary>
        ///  获取设备IP检测结果
        /// </summary>
        /// <returns>设备IP检测结果</returns>
        [HttpGet]
        public List<DeviceIpTestResults> DeviceIpTest()
        {
            if (!ServiceHub.DeviceIPList.Any()) throw new Exception("未配置任何Ip");
            List<DeviceIpTestResults> deviceIpTestResults = new List<DeviceIpTestResults>();
            ServiceHub.DeviceIPList.ForEach(ip =>
            {
                deviceIpTestResults.Add(new DeviceIpTestResults
                {
                    Ip = ip,
                    Result = PingIpOrDomainName(ip)
                });
            });

            return deviceIpTestResults;
        }

        /// <summary>
        /// 检查Ip是否正常联通
        /// </summary>
        /// <param name="strIpOrDName">输入参数,表示IP地址或域名</param>
        /// <returns></returns>
        public static bool PingIpOrDomainName(string strIpOrDName)
        {
            try

            {
                Ping objPingSender = new Ping();

                PingOptions objPinOptions = new PingOptions();

                objPinOptions.DontFragment = true;

                string data = "";

                byte[] buffer = Encoding.UTF8.GetBytes(data);

                int intTimeout = 120;

                PingReply objPinReply = objPingSender.Send(strIpOrDName, intTimeout, buffer, objPinOptions);

                string strInfo = objPinReply.Status.ToString();

                if (strInfo == "Success")

                {
                    return true;
                }
                else

                {
                    return false;
                }
            }
            catch (Exception)

            {
                return false;
            }
        }

        #endregion 设备IP相关
    }

    public interface IDeviceWriter
    {
        [HttpPost]
        void Write(DeviceTypeEnum deviceType, string devCode, string protocol, string propName, string value);
    }

    /// <summary>
    ///  设备Ip通讯检测结构
    /// </summary>
    public class DeviceIpTestResults
    {
        public string Ip { get; set; }

        public bool Result { get; set; }
    }
}