using Rs.Controls;
using Rs.Framework;
using Rs.Motion;
using Rs.Motion.Base;
using Rs.MotionPlat.Commom;
using Rs.MotionPlat.Flow;
using System.Threading;

namespace Rs.AutoDischarge.V3.Flow
{
    enum ETrayTestStep
    {
        等待命令,
        到下料降速位,
        等待到下料降速位,
        到下料结束位,
        等待到下料结束位,
        到下料托盘气缸下方,
        等待到下料托盘气缸下方,
        顶起托盘,
        等待托盘顶起,
        下料完成回原点,
        等待下料完成回原点,
        到上料接料盘位,
        等待到上料接料盘位,
        上料下降到托料盘位,
        等待上料下降到托料盘位,
        上料到原点位,
        等待上料到原点位,
        到上料降速位,
        等待到上料降速位,
        到上料终点位,
        等待到上料终点位
    }

    public enum ETrayStatus
    {
        /// <summary>
        /// 空闲
        /// </summary>
        IDLE,
        /// <summary>
        /// 上料中
        /// </summary>
        Loading,
        /// <summary>
        /// 上料完成
        /// </summary>
        Loaded,
        /// <summary>
        /// 下料中
        /// </summary>
        Unloading,
        /// <summary>
        /// 下料完成
        /// </summary>
        Unloaded,
        /// <summary>
        /// 未知
        /// </summary>
        UnKnown
    }

    public class TrayTest:BaseFlow
    {
        public ETrayStatus Status { get; set; } = ETrayStatus.IDLE;
        public bool NeedUnload = false;
        public bool NeedLoad = false;
        private bool finished = false;
        private bool m_bWholeLoad = true;
        //double baseHeight = -1;
        //private static StockTest instance;
        int stockNo = -1;//料仓编号
        //double trayHeight = -1;
        //public static StockTest Instance
        //{
        //    get
        //    {
        //        if(instance == null)
        //            instance = new StockTest();
        //        return instance;
        //    }
        //}

        public TrayTest(int  _stockNo)
        {
            stockNo = _stockNo;
            StockFlow = AxisControl.GetAxis($"StockFlow{stockNo}");
            StockZ = AxisControl.GetAxis($"StockZ{stockNo}");
           
            //baseHeight = GlobalVar.Instance.GetValue($"Stock{stockNo}BaseHeight");
            //trayHeight = GlobalVar.Instance.GetValue("TrayHeight");
        }

