using AGVLib;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml.Linq;
using static JAKA.JKTYPE;

namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 周转箱
    /// </summary>
    public class TurnoverBox
    {
        /// <summary>
        /// 箱子rfid
        /// </summary>
        public string BoxId = "";
        public string RFID_IP = "";
        public string Name = "";
        InputEquip_Config config;
        public DeviceMoveInfo MoveInfo;
        public string WarnMsg = "";
        public bool AutoClearBoxBind = false;
        /// <summary>
        /// 周转箱线体AGV检测
        /// </summary>
        string DI_SafetyRasterSignal = "TurnoverBoxA_SafetyRasterSignal";
        /// <summary>
        /// 周转箱线体前端周转箱检测
        /// </summary>
        string DI_FrontCheck = "TurnoverBoxA_FrontCheck";
        /// <summary>
        /// 周转箱线体末端周转箱检测
        /// </summary>
        string DI_InPlaceCheck = "TurnoverBoxA_InPlaceCheck";
        /// <summary>
        /// 周转箱线体正转
        /// </summary>
        string DO_LineRun = "TurnoverBoxA_LineRun";
        /// <summary>
        /// 周转箱线体反转
        /// </summary>
        string DO_LineBackRun = "TurnoverBoxA_LineBackRun";
        public string outLet = "A";
        public TurnoverBox(string name, string rfidIp, InputEquip_Config inputEquip_Config)
        {
            Name = name;
            if (name.Contains("B"))
            {
                outLet = "B";
                DI_SafetyRasterSignal = "TurnoverBoxB_SafetyRasterSignal";
                DI_FrontCheck = "TurnoverBoxB_FrontCheck";
                DI_InPlaceCheck = "TurnoverBoxB_InPlaceCheck";

                DO_LineRun = "TurnoverBoxB_LineRun";
                DO_LineBackRun = "TurnoverBoxB_LineBackRun";
            }
            RFID_IP = rfidIp;
            config = inputEquip_Config;
            MoveInfo = new DeviceMoveInfo(Name);
        }
        public string GetMoveStr()
        {
            return $"料箱：{BoxId} " + $"【格口最大数量：{MaxCntOnSide}】【" + (BoxTaskInfo?.ToStr() ?? "") + "】";
        }
        public void StartReset()
        {
            WarnMsg = "";
            bool needLeave = false;
            ReadBoxId();
            GetBoxTaskInfo();
            if (BoxTaskInfo != null)
            {
                needLeave = (BoxTaskInfo.boxTCount >= MaxCntOnSide || BoxTaskInfo.boxBCount >= MaxCntOnSide || BoxTaskInfo.remainTaskCount <= 0);
            }
            ProcessShelfOut = false;
            ProcessShelfEnter = false;
            recvAGVSig = false;
            SetToNone();
            Task.Factory.StartNew(delegate
            {
                LineRun();
                Thread.Sleep(10000);
                LineStopRun();

                if (needLeave)
                {
                    NeedLeave();
                    LogUtil.info($"复位 {Name}已满/无剩余任务，需要离开。{BoxTaskInfo?.ToStr()??""}");
                }

            });

        }
        public void LineRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_LineBackRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_LineRun, IO_VALUE.HIGH, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineBackRun, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineRun, IO_VALUE.HIGH));
            }
        }

        public void LineBackRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_LineRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_LineBackRun, IO_VALUE.HIGH, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineRun, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineBackRun, IO_VALUE.HIGH));
            }
        }
        public void LineStopRun(DeviceMoveInfo moveInfo = null)
        {
            IOManager.IOMove(DO_LineRun, IO_VALUE.LOW, config.Id);
            IOManager.IOMove(DO_LineBackRun, IO_VALUE.LOW, config.Id);
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineRun, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(DO_LineBackRun, IO_VALUE.LOW));
            }
        }
        bool recvAGVSig = false;
        public void RecvMsgFromServer(Node node)
        {
            if (node == null) return;
            if (node.id == AgvNode.id && AgvNode.name.Equals(node.name))
            {
                AgvNode.status = node.status;
                AgvNode.level = node.level;
                AgvNode.shelf_id = node.shelf_id;
                if (node.status.Equals(NodeStatus.RequestEnter))
                {
                    LogUtil.info($"收到AGV服务端消息：【{node.name}】【{node.status.ToString()}】【{node.ToText()}】");
                    recvAGVSig = true;
                    BoxEnterProcess();
                }
                else if (node.status.Equals(NodeStatus.RequestLeave))
                {
                    LogUtil.info($"收到AGV服务端消息：【{node.name}】【{node.status.ToString()}】【{node.ToText()}】");
                    recvAGVSig = true;
                    BoxOutProcess();
                }
            }
        }
        bool ProcessShelfOut = false;
        bool ProcessShelfEnter = false;
        bool DIValue(string iotype, IO_VALUE iO_VALUE)
        {
            return IOManager.IOValue(iotype, config.Id).Equals(iO_VALUE);
        }
        void BoxOutProcess()
        {
            //AGV已到达，将料串送入AGV中
            Task.Factory.StartNew(delegate
            {
                string logName = Name + " 料箱" + BoxId + "[" + AgvNode.name + "->AGV ]  ";
                try
                {
                    if (DIValue(DI_FrontCheck, IO_VALUE.HIGH) || DIValue(DI_InPlaceCheck, IO_VALUE.HIGH))
                    {
                        ProcessShelfOut = true;
                        MayLeave();
                        LineBackRun();
                        bool result = WaitIo(DI_InPlaceCheck, IO_VALUE.LOW, 60000);
                        if (!result)
                        {
                            LogUtil.error(logName + $"  等待 {DI_InPlaceCheck}=LOW超时，等待8000后停止转动");
                        }
                        else
                        {
                            LogUtil.info(logName + $"  已收到 {DI_InPlaceCheck}=LOW ，等待8000后停止转动");
                        }
                        //再转动8000
                        //Thread.Sleep(8000);

                        // Complete();
                        while (!AgvNode.status.Equals(NodeStatus.Complete))
                        {
                            Thread.Sleep(1000);
                        }
                        if (!ProcessShelfOut) return;
                        Thread.Sleep(1000);
                        FinishLeave();
                        //Thread.Sleep(8000);
                        //Task.Factory.StartNew(delegate
                        //{
                        //    Thread.Sleep(10000);
                        //    AgvClient.SetToNone(AgvNode.id);
                        //});
                        LineStopRun();
                        ProcessShelfOut = false;
                        BoxTaskInfo = new BoxTaskInfo();
                        LogUtil.info(logName + "结束,停止转动，清空料箱[" + BoxId + "] ");
                        BoxId = "";
                    }
                    else
                    {
                        LogUtil.info(logName + " 未检测到料箱，暂不处理");
                        Task.Factory.StartNew(delegate
                        {
                            Thread.Sleep(3000);
                            AgvClient.SetToNone(AgvNode.id);
                        });
                    }
                }
                catch (TimeoutException te)
                {
                    LogUtil.error(logName + " 超时：" + te);
                }
                catch (Exception ex)
                {
                    LogUtil.error(logName + " 出错：", ex);
                }
                finally
                {
                    LineStopRun();
                    ProcessShelfOut = false;
                    recvAGVSig = false;
                }
            });
        }
        void BoxEnterProcess()
        {
            Task.Factory.StartNew(delegate
            {
                BoxId = "";
                string logName = Name + "料箱 " + BoxId + " [AGV->" + AgvNode.name + "] ";
                try
                {
                    if (DIValue(DI_FrontCheck, IO_VALUE.LOW) && DIValue(DI_InPlaceCheck, IO_VALUE.LOW))
                    {
                        LogUtil.info(logName + "   开始转动线体");
                        ProcessShelfEnter = true;
                        MayEnter();
                        LineRun();

                        //等待进料检测信号
                        bool result = WaitIo(DI_FrontCheck, IO_VALUE.HIGH, 60000);

                        if (!result)
                        {
                            LogUtil.error(logName + $" 等待{DI_FrontCheck}=High 超时， 等待 {DI_InPlaceCheck} 信号");
                        }
                        else
                        {
                            LogUtil.info(logName + $"已收到 {DI_FrontCheck}=High ， 等待 {DI_InPlaceCheck} 信号");
                        }
                        result = WaitIo(DI_InPlaceCheck, IO_VALUE.HIGH, 60000);

                        if (!result)
                        {
                            LogUtil.error(logName + $" 等待 {DI_InPlaceCheck} =High 超时，等待3000后停止转动");
                        }
                        else
                        {
                            LogUtil.info(logName + $"已收到 {DI_InPlaceCheck} =High ，等待3000后停止转动");
                        }
                        DateTime dateTime = DateTime.Now;
                        if (ConfigHelper.Config.Get("BoxEnterNeedCompleSig", true))
                        {
                            while (!AgvNode.status.Equals(NodeStatus.Complete))
                            {
                                Thread.Sleep(1000);
                            }
                        }

                        if (!ProcessShelfEnter) return;
                        // Complete();
                        FinishEnter();
                        //等待200毫秒后停止转动
                        //Thread.Sleep(3000);
                        LogUtil.info(logName + "等待3000后，停止链条转动");
                        LineStopRun();
                        GetBoxTaskInfo();
                        //if (ReadBoxId())
                        //{

                        //    //SServerManager.BoxTakeAway(BoxId);
                        //    //Thread.Sleep(1000);
                        //   // BoxTaskInfo = SServerManager.GetBoxStatusInfo(config.CID, BoxId);
                        //}

                        ProcessShelfEnter = false;
                        LogUtil.info(logName + "   结束");
                    }
                    else
                    {
                        //入口有料串，暂不处理
                        LogUtil.error(logName + "，入口已有料架，暂不处理");
                        //Task.Factory.StartNew(delegate
                        //{
                        //    Thread.Sleep(3000);
                        //    //AgvClient.SetStatus(Config.AgvName, "", ClientAction.None, ClientLevel.High, true);
                        //});
                    }
                }
                catch (TimeoutException te)
                {
                    LogUtil.error(logName + "  超时：" + te);
                }
                catch (Exception ex)
                {
                    LogUtil.error(logName + "   出错：", ex);
                }
                finally
                {
                    ProcessShelfEnter = false;
                    recvAGVSig = false;
                }
            });
        }
        public Node AgvNode { get; set; }
        /// <summary>
        /// 是否有空位置
        /// </summary>
        /// <returns></returns>
        public bool HasEmptyPos(int boxT, int boxB)
        {
            return boxT < MaxCntOnSide && boxB < MaxCntOnSide;
        }
        //public bool CanPutIn(out string msg)
        //{
        //    msg = "";
        //    if (InHandlingAGVSig())
        //    {
        //        msg = Name + " 正在进出料，不允许放料";
        //        return false;
        //    }
        //    if (!BoxId.StartsWith("CN"))
        //    {
        //        msg = Name + " 未读到rfid，不允许放料";
        //        return false;
        //    }
        //    bool rtn = CntInSideT < MaxCntOnSide && CntInSideB < MaxCntOnSide;
        //    if (!rtn)
        //    {
        //        msg = Name + $" 格口数量已满，不允许放料。当前数量：【内侧={CntInSideT}】【外侧={CntInSideB}】";
        //        NeedLeave();
        //    }
        //    return rtn;
        //}
        //public bool CheckState(Label_LZ labelInfo, InOutParam param, out BoxTaskInfo boxTaskInfo, out string warnMsg)
        //{
        //    boxTaskInfo = BoxTaskInfo;
        //    warnMsg = "";
        //    bool canOutstore = false;
        //    if (BoxTaskInfo != null)
        //    {
        //        if (!CanPutIn())
        //        {
        //            warnMsg = $"{Name}数量到达极限，不允许放料";
        //            NeedLeave();
        //        }
        //        if (!string.IsNullOrEmpty(BoxTaskInfo.hSerial))
        //        {
        //            if (!BoxTaskInfo.hSerial.Equals(labelInfo.hSerial))
        //            {
        //                warnMsg = ($"{Name}料盘需求单与箱子需求单不符，出库失败：" + param.PosInfo.ToStr());
        //                NeedLeave();
        //            }
        //            else
        //            {
        //                if (labelInfo.side.Equals("T"))
        //                {
        //                    param.ShelfType = Name.Contains("A") ? 1 : 3;
        //                    canOutstore = true;
        //                }
        //                else if (labelInfo.side.Equals("B"))
        //                {
        //                    param.ShelfType = Name.Contains("A") ? 2 : 4;
        //                    canOutstore = true;
        //                }
        //                else
        //                {
        //                    warnMsg = ($"{Name}料盘的面别信息有误:{labelInfo.side}。出库失败：" + param.PosInfo.ToStr());
        //                }
        //            }
        //        }
        //        else//空箱子
        //        {
        //            if (labelInfo.side.Equals("T"))
        //            {
        //                param.ShelfType = Name.Contains("A") ? 1 : 3;
        //                canOutstore = true;
        //            }
        //            else if (labelInfo.side.Equals("B"))
        //            {
        //                param.ShelfType = Name.Contains("A") ? 2 : 4;
        //                canOutstore = true;
        //            }
        //            else
        //            {
        //                warnMsg = ($"{Name}料盘的面别信息有误:{labelInfo.side}。出库失败：" + param.PosInfo.ToStr());
        //            }
        //        }
        //    }

        //    return canOutstore;
        //}
        public void NeedLeave(bool force = false)
        {
            if (force)
            {
                AgvNode.status = NodeStatus.NeedLeave;
                AgvNode.shelf_id = BoxId;
                AgvClient.NeedLeave(AgvNode.id, BoxId);
            }
            else
            {
                if (InHandlingAGVSig())
                {
                    LogUtil.debug(Name + $" 正在进出料，无法设置状态为NeedLeave");
                }
                else
                {
                    AgvClient.NeedLeave(AgvNode.id, BoxId);
                    AgvNode.status = NodeStatus.NeedLeave;
                    AgvNode.shelf_id = BoxId;
                }
            }
        }
        /// <summary>
        /// 正在处理AGV信号
        /// </summary>
        /// <returns></returns>
        bool InHandlingAGVSig()
        {
            return (ProcessShelfOut || ProcessShelfEnter ||
                AgvNode.status.Equals(NodeStatus.RequestEnter) ||
                AgvNode.status.Equals(NodeStatus.RequestLeave) ||
                 AgvNode.status.Equals(NodeStatus.MayEnter) ||
                  AgvNode.status.Equals(NodeStatus.MayLeave) ||
                  recvAGVSig);
        }
        public void SetToNone()
        {
            AgvClient.SetToNone(AgvNode.id, "");
            AgvNode.status = NodeStatus.None;
            AgvNode.shelf_id = BoxId;
        }
        public void MayLeave()
        {
            AgvClient.MayLeave(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.MayLeave;
            AgvNode.shelf_id = BoxId;
        }
        public void MayEnter()
        {
            AgvClient.MayEnter(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.MayEnter;
            AgvNode.shelf_id = BoxId;
        }
        public void FinishEnter()
        {
            AgvClient.FinishEnter(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.FinishEnter;
            AgvNode.shelf_id = BoxId;
        }
        public void FinishLeave()
        {
            AgvClient.FinishLeave(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.FinishLeave;
            AgvNode.shelf_id = BoxId;
        }
        public void Complete()
        {
            AgvClient.SetToComplete(AgvNode.id, BoxId);
            AgvNode.status = NodeStatus.Complete;
            AgvNode.shelf_id = BoxId;
        }
        /// <summary>
        /// 格口的最大数量
        /// </summary>
        public int MaxCntOnSide { get; set; } = ConfigAppSettings.GetIntValue(Setting_Init.MaxCntInBox, 15);
        public void PutReelIn(int side)
        {
            WarnMsg = "";
            bool rtn = false;
            //BoxTaskInfo = SServerManager.GetBoxStatusInfo(config.CID, BoxId);
            bool hasRemain = true;
            if (BoxTaskInfo != null)
            {
                rtn = BoxTaskInfo.boxBCount >= MaxCntOnSide || BoxTaskInfo.boxTCount >= MaxCntOnSide;
                hasRemain = (BoxTaskInfo.remainTaskCount > 0 ? true : false);
            }
            if (AutoClearBoxBind)
            {
                ClearBoxInfo();

            }
            else if (InHandlingAGVSig())
            {

            }
            else if (rtn || !hasRemain)
            {
                NeedLeave();
                LogUtil.info($"{Name}已满/无剩余任务，需要离开。{BoxTaskInfo?.ToStr()??""}");
            }

        }
        public void GetBoxTaskInfo()
        {
            if (ReadBoxId())
            {
                List<BoxTaskInfo> boxInfos = SServerManager.GetOutStateInfo();
                UpdateBoxInfo(boxInfos);
            }
        }
        public void UpdateBoxInfo(List<BoxTaskInfo> boxInfos)
        {
            if (boxInfos == null) return;
            BoxTaskInfo = boxInfos.Find(s => outLet.Equals(s.outlet));
        }
        /// <summary>
        /// 任务信息
        /// </summary>
        public BoxTaskInfo BoxTaskInfo { get; set; }

        public void ClearBoxInfo(bool manual = false)
        {
            try
            {
                if (ReadBoxId())
                {
                    SetToNone();
                    SServerManager.BoxTakeAway(BoxId);
                    BoxTaskInfo = SServerManager.GetBoxStatusInfo(config.CID, BoxId);
                    if (manual)
                        LogUtil.info($"手动清除料箱绑定：{BoxId}");
                    else
                    {
                        LogUtil.info($"自动清除料箱绑定：{BoxId}");
                    }
                }
                BoxTaskInfo = new BoxTaskInfo();
            }
            catch { }


        }
        /// <summary>
        /// 读取周转箱编号
        /// </summary>
        /// <returns></returns>
        public bool ReadBoxId()
        {
            try
            {
                //判断料架的编码是否正确
                RFIDData rfidD = RFIDManager.ReadRFID(RFID_IP);
                BoxId = rfidD.NumStr();
                //发送料架信息给调度系统
                // LogUtil.info(Name + "读取RFID：" + BoxId);
                return rfidD.IsValidated();
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "ReadBoxId出错：", ex);
            }
            return false;
        }
        public bool WaitIo(string ioType, IO_VALUE value, int timeOut, string errName = "")
        {
            try
            {
                return WaitUtil.Wait(timeOut, delegate ()
                {
                    return DIValue(ioType, value);
                }, errName);
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "等待" + ioType + "=" + value + "超时：" + ex.ToString());
                return false;
            }
        }

    }
}