agrobot_base/AgroBase/OperationControl/Models/Variaveis.cs

using AgroBase.Models;
using Newtonsoft.Json;
using System.Diagnostics;
using System.Windows;
using OperationControl.Services;

namespace OperationControl.Models
{
    public class Variaveis
    {
        public static MqttService MqttService;
        public static GpsService GpsService;

        public static void MostrarLog(string message)
        {
            Debug.WriteLine(message);
        }

        public static async void IniciarMQTT()
        {
            if (MqttService != null)
            {
                foreach (var topico in MqttService.Topicos.Where(x => x.Inscrever))
                {
                    await MqttService.UnsubscribeAsync(topico);
                }
                MqttService.Topicos.Clear();
            }

            MqttService = new MqttService("localhost", 1883, "base", true, msg => MostrarLog($"[MQTT localhost:1883] - {msg}"));

            await MqttService.AdicionarNovoTopico(VariaveisControleOperacao.TopicoMqttRTCM);
            await MqttService.AdicionarNovoTopico(VariaveisControleOperacao.TopicoMqttDispositivos, true, 1, async (message) =>
            {
                try
                {
                    string device_id = message.Mensagem;
                    VariaveisControleOperacao.AdicionarNovoRoverNaRede(message.Mensagem);
                }
                catch (Exception ex)
                {
                    MostrarLog($"Erro ao deserializar ping do rover: {ex.Message}");
                }
            });

            GpsService = new GpsService();
        }
    
    }

    public class VariaveisControleOperacao
    {
        public static double LeverArmFrontal { get; } = 0.0;
        public static double LeverArmLateral { get; } = 0.0;

        public static readonly string BaseMarkerID = "BASE";
        public static string TopicoMqttDispositivos { get; } = $"agrobot/v1/base/devices";
        public static string TopicoMqttPosicao { get; } = $"agrobot/v1/base/position";
        public static string TopicoMqttRTCM { get; } = $"agrobot/v1/base/rtcm";
        private static readonly object _RoversLock = new object();
        public static Dictionary<string, OperacaoSensoriamentoLogModel> RoversNaRede { get; set; } = new Dictionary<string, OperacaoSensoriamentoLogModel>();
        public static string SelectedRoverId { get; set; } = BaseMarkerID;
        
        public static async void AdicionarNovoRoverNaRede(string device_id)
        {
            if (string.IsNullOrEmpty(device_id))
                return;

            bool rover_ja_adicionado = false;
            lock (_RoversLock)
            {
                rover_ja_adicionado = RoversNaRede.ContainsKey(device_id);
            }

            if (!rover_ja_adicionado)
            {
                lock (_RoversLock)
                {
                    RoversNaRede.Add(device_id, new OperacaoSensoriamentoLogModel() { Momento = DateTime.Now });
                }

                await Variaveis.MqttService.AdicionarNovoTopico(VariaveisEquipamento.TopicoMqttComandos.Replace("<id>", device_id));
                await Variaveis.MqttService.AdicionarNovoTopico(VariaveisEquipamento.TopicoMqttTelemetria.Replace("<id>", device_id), true, 1, async (message) =>
                {
                    try
                    {
                        string json = message.Mensagem;
                        var obj = JsonConvert.DeserializeObject<OperacaoSensoriamentoLogModel>(json);
                        lock (_RoversLock)
                        {
                            RoversNaRede[device_id] = obj;

                            ((App)Application.Current).Shell.Main.AtualizarDadosTela_Telemetria(device_id);
                        }
                    }
                    catch (Exception ex)
                    {
                        Variaveis.MostrarLog($"Erro ao deserializar dados de telemetria do rover {device_id}: {ex.Message}");
                    }
                });

                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    try
                    {
                        List<string> dispositivos_ids = new List<string>() { "BASE" };
                        dispositivos_ids.Union(RoversNaRede.Select(x => x.Key).ToList());
                        ((App)Application.Current).Shell.Main.AtualizarListaDispositivos(dispositivos_ids);
                    }
                    catch (Exception exUi)
                    {
                        Variaveis.MostrarLog($"Erro ao atualizar UI lista dispositivos: {exUi.Message}");
                    }
                }));
            }
        }
        
        public static async void AtualizarListaRoversNaRede()
        {
            List<string> rovers_desconectados = new List<string>();
            var rovers_atual = new Dictionary<string, OperacaoSensoriamentoLogModel>();
            lock (_RoversLock)
            {
                rovers_atual = new Dictionary<string, OperacaoSensoriamentoLogModel>(RoversNaRede);
            }
            foreach (var rover in rovers_atual)
            {
                double tempo_sem_resposta = (DateTime.Now - rover.Value.Momento).TotalSeconds;
                if (tempo_sem_resposta > 5.0)
                {
                    rovers_desconectados.Add(rover.Key);
                }
            }
            foreach (var device_id in rovers_desconectados)
            {
                lock (_RoversLock)
                {
                    RoversNaRede.Remove(device_id);

                    if (SelectedRoverId == device_id)
                    {
                        ((App)Application.Current).Shell.Main.LimparDadosTela_Telemetria();
                    }
                }
                var topicos_rover = Variaveis.MqttService.Topicos.Where(x => x.Topico.Contains(device_id)).ToList();
                foreach (var topico in topicos_rover)
                {
                    await Variaveis.MqttService.UnsubscribeAsync(topico);
                    Variaveis.MqttService.Topicos.Remove(topico);
                }
            }
        }

        public static async void EnviarDadosControle(string rover_id, OperacaoControleBaseModel controle)
        {
            var topico = Variaveis.MqttService.Topicos.FirstOrDefault(x => x.Topico == VariaveisEquipamento.TopicoMqttComandos.Replace("<id>", rover_id));
            if (topico != null)
            {
                string json = JsonConvert.SerializeObject(controle);
                await Variaveis.MqttService.PublishAsync(topico, json);
            }
        }

        public static async void EnviarDadosPosicao(GPSModel posicao)
        {
            var topico = Variaveis.MqttService.Topicos.FirstOrDefault(x => x.Topico == TopicoMqttPosicao);
            if (topico != null)
            {
                string json = JsonConvert.SerializeObject(posicao);
                await Variaveis.MqttService.PublishAsync(topico, json);
            }
        }

        public static async void EnviarDadosCorrecaoRTCM(byte[] correcao)
        {
            var topico = Variaveis.MqttService.Topicos.FirstOrDefault(x => x.Topico == TopicoMqttRTCM);
            if (topico != null)
            {
                await Variaveis.MqttService.PublishAsync(topico, correcao);
            }
        }

    }
}