agrobot_base/AgroBase/OperationControl/ViewModels/ConfigConexaoViewModel.cs

// ViewModels/ConfigConexaoViewModel.cs
using System;
using System.ComponentModel;
using System.Windows.Input;
using System.Windows.Threading;
using OperationControl.Helpers;
using OperationControl.Models;

namespace OperationControl.ViewModels
{
    public class ConfigConexaoViewModel : INotifyPropertyChanged
    {
        public event Action SolicitarConfigRede;
        private readonly DispatcherTimer _timerGnss;

        public ConfigConexaoViewModel()
        {
            AbrirConfigRedeCommand = new RelayCommand(_ => AbrirConfigRede());
            AbrirDetalhesGnssCommand = new RelayCommand(_ => AbrirDetalhesGnss());

            // aqui você já pode chamar um serviço real depois
            CarregarStatusInicial();

            _timerGnss = new DispatcherTimer();
            _timerGnss.Interval = TimeSpan.FromMilliseconds(800); // 0.8s fica responsivo
            _timerGnss.Tick += (_, __) => AtualizarStatusGnss();
            _timerGnss.Start();
        }

        // ====== PROPRIEDADES DE REDE ======

        private bool _redeOk;
        public bool RedeOk
        {
            get => _redeOk;
            set
            {
                if (_redeOk != value)
                {
                    _redeOk = value;
                    OnPropertyChanged(nameof(RedeOk));
                    OnPropertyChanged(nameof(StatusRedeTexto));
                    OnPropertyChanged(nameof(CorStatusRede));
                    OnPropertyChanged(nameof(CorBordaRede));
                    OnPropertyChanged(nameof(TudoOk));
                    OnTudoOkChanged();
                }
            }
        }

        private string _detalhesRede;
        public string DetalhesRede
        {
            get => _detalhesRede;
            set { _detalhesRede = value; OnPropertyChanged(nameof(DetalhesRede)); }
        }

        public string StatusRedeTexto => RedeOk ? "Rede configurada" : "Rede com problema";

        public Brush CorStatusRede => RedeOk ? Brushes.LightGreen : Brushes.OrangeRed;

        public Brush CorBordaRede => RedeOk ? Brushes.LightGreen : Brushes.OrangeRed;

        // ====== PROPRIEDADES DE GNSS ======

        private bool _gnssOk;
        public bool GnssOk
        {
            get => _gnssOk;
            set
            {
                if (_gnssOk != value)
                {
                    _gnssOk = value;
                    OnPropertyChanged(nameof(GnssOk));
                    OnPropertyChanged(nameof(StatusGnssTexto));
                    OnPropertyChanged(nameof(CorStatusGnss));
                    OnPropertyChanged(nameof(CorBordaGnss));
                    OnPropertyChanged(nameof(TudoOk));
                    OnTudoOkChanged();
                }
            }
        }

        private string _detalhesGnss;
        public string DetalhesGnss
        {
            get => _detalhesGnss;
            set { _detalhesGnss = value; OnPropertyChanged(nameof(DetalhesGnss)); }
        }

        public string StatusGnssTexto => GnssOk ? "GNSS conectado" : "GNSS não detectado";

        public Brush CorStatusGnss => GnssOk ? Brushes.LightGreen : Brushes.OrangeRed;

        public Brush CorBordaGnss => GnssOk ? Brushes.LightGreen : Brushes.OrangeRed;

        // ====== MENSAGEM GERAL ======

        private string _mensagemGeral;
        public string MensagemGeral
        {
            get => _mensagemGeral;
            set { _mensagemGeral = value; OnPropertyChanged(nameof(MensagemGeral)); }
        }

        // ====== COMANDOS ======

        public ICommand AbrirConfigRedeCommand { get; }
        public ICommand AbrirDetalhesGnssCommand { get; }

        private void AbrirConfigRede()
        {
            // depois você pode abrir uma janelinha de config
            //MessageBox.Show("Aqui vai abrir a tela de configuração de rede.");
            SolicitarConfigRede?.Invoke();
        }

