using Microsoft.Extensions.Logging;
using SlnMesnac.Repository.service;
using SlnMesnac.TouchSocket;
using SlnMesnac.TouchSocket.Entity;
using System;
using System.Collections.Generic;
using System.Text;

namespace SlnMesnac.Business.@base
{
    /// <summary>
    /// 视觉系统业务类
    /// </summary>
    public class VisionBusiness
    {
        private ILogger<VisionBusiness> _logger;
        private static VisionBusiness instance;
        private TcpServer _tcpServer;

        public VisionBusiness(ILogger<VisionBusiness> logger, TcpServer tcpServer)
        {
            _logger = logger;
            _tcpServer = tcpServer;

            //视觉系统回复状态
            _tcpServer.ReceiveVisionSysStateEvent += VisionStateRequest;
            //视觉系统回复开始码垛
            _tcpServer.ReceiveVisionStartWorkEvent += GetVisionWorkState;
            //视觉系统通知一次码垛完成结果
            _tcpServer.ReceiveStackWorkDoneEvent += StackResultSend;
            //视觉系统通知人工异常处理完成
            _tcpServer.ReceiveManualExceptionDealDoneEvent += GetManualExceptionDealDone;
            //视觉系统回复复位结果
            _tcpServer.ReceiveStackRobotResetEvent += GetResetResult;
        }

        public static VisionBusiness GetInstance(ILogger<VisionBusiness> logger, TcpServer tcpServer)
        {
            if (instance == null)
            {
                instance = new VisionBusiness(logger, tcpServer);
            }
            return instance;
        }

        /// <summary>
        /// AMR就绪，请求视觉开始工作
        /// </summary>
        public void RequestVisionStartWork(StackState state, string id)
        {
            _tcpServer.SendAMRRequestVisionStartWork(new byte[1] { (byte)state }, id);
        }

        /// <summary>
        /// 码垛结束，请求视觉系统复位
        /// </summary>
        public void RequestVisionReplace(string port)
        {
            _tcpServer.SendStackOverRequestVisionSysReplace(port);
            VDCount = 1;
            VACount = 0;
            TotalJudge = false;
        }

        /// <summary>
        /// 上位机调度系统每隔固定时间，请求视觉系统状态
        /// </summary>
        public void VisionStateRequest(TcpVisionEntity entity, string id)
        {
            if (entity.DataLength == 2)
            {

            }
            //Thread.Sleep(1000);
            //SendRequestVisionSysState(id);
        }

        /// <summary>
        /// 接受开始工作状态
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="id"></param>
        private void GetVisionWorkState(TcpVisionEntity entity, string id)
        {
            if (entity.DataLength == 1)
            {
                if (entity.DataBytes[0] == 0x00)
                {
                    _logger.LogInformation($"视觉系统收到开始工作状态：正常开始工作");
                }
                else if (entity.DataBytes[0] == 0x01)
                {
                    _logger.LogError($"视觉系统收到开始工作状态：异常不能开始工作");
                }
                else
                {
                    _logger.LogError($"视觉系统收到开始工作状态：返回未知代码");
                }
            }
            else
            {
                _logger.LogError($"视觉系统收到开始工作状态：数据返回格式错误");
            }
        }

        int VDCount = 1;
        int VACount = 0;
        int VDTotal = 8;
        int VATotal = 6;
        bool Vjudge = true;
        bool VNow = true;
        public bool TotalJudge = false;
        /// <summary>
        /// 接受码垛结果
        /// </summary>
        public void StackResultSend(TcpVisionEntity entity, string id)
        {
            if (entity.DataLength == 1)
            {
                if (entity.DataBytes[0] == 0x00)
                {
                    _logger.LogInformation($"视觉系统一次码垛结束，码垛完成 Deliver:{VDCount} AMR:{VACount}");
                    //上位机回复收到码垛结果
                    _tcpServer.SendReplayStackResult(id);
                    //这里写是否继续下一次码垛的判断条件
                    if ((VDCount < VDTotal && Vjudge == true && TotalJudge == true) || (VACount < VATotal && Vjudge == false && TotalJudge == true))
                    {
                        //如果码垛没结束继续发下一次的码垛信号
                        if (Vjudge) //这里写向哪个机器人码垛的判断条件
                        {
                            //发送向搬运机器人（AGVDeliver）码垛的信号
                            RequestVisionStartWork(StackState.AGVNoPositioning, id);
                            _logger.LogInformation("下一次码垛开始，方向：搬运机器人");
                            VDCount++;
                            VNow = true;
                            if (VDCount >= VDTotal)
                            {
                                Vjudge = false;
                            }
                        }
                        else
                        {
                            //发送向复合机器人（AMR）码垛的信号
                            RequestVisionStartWork(StackState.AMRNoPositioning, id);
                            _logger.LogInformation("下一次码垛开始，方向：复合机器人");
                            VACount++;
                            VNow = false;
                            if (VACount >= VATotal)
                            {
                                Vjudge = true;
                            }
                        }
                    }
                    else
                    {
                        //如果码垛结束就请求复位
                        RequestVisionReplace(id);
                        _logger.LogInformation("本次码垛结束，请求复位");
                    }
                }
                else if (entity.DataBytes[0] == 0x01)
                {
                    _logger.LogError($"视觉系统一次码垛结束，码垛过程失败 Deliver:{VDCount} AMR:{VACount}");
                    //如果码垛没结束继续发下一次的码垛信号
                    if (VNow) //这里写向哪个机器人码垛的判断条件
                    {
                        //发送向搬运机器人（AGVDeliver）码垛的信号
                        RequestVisionStartWork(StackState.AGVNoPositioning, id);
                        _logger.LogInformation("下一次码垛开始，方向：搬运机器人");
                    }
                    else
                    {
                        //发送向复合机器人（AMR）码垛的信号
                        RequestVisionStartWork(StackState.AMRNoPositioning, id);
                        _logger.LogInformation("下一次码垛开始，方向：复合机器人");
                    }
                }
                else if (entity.DataBytes[0] == 0x02)
                {
                    _logger.LogError($"视觉系统一次码垛结束，码垛检查失败");
                }
                else
                {
                    _logger.LogError($"视觉系统一次码垛结束，未知返回代码");
                }
            }
            else
            {
                _logger.LogError($"视觉系统一次码垛结束，返回数据格式错误");
            }
        }

        /// <summary>
        /// 收到视觉系统复位结果
        /// </summary>
        public void GetResetResult(TcpVisionEntity entity, string id)
        {
            if(entity.DataLength == 0x01)
            {
                if (entity.DataBytes[0] == 0x00)
                {
                    _logger.LogInformation($"视觉系统码垛结束，复位正常");
                }
                else if (entity.DataBytes[0] == 0x01)
                {
                    _logger.LogError($"视觉系统码垛结束，复位异常");
                }
                else
                {
                    _logger.LogError($"视觉系统码垛结束，未知返回代码");
                }
            }
            else
            {
                _logger.LogError($"视觉系统码垛结束，返回数据格式错误");
            }
        }

        /// <summary>
        /// 人工异常处理完成并更新计数
        /// </summary>
        public void GetManualExceptionDealDone(TcpVisionEntity entity, string id)
        {
            _tcpServer.SendReplyGetManualException(id);
        }
    }
}