agrobot_base/AgroBase/AgroBase/Services/Operadores/ManagerWorkerService.cs

using AgroBase.Models;
using AgroBase.Models.Operadores;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using static AgroBase.Models.Operadores.OperadoresModels;

namespace AgroBase.Services.Operadores
{
    public class ManagerWorkerService : IWorkerModel
    {
        public ManagerWorkerModel DadosLeitura = new ManagerWorkerModel();
        public SaudeWorkerModel Saude { get; set; } = new SaudeWorkerModel();

        private bool DebugMode = true;

        public void MostrarLog(string message, int limite = 500)
        {
            if (DebugMode)
            {
                Console.WriteLine($"[ManagerWorker] {message.Substring(0, Math.Min(limite, message.Length))}{(message.Length > limite ? "..." : "")}");
            }
        }

        public async Task<bool> IniciarProcessamento()
        {
            RedisService.Subscribe(CmdKey.ManagerWorkerTx, RedisCallback);

            DadosLeitura.IniciadoEm = DateTime.Now;
            DadosLeitura.Iniciado = true;

            bool pronto() => DadosLeitura.Pronto;
            await FuncoesGlobais.AguardarCondicaoAsync(pronto, 5000);
            if (pronto())
            {
                MostrarLog("Processamento iniciado com sucesso");
                return true;
            }

            MostrarLog("Timeout ao iniciar script");
            DadosLeitura.ReiniciarEstado();
            return false;
        }

        private void AtualizarControle(Dictionary<string, object> dictParams)
        {
            if (dictParams == null)
                return;

            ManagerWorkerMessageResponseComandoModel novoComando = null;

            try
            {
                dictParams.TryGetValue("angulo_sp", out object _angulo);
                dictParams.TryGetValue("velocidade_sp", out object _velocidade);
                dictParams.TryGetValue("em_freio", out object _em_freio);
                dictParams.TryGetValue("tipo_movimento_direcional", out object _movimento);
                dictParams.TryGetValue("simulacao", out object _simulacao);
                dictParams.TryGetValue("heartbeat", out object _heartbeat);
                novoComando = new ManagerWorkerMessageResponseComandoModel()
                {
                    angulo = Convert.ToDouble(_angulo),
                    percentual_velocidade = Convert.ToDouble(_velocidade),
                    em_freio = Convert.ToBoolean(_em_freio),
                    tipo_movimento = (Enums.TipoMovimentoDirecional)Convert.ToInt32(_movimento),
                    simulacao = JsonConvert.DeserializeObject<List<double[]>>((_simulacao ?? "").ToString()),
                    heartbeat = Convert.ToInt32(_heartbeat)
                };
            }
            catch (Exception ex)
            {
                MostrarLog($"Erro ao receber novo comando: {ex.Message}");
            }

            var _Controle = Variaveis.OperacaoEmAndamento.Controle;
            bool comandoMudou = (_Controle.Angulo != novoComando.angulo || _Controle.PercentualVelocidadeSP != novoComando.percentual_velocidade || _Controle.TipoMovimento != novoComando.tipo_movimento || _Controle.EmFreio != novoComando.em_freio);
            if (novoComando != null && comandoMudou)
            {
                _Controle.Angulo = novoComando.angulo;
                _Controle.TipoMovimento = novoComando.tipo_movimento;
                _Controle.PercentualVelocidadeSP = novoComando.percentual_velocidade;
                _Controle.EmFreio = novoComando.em_freio;
                _Controle.SimulacaoMPC = novoComando.simulacao?.Select(x => new MPCSimulacaoModel() { latitude = x[0], longitude = x[1], orientacao = x[2] }).ToList() ?? new List<MPCSimulacaoModel>();
                Variaveis.OperacaoEmAndamento.AtualizaInformacoesControleOperacao();
            }
        }

        public void RedisCallback(string mensagem)
        {
            try
            {
                var comando = JsonConvert.DeserializeObject<ComandoRedis>(mensagem);

                var cmd = (ManagerWorkerCommandType)comando.cmd;

                switch (cmd)
                {
                    case ManagerWorkerCommandType.ScriptCarregado:
                        DadosLeitura.Pronto = true;
                        DadosLeitura.ProntoEm = DateTime.Now;
                        MostrarLog($"Comando recebido: cmd = {cmd.ToString()}");
                        break;
                    
                    case ManagerWorkerCommandType.EnviarDadosControle:
                        if (Variaveis.OperacaoEmAndamento.Controle.MovimentoAutomatico)
                        {
                            AtualizarControle(comando.@params);
                        }
                        break;
                    
                    case ManagerWorkerCommandType.FinalizarOperacao:
                        Task.Run(async () =>
                        {
                            await Variaveis.OperacaoEmAndamento.FinalizarOperacao();
                        });
                        break;

                    default:
                        MostrarLog($"Comando não reconhecido: {comando.cmd}");
                        break;
                }
            }
            catch (Exception ex)
            {
                MostrarLog($"Erro ao deserializar resposta: {ex.Message}");
            }
            finally
            {
                DadosLeitura.UltimaMensagem = DateTime.Now;
            }
        }

        public void AtualizarSaude()
        {
            Saude = OperadoresModels.AtualizarSaude(CtxKey.DadosManagerWorker);
        }

    }
}