using Common;
using DeviceLibrary.Models.Service.Request;
using DeviceLibrary.Models.Service.Response;
using LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DeviceLibrary.Models
{
    /// <summary>
    /// 电梯信息
    /// </summary>
    public class LiftInfo
    {
        /// <summary>
        /// 电梯标识
        /// </summary>
        public string liftId { get; set; } = "";
        /// <summary>
        /// 电梯状态信息
        /// </summary>
        public Status Status { get; set; }
        /// <summary>
        /// 电梯状态
        /// </summary>
        public LiftState State { get; private set; }
        /// <summary>
        /// 运行状态
        /// </summary>
        public LiftRunState RunState { get; private set; }
        /// <summary>
        /// 使用该电梯的的系统
        /// </summary>
        public List<ClientInfo> Clients { get; set; }
        public LiftInfo(string liftId)
        {
            Status = new Status();
            Clients = new List<ClientInfo>();
            this.liftId = liftId;
        }

        private static object locObj = new object();

        /// <summary>
        /// 设置电梯状态
        /// </summary>
        /// <param name="occupyinfo"></param>
        void SetState(LiftState liftState)
        {
            if (Monitor.TryEnter(locObj, 500))
            {
                try
                {
                    this.State = liftState;
                }
                finally
                {
                    Monitor.Exit(locObj);
                }
            }

        }


        /// <summary>
        /// 电梯是否空闲。空闲则电梯可被控制
        /// </summary>
        /// <returns></returns>
        public bool IsIdle(out string msg)
        {
            msg = "ok";

            if (Monitor.TryEnter(locObj, 500))
            {
                try
                {

                    if (Status.Occupied)
                    {
                        msg = "Occupied";
                        return false;
                    }

                    if (!State.Equals(LiftState.Idle))
                    {
                        msg = State.ToString();
                        return false;
                    }

                }
                finally
                {
                    Monitor.Exit(locObj);
                }
            }
            else
            {
                msg = "Get State TimeOut";
                return false;
            }

            return true;
        }
        /// <summary>
        /// 是否具有控制电梯的权力
        /// </summary>
        /// <param name="doorInfo"></param>
        /// <returns></returns>
        private bool CanControl(DoorInfo doorInfo)
        {
            if (!this.liftId.Equals(doorInfo.liftId))
                return false;
            if (IsSrcClient(doorInfo))
                return true;
            if (IsDesClient(doorInfo))
                return true;
            return false;
        }
        public string OccupiedInfo()
        {
            return $"电梯{liftId}占用[{Status.Occupied}]信息:{Status.sourceClient}[{Status.sourceFloor}],{Status.destinationClient}[{Status.destinationFloor}]";
        }
        /// <summary>
        /// 是否是起始端
        /// </summary>
        /// <param name="doorInfo"></param>
        /// <returns></returns>
        private bool IsSrcClient(DoorInfo doorInfo)
        {
            if (Status.sourceClient.Equals(doorInfo.sourceClient) && Status.sourceFloor.Equals(doorInfo.sourceFloor))
                return true;
            return false;
        }
        /// <summary>
        /// 是否是目的端
        /// </summary>
        /// <param name="doorInfo"></param>
        /// <returns></returns>
        private bool IsDesClient(DoorInfo doorInfo)
        {
            if (Status.destinationClient.Equals(doorInfo.sourceClient) && Status.destinationFloor.Equals(doorInfo.sourceFloor))
                return true;
            return false;
        }

        /// <summary>
        /// 请求使用电梯
        /// </summary>
        /// <param name="door"></param>
        /// <returns>true:请求成功</returns>
        public bool RequestUse(SendInInfo lift, out string msg)
        {
            if (IsIdle(out msg))
            {
                ClientInfo clientInfo = Clients.Find(s => s.sourceClient.Equals(lift.destinationClient));
                if (clientInfo == null)
                {
                    msg = $"目标AGV系统标识不存在:{lift.destinationClient}";
                    return false;
                }
                if (!clientInfo.Online)
                {
                    msg = $"目标AGV系统标识离线:{lift.destinationClient}";
                    return false;
                }

                if (!clientInfo.sourceClient.Equals("NEOTEL-1F")&& !clientInfo.hasIdleAgv)
                {
                    msg = $"目标AGV系统无可用Agv:{lift.destinationClient}";
                    return false;
                }
                if (IOManager.IOValue($"{liftId}{SettingString._AGVRequest}").Equals(IO_VALUE.HIGH))
                {
                    if (IOManager.IOValue($"{liftId}{SettingString._Response}").Equals(IO_VALUE.HIGH) &&
                        IOManager.IOValue($"{liftId}{SettingString._DoorOpen}").Equals(IO_VALUE.HIGH))
                    {
                        OpenAGVLeave(5);
                        LogUtil.info($"{lift} 上一次异常退出，发送AGV离开清除异常状态！");
                        return false;
                    }
                    if (IOManager.IOValue($"{liftId}{SettingString._Response}").Equals(IO_VALUE.HIGH))
                    {
                        SetState(LiftState.Busy);
                        Status.Set(lift);
                        msg = "ok";
                        return true;
                    }
                }
                else
                {
                    //if (IOManager.IOValue($"{liftId}{SettingString._Response}").Equals(IO_VALUE.HIGH))
                    //{
                    //    if (IOManager.IOValue($"{liftId}{SettingString._DoorOpen}").Equals(IO_VALUE.HIGH))
                    //    {
                    //        OpenAGVLeave(5);
                    //        LogUtil.info($"{lift} 上一次异常退出，发送AGV离开清除异常状态！");
                    //        return false;
                    //    }
                    //}
                    if (OpenAGVRequest(true))
                    {
                        SetState(LiftState.Busy);
                        Status.Set(lift);
                        OpenAGVLeave(5);
                        msg = "ok";
                        return true;
                    }
                    else
                    {
                        msg = "打开电梯请求超时";
                    }

                }
            }
            else
            {
                msg = "电梯被占用";
            }
            return false;
        }

        /// <summary>
        /// AGV离开
        /// </summary>
        /// <returns></returns>
        public bool AGVLeave(DoorInfo doorInfo)
        {
            if (CanControl(doorInfo))
            {

                if (IsDesClient(doorInfo))
                {
                    //关闭送料信号
                    CloseSendFloor(doorInfo);
                    //AGV离开信号，使得门关
                    CloseDoor();
                    Status.Clear();
                    SetState(LiftState.Idle);
                    //是否继续使用电梯
                    OpenAGVRequest(doorInfo.continueUse);
                    LogUtil.info($"AGV离开，【{doorInfo}】取出电梯内的产品,清除电梯占用");
                }

                if (IsSrcClient(doorInfo))
                {
                    //关闭呼叫信号
                    CloseCallFloor(doorInfo);
                    //AGV离开信号，使得门关
                    CloseDoor();
                    if (!Status.destinationFloor.Equals(-1))
                    {
                        RunToFloor(Status.destinationFloor, doorInfo);
                        LogUtil.info($"AGV离开，【{doorInfo}】将产品送入电梯");
                    }
                }
                return true;
            }
            return false;
        }
        /// <summary>
        /// 运行到指定楼层（送料信号）
        /// </summary>
        /// <param name="floor"></param>
        private void RunToFloor(int floor, DoorInfo door)
        {
            Task.Factory.StartNew(() =>
            {
                switch (floor)
                {
                    //case -1:
                    //    IOManager.CIOMove($"{liftId}{SettingString._RunToNegativeFirst}", IO_VALUE.HIGH);
                    //    break;
                    case 1:
                        IOManager.CIOMove($"{liftId}{SettingString._RunToFirst}", IO_VALUE.HIGH);
                        break;

                    //case 2:
                    //    IOManager.CIOMove($"{liftId}{SettingString._RunToSecond}", IO_VALUE.HIGH);
                    //    break;

                    case 3:
                        IOManager.CIOMove($"{liftId}{SettingString._RunToThird}", IO_VALUE.HIGH);
                        break;
                    case 4:
                        IOManager.CIOMove($"{liftId}{SettingString._RunToFourth}", IO_VALUE.HIGH);
                        break;
                }
                Thread.Sleep(1000);
                DateTime dateTime1 = DateTime.Now;
                //等待运行信号亮
                while (!CheckIsInRun())
                {
                    if ((DateTime.Now - dateTime1).TotalSeconds > 30)
                    {
                        LogUtil.error("检查AGV送料信号有效：等待电梯运行信号超时");
                        break;
                    }
                    switch (floor)
                    {
                        //case -1:
                        //    IOManager.CIOMove($"{liftId}{SettingString._RunToNegativeFirst}", IO_VALUE.HIGH);
                        //    break;
                        case 1:
                            IOManager.CIOMove($"{liftId}{SettingString._RunToFirst}", IO_VALUE.HIGH);
                            break;

                        //case 2:
                        //    IOManager.CIOMove($"{liftId}{SettingString._RunToSecond}", IO_VALUE.HIGH);
                        //    break;

                        case 3:
                            IOManager.CIOMove($"{liftId}{SettingString._RunToThird}", IO_VALUE.HIGH);
                            break;
                        case 4:
                            IOManager.CIOMove($"{liftId}{SettingString._RunToFourth}", IO_VALUE.HIGH);
                            break;
                    }
                    Thread.Sleep(1000);
                }
                LogUtil.info($"送料信号：运行到{floor}层");
                CloseSendFloor(door);
            });
        }

        /// <summary>
        /// 运行到指定楼层（呼叫信号）
        /// </summary>
        /// <param name="floor"></param>
        private void FloorCall(int floor)
        {
            switch (floor)
            {
                //case -1:
                //    IOManager.CIOMove($"{liftId}{SettingString._RunToNegativeFirst}", IO_VALUE.HIGH);
                //    break;
                case 1:
                    IOManager.CIOMove($"{liftId}{SettingString._FirstCall}", IO_VALUE.HIGH);
                    break;

                //case 2:
                //    IOManager.CIOMove($"{liftId}{SettingString._RunToSecond}", IO_VALUE.HIGH);
                //    break;

                case 3:
                    IOManager.CIOMove($"{liftId}{SettingString._ThirdCall}", IO_VALUE.HIGH);
                    break;
                case 4:
                    IOManager.CIOMove($"{liftId}{SettingString._FourthCall}", IO_VALUE.HIGH);
                    break;
            }
            //Thread.Sleep(5000);
            ////关闭呼叫信号
            //CloseCallFloor();
        }
        /// <summary>
        /// AGV呼叫
        /// </summary>
        /// <param name="occupyinfo"></param>
        /// <returns></returns>
        public bool AGVCall(DoorInfo doorInfo)
        {
            if (CanControl(doorInfo))
            {
                FloorCall(doorInfo.sourceFloor);
                LogUtil.info($"【{doorInfo}】呼叫电梯运行到{doorInfo.sourceFloor}层");
                return true;
            }
            return false;
        }

        public void UpdateClient(ClientStatus clientStatus)
        {
            if (clientStatus == null)
                return;
            if (!liftId.Equals(clientStatus.liftId))
                return;
            int floor = -1;
            if (IOManager.IOValue($"{liftId}{SettingString._AtFirst}").Equals(IO_VALUE.HIGH))
            {
                floor = 1;
            }
            else if (IOManager.IOValue($"{liftId}{SettingString._AtThird}").Equals(IO_VALUE.HIGH))
            {
                floor = 3;
            }
            else if (IOManager.IOValue($"{liftId}{SettingString._AtFourth}").Equals(IO_VALUE.HIGH))
            {
                floor = 4;
            }
            Status.floor = floor;

            if (IOManager.IOValue($"{liftId}{SettingString._DoorOpen}").Equals(IO_VALUE.HIGH))
            {
                Status.door = "opened";
                RunState = LiftRunState.DoorOpen;
                //关闭呼叫信号
                CloseCallFloor();
            }
            else
            {
                Status.door = "closed";
            }

            if (CheckIsInRun())
            {
                RunState = LiftRunState.Running;
            }
            else if (CheckIsFault())
            {
                RunState = LiftRunState.Fault;
            }

            ClientInfo clientInfo = Clients.Find(s => s.sourceClient.Equals(clientStatus.sourceClient));
            if (clientInfo == null)
            {
                Clients.Add(new ClientInfo(clientStatus.sourceClient, clientStatus.hasIdleAgv));
            }
            else
            {
                clientInfo.SetInfo(clientStatus.sourceClient, clientStatus.hasIdleAgv);
            }
        }
        private void CloseSendFloor(DoorInfo doorInfo)
        {
            IOManager.CIOMove($"{liftId}{SettingString._RunToFirst}", IO_VALUE.LOW);
            IOManager.CIOMove($"{liftId}{SettingString._RunToThird}", IO_VALUE.LOW);
            IOManager.CIOMove($"{liftId}{SettingString._RunToFourth}", IO_VALUE.LOW);
            LogUtil.info($"【{doorInfo}】:关闭所有送料信号");
        }
        /// <summary>
        /// 等待运行信号亮或者关信号
        /// </summary>
        /// <returns></returns>
        private bool CheckAGVLeaveOK()
        {
            return !CheckDoorOpen() || CheckIsInRun();
        }
        private bool CheckDoorOpen()
        {
            return IOManager.IOValue($"{liftId}{SettingString._DoorOpen}").Equals(IO_VALUE.HIGH);
        }
        private bool CheckAgvLeave()
        {
            return IOManager.IOValue($"{liftId}{SettingString._AGVLeave}").Equals(IO_VALUE.HIGH);
        }
        private bool CheckAgvRequest()
        {
            return IOManager.IOValue($"{liftId}{SettingString._AGVRequest}").Equals(IO_VALUE.HIGH);
        }
        private bool CheckIsInRun()
        {
            return IOManager.IOValue($"{liftId}{SettingString._InRun}").Equals(IO_VALUE.HIGH);
        }
        private bool CheckIsFault()
        {
            return IOManager.IOValue($"{liftId}{SettingString._InFault}").Equals(IO_VALUE.HIGH);
        }
        private void OpenAGVLeave(bool open)
        {
            if (open)
            {
                IOManager.IOMove($"{liftId}{SettingString._AGVLeave}", IO_VALUE.HIGH);
                LogUtil.info($"【{liftId}】打开AGV离开信号");
            }
            else
            {
                IOManager.IOMove($"{liftId}{SettingString._AGVLeave}", IO_VALUE.LOW);
                LogUtil.info($"【{liftId}】关闭AGV离开信号");
            }
        }
        private void OpenAGVLeave(int second)
        {
            Task task = Task.Factory.StartNew(() =>
            {
                OpenAGVLeave(true);
                Thread.Sleep(second * 1000);
                OpenAGVLeave(false);
            });
            task.Wait(20000);
        }
        private void CloseDoor()
        {
            Task task = Task.Factory.StartNew(() =>
            {
                OpenAGVLeave(true);
                DateTime dateTime = DateTime.Now;
                //门关信号
                while (CheckDoorOpen() && (DateTime.Now - dateTime).TotalMinutes < 1)
                {
                    if ((DateTime.Now - dateTime).TotalSeconds > 3)
                    {
                        IOManager.CIOMove($"{liftId}{SettingString._AGVLeave}", IO_VALUE.HIGH);
                    }
                    Thread.Sleep(1000);
                }
                dateTime = DateTime.Now;
                while (!CheckAgvLeave() && (DateTime.Now - dateTime).TotalMinutes < 1)
                {
                    IOManager.CIOMove($"{liftId}{SettingString._AGVLeave}", IO_VALUE.HIGH);
                    Thread.Sleep(500);
                }
                Thread.Sleep(5000);
                OpenAGVLeave(false);
            });
            task.Wait(60000);
        }
        private bool OpenAGVRequest(bool open)
        {
            DateTime dateTime = DateTime.Now;
            bool rtn = false;
            if (open)
            {
                IOManager.IOMove($"{liftId}{SettingString._AGVRequest}", IO_VALUE.HIGH);
                while (!CheckAgvRequest() && (DateTime.Now - dateTime).TotalSeconds < 5)
                {
                    IOManager.CIOMove($"{liftId}{SettingString._AGVRequest}", IO_VALUE.HIGH);
                    Thread.Sleep(500);
                }
                rtn = CheckAgvRequest();
                LogUtil.info($"{liftId}打开AGV请求信号结果：{rtn}");
            }
            else
            {
                IOManager.IOMove($"{liftId}{SettingString._AGVRequest}", IO_VALUE.LOW);
                while (CheckAgvRequest() && (DateTime.Now - dateTime).TotalSeconds < 5)
                {
                    IOManager.CIOMove($"{liftId}{SettingString._AGVRequest}", IO_VALUE.LOW);
                    Thread.Sleep(500);
                }
                rtn = !CheckAgvRequest();
                LogUtil.info($"{liftId}关闭AGV请求信号结果：{rtn}");
            }
            return rtn;
        }
        private void CloseCallFloor(DoorInfo doorInfo)
        {
            IOManager.CIOMove($"{liftId}{SettingString._FirstCall}", IO_VALUE.LOW);
            IOManager.CIOMove($"{liftId}{SettingString._ThirdCall}", IO_VALUE.LOW);
            IOManager.CIOMove($"{liftId}{SettingString._FourthCall}", IO_VALUE.LOW);
            LogUtil.info($"【{doorInfo}】:关闭所有呼叫信号");
        }
        private void CloseCallFloor()
        {
            IOManager.CIOMove($"{liftId}{SettingString._FirstCall}", IO_VALUE.LOW);
            IOManager.CIOMove($"{liftId}{SettingString._ThirdCall}", IO_VALUE.LOW);
            IOManager.CIOMove($"{liftId}{SettingString._FourthCall}", IO_VALUE.LOW);
        }
    }
    /// <summary>
    /// 电梯状态
    /// </summary>
    public enum LiftState
    {
        /// <summary>
        /// 空闲
        /// </summary>
        Idle,
        /// <summary>
        /// 忙碌
        /// </summary>
        Busy,
        /// <summary>
        /// 手动
        /// </summary>
        Manual
    }
    /// <summary>
    /// 电梯运行状态
    /// </summary>
    public enum LiftRunState
    {
        /// <summary>
        /// 就绪
        /// </summary>
        Ready,
        /// <summary>
        /// 门已开
        /// </summary>
        DoorOpen,
        /// <summary>
        /// 运行中
        /// </summary>
        Running,
        /// <summary>
        /// 故障
        /// </summary>
        Fault
    }
}