        private ETrayTestStep Step= ETrayTestStep.等待命令;
        bool bStop= false;
        IAxis StockFlow = null;
        IAxis StockZ=null;
        public override void Run()
        {
            
            switch (Step)
            {
                case ETrayTestStep.等待命令:
                    if (StockZ.HomeStatus == EHomeStatus.Finished)
                    {
                        if (NeedUnload)
                        {
                            Status = ETrayStatus.Unloading;
                            //下料
                            IoManager.Instance.WriteOut($"{stockNo}号料仓斜推气缸", 0);
                            Thread.Sleep(200);
                            finished = false;
                            NeedUnload = false;
                            Step = ETrayTestStep.到下料降速位;

                        }
                        else if (NeedLoad)
                        {
                            //上料
                            finished = false;
                            NeedLoad = false;
                            if (m_bWholeLoad)
                                Step = ETrayTestStep.到上料接料盘位;
                            else
                                Step = ETrayTestStep.到上料终点位;
                        }
                        
                    }
                    break;
                case ETrayTestStep.到下料降速位:
                    StockFlow.MoveOffset(SysConfigParam.GetValue<double>("HighSpeedDistance"), GlobalVar.WholeSpeed);
                    Step = ETrayTestStep.等待到下料降速位;
                    break;
                case ETrayTestStep.等待到下料降速位:
                    StockFlow.IsStop(out bStop);
                    if (bStop)
                    {
                        Step = ETrayTestStep.到下料结束位;
                    }
                    break;
                case ETrayTestStep.到下料结束位:
                    StockFlow.MoveOffset(SysConfigParam.GetValue<double>("LowSpeedDistance"), 3);
                    Step = ETrayTestStep.等待到下料结束位;
                    break;
                case ETrayTestStep.等待到下料结束位:
                    if (IoManager.Instance.ReadIn($"{stockNo}号料仓上料位光电检测") == 1)
                    {
                        Thread.Sleep(1000);
                        StockFlow.Stop();
                        Thread.Sleep(200);
                        Step = ETrayTestStep.到下料托盘气缸下方;
                    }
                    break;
                case ETrayTestStep.到下料托盘气缸下方:
                    StockZ.MovePos(SysConfigParam.GetValue<double>($"Stock{stockNo}BaseHeight") - SysConfigParam.GetValue<double>("TrayHeight"), GlobalVar.WholeSpeed);
                    Step = ETrayTestStep.等待到下料托盘气缸下方;
                    break;
                case ETrayTestStep.等待到下料托盘气缸下方:
                    StockZ.IsStop(out bStop);
                    if (bStop)
                    {
                        IoManager.Instance.WriteOut($"{stockNo}号料仓托盘气缸", 0);
                        Thread.Sleep(200);
                        Step = ETrayTestStep.顶起托盘;
                    }
                    break;
                case ETrayTestStep.顶起托盘:
                    StockZ.MoveOffset(10, GlobalVar.WholeSpeed);
                    Step = ETrayTestStep.等待托盘顶起;
                    break;
                case ETrayTestStep.等待托盘顶起:
                    StockZ.IsStop(out bStop);
                    if (bStop)
                    {
                        IoManager.Instance.WriteOut($"{stockNo}号料仓托盘气缸", 1);
                        Thread.Sleep(200);
                        Step = ETrayTestStep.下料完成回原点;
                    }
                    break;
                case ETrayTestStep.下料完成回原点:
                    StockZ.MovePos(0, GlobalVar.WholeSpeed);
                    Step = ETrayTestStep.等待下料完成回原点;
                    break;
                case ETrayTestStep.等待下料完成回原点:
                    StockZ.IsStop(out bStop);
                    if (bStop)
                    {
                        Status = ETrayStatus.Unloaded;
                        finished = true;
                        Step = ETrayTestStep.等待命令;
                        StockZ.Home();
                        Thread.Sleep(200);
                    }
                    break;
                case ETrayTestStep.到上料接料盘位:
                    //把料盘顶起一点点
                    Status = ETrayStatus.Loading;
                    StockZ.MovePos(SysConfigParam.GetValue<double>($"Stock{stockNo}BaseHeight"), GlobalVar.WholeSpeed);
                    Step = ETrayTestStep.等待到上料接料盘位;
                    break;
                case ETrayTestStep.等待到上料接料盘位:
                    StockZ.IsStop(out bStop);
                    if (bStop)
                    {
                        IoManager.Instance.WriteOut($"{stockNo}号料仓托盘气缸",0);
                        Thread.Sleep(500);
                        Step = ETrayTestStep.上料下降到托料盘位;
                    }
                    break;
                case ETrayTestStep.上料下降到托料盘位:
                    StockZ.MovePos(SysConfigParam.GetValue<double>($"Stock{stockNo}BaseHeight") - (SysConfigParam.GetValue<double>("TrayHeight")), GlobalVar.WholeSpeed);
                    Step = ETrayTestStep.等待上料下降到托料盘位;
                    break;
                case ETrayTestStep.等待上料下降到托料盘位:
                    StockZ.IsStop(out bStop);
                    if (bStop)
                    {
                        Thread.Sleep(500);
                        IoManager.Instance.WriteOut($"{stockNo}号料仓托盘气缸", 1);
                        Thread.Sleep(500);
                        Step = ETrayTestStep.上料到原点位;
                    }
                    break;
                case ETrayTestStep.上料到原点位:
                    StockZ.MovePos(0, GlobalVar.WholeSpeed);
                    Step = ETrayTestStep.等待上料到原点位;
                    break;
                case ETrayTestStep.等待上料到原点位:
                    StockZ.IsStop(out bStop);
                    if (bStop)
                    {
                        StockZ.Home();
                        Step = ETrayTestStep.到上料降速位;
                    }
                    break;
                case ETrayTestStep.到上料降速位:
                    StockFlow.MoveOffset(SysConfigParam.GetValue<double>("HighSpeedDistance")*-1, GlobalVar.WholeSpeed);
                    Step = ETrayTestStep.等待到上料降速位;
                    break;
                case ETrayTestStep.等待到上料降速位:
                    StockFlow.IsStop(out bStop);
                    if (bStop)
                    {
                        Step = ETrayTestStep.到上料终点位;
                    }
                    break;
                case ETrayTestStep.到上料终点位:
                    StockFlow.MoveOffset(-1* SysConfigParam.GetValue<double>("LowSpeedDistance"), 3);
                    Step = ETrayTestStep.等待到上料终点位;
                    break;
                case ETrayTestStep.等待到上料终点位:
                    if (IoManager.Instance.ReadIn($"{stockNo}号料仓料盘到位光电检测") == 1)
                    {
                        switch (stockNo)
                        {
                            case 1:
                                GlobalTray.Empty1Tray.ResetTray();
                                GlobalTray.Empty1Tray.Clear();
                                break;
                            case 2:
                                GlobalTray.InputTray.ResetTray();
                                GlobalTray.InputTray.Fill();
                                break;
                            case 3:
                                GlobalTray.OkTary.ResetTray();
                                GlobalTray.OkTary.Clear();
                                break;
                            case 4:
                                GlobalTray.NgTray.ResetTray();
                                GlobalTray.NgTray.Clear();
                                break;
                            case 5:
                                GlobalTray.MultiTray.ResetTray();
                                GlobalTray.MultiTray.Clear();
                                break;
                            case 6:
                                GlobalTray.Empty2Tray.ResetTray();
                                GlobalTray.Empty2Tray.Clear();
                                break;
                            default:
                                break;
                        }
                        Thread.Sleep(500);
                        StockFlow.Stop();
                        Thread.Sleep(200);
                        IoManager.Instance.WriteOut($"{stockNo}号料仓斜推气缸", 1);
                        Thread.Sleep(200);
                        finished = true;
                        Status = ETrayStatus.Loaded;
                        Step = ETrayTestStep.等待命令;
                        Thread.Sleep(200);
                    }
                    break;
            }
        }

        
        public void Unload()
        {
            finished = false;
            NeedUnload = true;
        }

        public void Load(bool bWholeLoad)
        {
            m_bWholeLoad = bWholeLoad;
            finished = false;
            NeedLoad = true;
           
        }

        public bool Finished()
        {
            return finished;
        }

        public bool IsLastTray()
        {
            if(IoManager.Instance.ReadIn($"{stockNo}号料仓最后一盘")==1)
            {
                return true;
            }
            return false;
        }

        public ETrayStatus GetStatus()
        {
            return Status;
        }
    }
}