        private void AbrirDetalhesGnss()
        {
            MessageBox.Show("Aqui vai abrir uma tela com detalhes do GNSS/UM982.");
        }

        // ====== STATUS GERAL PARA AVANÇAR ======

        public bool TudoOk => RedeOk && GnssOk;

        // Evento para o DockWindow saber quando ficou tudo ok
        public event Action<bool> TudoOkChanged;

        private void OnTudoOkChanged()
        {
            TudoOkChanged?.Invoke(TudoOk);
        }

        // ====== STATUS INICIAL (fake por enquanto) ======

        public void CarregarStatusInicial()
        {
            // aqui você pluga de verdade nos seus serviços:
            // var statusRede = NetworkService.Get();
            // var statusGnss = GnssService.Get();

            AtualizarStatusRede();
            AtualizarStatusGnss();
        }



        private void AtualizarStatusGnss()
        {
            try
            {
                // Exemplo de checks (troca pelo teu serviço):
                // bool conectado = GnssService.Um982Conectado();
                // string porta = GnssService.PortaAtual();
                // string fix = GnssService.FixMode(); // "No Fix", "3D", "RTK Float", "RTK Fixed"
                // double? hdop = GnssService.Hdop();

                bool conectado = Variaveis.GpsService?.IsConnected ?? false; // <-- seu método real aqui
                //conectado = true;

                if (!conectado)
                {
                    GnssOk = false;
                    DetalhesGnss = "UM982 não detectado. Verifique cabo USB e alimentação.";
                    MensagemGeral = "Conecte o GNSS e ajuste a rede para avançar.";
                    return;
                }

                // Se conectou:
                GnssOk = true;

                // Se você tiver mais infos, mostra aqui:
                // DetalhesGnss = $"Conectado ({porta}) | Fix: {fix} | HDOP: {hdop:0.0}";
                DetalhesGnss = "Conectado. Recebendo dados GNSS.";

                // Mensagem geral pode ficar mais positiva se Rede também estiver ok
                MensagemGeral = TudoOk
                    ? "Tudo OK. Você pode avançar para a fixação da base."
                    : "GNSS OK. Agora ajuste a rede para avançar.";
            }
            catch (Exception ex)
            {
                GnssOk = false;
                DetalhesGnss = "Erro ao verificar GNSS: " + ex.Message;
                MensagemGeral = "Erro ao ler GNSS. Verifique conexões.";
            }
        }

        public void AtualizarStatusRede()
        {
            try
            {
                // 1) Escolhe a interface “ativa” ou a que você usa pra ponte IP
                //    Se você já tem isso fixo, melhor ainda: use sempre a mesma.
                var interfaces = EthernetService.ObterNomesInterfaces().Where(x => x.Contains("Ativa")).Select(x => x.Split('(')[0].Trim()).ToList();
                var iface = interfaces[0]; // <-- se tiver
                                                                   // ou se você já sabe o nome: var iface = "Ethernet 2";

                var ip = EthernetService.ObterIpAtual(iface);
                var sub = EthernetService.ObterSubnetMaskAtual(iface);
                var gw = EthernetService.ObterIpGateway(iface);

                DetalhesRede = $"{iface}\nIP: {ip}\nMáscara: {sub}\nGateway: {gw}";

                // 2) Define RedeOk do jeito que faz sentido pra você:
                //    exemplo simples: tem IP válido + gateway válido
                RedeOk = !string.IsNullOrWhiteSpace(ip) && !string.IsNullOrWhiteSpace(gw);
            }
            catch (Exception ex)
            {
                RedeOk = false;
                DetalhesRede = "Não foi possível ler a configuração.\n" + ex.Message;
            }
        }


        // ====== INotifyPropertyChanged ======

        public event PropertyChangedEventHandler PropertyChanged;
        private void OnPropertyChanged(string nome)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nome));
        }

        public void Dispose()
        {
            _timerGnss?.Stop();
        }
    }
}