using System.ComponentModel;
using System.Windows.Input;
using OperationControl.Views;
using OperationControl.Helpers;
using System.Windows;
using OperationControl.Models;
using OperationControl.Views.Operacao;
using AgroBase.Models.Operacoes;
using Newtonsoft.Json.Linq;
using OperationControl.ViewModels.Views.Operacao;

namespace OperationControl.ViewModels
{
    public class DockWindowViewModel : INotifyPropertyChanged
    {
        private readonly ConfigConexaoView _viewConfig;

        private readonly PreparacaoMapaView _viewPreparacaoMapa;
        public readonly PreparacaoMapaTopView _viewPreparacaoMapaTop;
        private readonly PreparacaoMapaBottomView _viewPreparacaoMapaBottom;

        private readonly OperacaoTopView _viewOperacaoTop;
        private readonly OperacaoCenterView _viewOperacaoCenter;
        public readonly OperacaoLeftView _viewOperacaoLeft;
        public readonly OperacaoRightView _viewOperacaoRight;
        public readonly OperacaoBottomView _viewOperacaoBottom;

        private DockStep _currentStep;

        public DockWindowViewModel()
        {
            // Views
            _viewConfig = new ConfigConexaoView();
            _viewConfig._vm.TudoOkChanged += OnTudoOkChanged;

            _viewPreparacaoMapa = new PreparacaoMapaView();

            _viewPreparacaoMapaTop = new PreparacaoMapaTopView();

            _viewPreparacaoMapaBottom = new PreparacaoMapaBottomView();
            _viewPreparacaoMapaBottom._vm.CarregarMapaSolicitado += OnCarregarMapaSolicitado;
            _viewPreparacaoMapaBottom._vm.FixarBaseSolicitado += OnFixarBaseSolicitado;

            _viewOperacaoTop = new OperacaoTopView();

            _viewOperacaoCenter = new OperacaoCenterView();
            _viewOperacaoCenter._vm.RoverSelecionadoChanged += OnRoverSelecionadoChanged;

            _viewOperacaoLeft = new OperacaoLeftView();

            _viewOperacaoRight = new OperacaoRightView();
            _viewOperacaoRight._vm.PropertyChanged += OperacaoRightVm_PropertyChanged;
            _viewOperacaoRight._vm.RoverSelecionadoChanged += OnRoverSelecionadoChanged;
            _viewOperacaoRight._vm.SecaoSelecionadaChanged += OnSecaoSelecionadaChanged;
            _viewOperacaoRight._vm.LerParametrosSolicitado += OnLerParametrosSolicitado;
            _viewOperacaoRight._vm.SalvarParametrosSolicitado += OnSalvarParametrosSolicitado;

            _viewOperacaoBottom = new OperacaoBottomView();
            _viewOperacaoBottom._vm.AlertaSelecionadoChanged += OnAlertaSelecionadoChanged;

            // Commands
            BackCommand = new RelayCommand(_ => GoBack(), _ => CanGoBack);
            NextCommand = new RelayCommand(_ => GoNext(), _ => CanGoNext);

            // Estado inicial
            ConfigConexaoOk = _viewConfig._vm.TudoOk;
            CurrentStep = DockStep.ConfigConexao;
        }

        private void OnTudoOkChanged(bool ok)
        {
            ConfigConexaoOk = ok;

            OnPropertyChanged(nameof(CanGoNext));
            CommandManager.InvalidateRequerySuggested();
        }

        // ====== ETAPA ATUAL ======
        public ModoOperacao ModoOperacaoAtual => _viewConfig._vm.TipoOperacaoSelecionado;

        public DockStep CurrentStep
        {
            get => _currentStep;
            set
            {
                if (_currentStep != value)
                {
                    _currentStep = value;
                    OnPropertyChanged(nameof(CurrentStep));
                    OnPropertyChanged(nameof(CanGoBack));
                    OnPropertyChanged(nameof(CanGoNext));
                    OnPropertyChanged(nameof(MostrarPainelEsquerdo));
                    OnPropertyChanged(nameof(MostrarBotaoVoltarEsquerda));
                    OnPropertyChanged(nameof(RightPanelWidth));
                    OnPropertyChanged(nameof(LeftPanelWidth));

                    AtualizarConteudo();
                    CommandManager.InvalidateRequerySuggested();
                }
            }
        }

        // ====== ESTADO ======
        private bool _configConexaoOk;
        public bool ConfigConexaoOk
        {
            get => _configConexaoOk;
            set
            {
                if (_configConexaoOk != value)
                {
                    _configConexaoOk = value;
                    OnPropertyChanged(nameof(ConfigConexaoOk));
                    OnPropertyChanged(nameof(CanGoNext));
                    CommandManager.InvalidateRequerySuggested();
                }
            }
        }

        private bool _mapaCarregado;
        public bool MapaCarregado
        {
            get => _mapaCarregado;
            set
            {
                if (_mapaCarregado != value)
                {
                    _mapaCarregado = value;
                    OnPropertyChanged(nameof(MapaCarregado));
                    OnPropertyChanged(nameof(CanGoNext));
                    CommandManager.InvalidateRequerySuggested();
                }
            }
        }

        private bool _baseFixada = true;
        public bool BaseFixada
        {
            get => _baseFixada;
            set
            {
                if (_baseFixada != value)
                {
                    _baseFixada = value;
                    OnPropertyChanged(nameof(BaseFixada));
                    OnPropertyChanged(nameof(CanGoNext));
                    CommandManager.InvalidateRequerySuggested();
                }
            }
        }

        public bool CanGoBack => CurrentStep != DockStep.ConfigConexao;

        public bool CanGoNext
        {
            get
            {
                return CurrentStep switch
                {
                    DockStep.ConfigConexao => PodeAvancarConfigConexao(),
                    DockStep.PreparacaoMapa => MapaCarregado && BaseFixada,
                    _ => false
                };
            }
        }
        private bool PodeAvancarConfigConexao()
        {
            return ModoOperacaoAtual switch
            {
                ModoOperacao.Automatico => _viewConfig._vm.RedeOk && _viewConfig._vm.GnssOk,
                ModoOperacao.Manual => _viewConfig._vm.RedeOk,
                _ => false
            };
        }


        public bool MostrarPainelEsquerdo => CurrentStep == DockStep.ParametrizacaoRover;
        public bool MostrarBotaoVoltarEsquerda => CurrentStep != DockStep.ParametrizacaoRover;

        public GridLength LeftPanelWidth
        {
            get
            {
                return CurrentStep switch
                {
                    DockStep.ParametrizacaoRover => new GridLength(280),
                    _ => new GridLength(60)
                };
            }
        }
        public GridLength RightPanelWidth
        {
            get
            {
                return CurrentStep switch
                {
                    DockStep.ParametrizacaoRover => (_viewOperacaoRight?.DataContext as OperacaoRightViewModel)?.IsCollapsed == true
                        ? new GridLength(44)
                        : new GridLength(320),

                    _ => new GridLength(60)
                };
            }
        }
        private void OperacaoRightVm_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(OperacaoRightViewModel.IsCollapsed))
            {
                OnPropertyChanged(nameof(RightPanelWidth));
            }
        }
        
        // ====== CONTEÚDOS ======
        private object _centerContent;
        public object CenterContent
        {
            get => _centerContent;
            set
            {
                _centerContent = value;
                OnPropertyChanged(nameof(CenterContent));
            }
        }

        private object _topContent;
        public object TopContent
        {
            get => _topContent;
            set
            {
                _topContent = value;
                OnPropertyChanged(nameof(TopContent));
            }
        }

        private object _bottomContent;
        public object BottomContent
        {
            get => _bottomContent;
            set
            {
                _bottomContent = value;
                OnPropertyChanged(nameof(BottomContent));
            }
        }
        private object _leftContent;
        public object LeftContent
        {
            get => _leftContent;
            set
            {
                _leftContent = value;
                OnPropertyChanged(nameof(LeftContent));
            }
        }
        private object _rightContent;
        public object RightContent
        {
            get => _rightContent;
            set
            {
                _rightContent = value;
                OnPropertyChanged(nameof(RightContent));
            }
        }

        // ====== COMMANDS ======
        public ICommand BackCommand { get; }
        public ICommand NextCommand { get; }

        private void GoBack()
        {
            switch (CurrentStep)
            {
                case DockStep.PreparacaoMapa:
                    CurrentStep = DockStep.ConfigConexao;
                    break;
            }
        }

        private void GoNext()
        {
            if (!CanGoNext) return;

            switch (CurrentStep)
            {
                case DockStep.ConfigConexao:
                    if (ModoOperacaoAtual == ModoOperacao.Manual)
                        CurrentStep = DockStep.ParametrizacaoRover;
                    else
                        CurrentStep = DockStep.PreparacaoMapa;
                    break;

                case DockStep.PreparacaoMapa:
                    CurrentStep = DockStep.ParametrizacaoRover;
                    break;
            }
        }

        private FrameworkElement CriarBotaoNextSimples()
        {
            return new System.Windows.Controls.Button
            {
                Content = "⮞",
                FontSize = 24,
                Width = 40,
                Height = 40,
                HorizontalAlignment = System.Windows.HorizontalAlignment.Center,
                VerticalAlignment = VerticalAlignment.Center,
                Command = NextCommand
            };
        }

        private void AtualizarConteudo()
        {
            TopContent = null;
            BottomContent = null;
            LeftContent = null;
            RightContent = null;
            CenterContent = null;

            switch (CurrentStep)
            {
                case DockStep.ConfigConexao:
                    CenterContent = _viewConfig;
                    RightContent = CriarBotaoNextSimples();
                    break;

                case DockStep.PreparacaoMapa:
                    TopContent = _viewPreparacaoMapaTop;
                    CenterContent = _viewPreparacaoMapa;
                    BottomContent = _viewPreparacaoMapaBottom;
                    RightContent = CriarBotaoNextSimples();
                    break;

                case DockStep.ParametrizacaoRover:
                    TopContent = _viewOperacaoTop;
                    LeftContent = _viewOperacaoLeft;
                    CenterContent = _viewOperacaoCenter;
                    RightContent = _viewOperacaoRight;
                    BottomContent = _viewOperacaoBottom;

                    if (!string.IsNullOrWhiteSpace(_ultimoMapaCarregado))
                        _viewOperacaoCenter?.MapaOperacao?.LoadMapFile(_ultimoMapaCarregado);
                    break;
            }

            OnPropertyChanged(nameof(MostrarPainelEsquerdo));
            OnPropertyChanged(nameof(MostrarBotaoVoltarEsquerda));
        }

        // ====== INotifyPropertyChanged ======
        public event PropertyChangedEventHandler PropertyChanged;

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


        public void AtualizarDadosGnss(AgroBase.Models.GPSModel dados)
        {
            var bf = Variaveis.GpsService.BaseFix;
            if (bf.CorrecaoEmAndamento)
            {
                AtualizarProgressoFixacaoBase(bf.Progresso, bf.ProgressoStr);
                if (bf.Progresso >= 100) FinalizarFixacaoBase(true, bf.ProgressoStr);
            }
            switch (CurrentStep)
            {
                case DockStep.PreparacaoMapa:
                    System.Windows.Application.Current.Dispatcher.Invoke(() =>
                    {
                        _viewPreparacaoMapaTop?._vm?.AtualizarDados(dados);
                    });
                    break;

                case DockStep.ParametrizacaoRover:
                    _viewOperacaoCenter?.MapaOperacao?.markers?.UpdateMarkerPosition(VariaveisControleOperacao.BaseMarkerID, lat: dados?.Latitude, lon: dados?.Longitude, heading: dados?.OrientacaoReal);
                    break;
            }
        }

        public void AtualizarDadosMapa(OperacaoParametrosModel dados)
        {
            _viewOperacaoCenter?.MapaOperacao?.CarregarDadosMapa(dados?.Mapa, dados?.RuasPercorrer);
        }

        #region TELA 2

        private string? _ultimoMapaCarregado;

        private void OnCarregarMapaSolicitado(string caminhoArquivo)
        {
            try
            {
                _ultimoMapaCarregado = caminhoArquivo;
                _viewPreparacaoMapa?.MapControl?.LoadMapFile(caminhoArquivo);
                MapaCarregado = true;
                _viewPreparacaoMapaBottom?._vm.AtualizarProgresso(0, $"Mapa carregado: {System.IO.Path.GetFileName(caminhoArquivo)}");
            }
            catch (Exception ex)
            {
                MapaCarregado = false;
                _viewPreparacaoMapaBottom?._vm.AtualizarProgresso(0, $"Erro ao carregar mapa: {ex.Message}");
            }
        }

        private async void OnFixarBaseSolicitado()
        {
            try
            {
                if (!Variaveis.GpsService.BaseFix.FixLiberado)
                {
                    bool fixar = false;

                    if (Variaveis.GpsService.BaseFix.PosicaoBaseFixada)
                    {
                        var res = System.Windows.MessageBox.Show(
                            "Mudar posição da base?",
                            "Tem certeza que deseja fixar a posição da base novamente?",
                            MessageBoxButton.YesNo,
                            MessageBoxImage.Question);

                        if (res == MessageBoxResult.Yes)
                            fixar = true;
                    }
                    else
                    {
                        fixar = true;
                    }

                    if (fixar)
                    {
                        _viewPreparacaoMapaBottom?._vm.IniciarFixacao();
                        await Task.Run(async () => await Variaveis.GpsService.ConfigurarModulo(true));
                    }
                }
                else
                {
                    Variaveis.GpsService.BaseFix.ReiniciarFix();
                    BaseFixada = false;
                    _viewPreparacaoMapaBottom?._vm.CancelarFixacao("Fixação da base interrompida pelo operador.");
                }
            }
            catch (Exception ex)
            {
                _viewPreparacaoMapaBottom?._vm.FinalizarFixacao(false, $"Erro na fixação da base: {ex.Message}");
            }
        }

        public void AtualizarProgressoFixacaoBase(double progresso, string status)
        {
            System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                _viewPreparacaoMapaBottom?._vm.AtualizarProgresso(progresso, status);
            }));
        }

        public void FinalizarFixacaoBase(bool sucesso, string mensagem)
        {
            System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                BaseFixada = sucesso;
                _viewPreparacaoMapaBottom?._vm.FinalizarFixacao(sucesso, mensagem);
            }));
        }

        public void CancelarFixacaoBase(string mensagem)
        {
            System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                BaseFixada = false;
                _viewPreparacaoMapaBottom?._vm.CancelarFixacao(mensagem);
            }));
        }

        #endregion

        #region TELA 3

        public void AtualizarTopOperacaoBase()
        {
            System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                _viewOperacaoTop?._vm.DefinirStatusNormal("BASE", "Base selecionada. Sistema pronto.");
            }));
        }

        public void AtualizarTopOperacaoRover(string nomeRover, bool modoManual)
        {
            System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                if (modoManual)
                    _viewOperacaoTop?._vm.DefinirStatusManual($"{nomeRover}", "Rover em modo manual. Comandos locais liberados.");
                else
                    _viewOperacaoTop?._vm.DefinirStatusNormal($"{nomeRover}", "Rover selecionado. Operação pronta.");
            }));
        }

        public void AtualizarTopOperacaoAlerta(string contexto, string mensagem)
        {
            System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                _viewOperacaoTop?._vm.DefinirStatusAtencao(contexto, mensagem);
            }));
        }

        public void AtualizarTopOperacaoCritico(string contexto, string mensagem)
        {
            System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                _viewOperacaoTop?._vm.DefinirStatusCritico(contexto, mensagem);
            }));
        }


        private void OnAlertaSelecionadoChanged(AlertaModel alerta)
        {
            if (alerta == null) return;

            AtualizarTopOperacaoAlerta(
                $"ALERTA {alerta.Rover_ID}",
                $"{alerta.Titulo}: {alerta.Mensagem}"
            );

            // depois você pode navegar para diagnostico, abrir popup, focar modulo, etc
        }

        public void AdicionarAlerta(string roverId, AgroBase.Models.Enums.T_Code modulo, SeveridadeAlerta severidade, string mensagem, string modId = null)
        {
            (_viewOperacaoBottom.DataContext as OperacaoBottomViewModel)?.AdicionarAlerta(roverId, modulo, severidade, mensagem, modId);
        }

        public void RemoverAlerta(string roverId, AgroBase.Models.Enums.T_Code modulo, SeveridadeAlerta? severidade = null, string modId = null)
        {
            (_viewOperacaoBottom.DataContext as OperacaoBottomViewModel)?.RemoverAlerta(roverId, modulo, severidade, modId);
        }


        public void AtualizarListaRovers(List<OperacaoParametrosModel> rovers_atual)
        {
            var cards = rovers_atual.Select(x => new RoverCardModel()
            {
                EquipamentoId = x.IP,
                NumeroSerie = x.RoverId,
                Status = x.DadosLeitura?.StatusRover ?? AgroBase.Models.Enums.StatusModulo.Desconectado
            }).ToArray();

            _viewOperacaoRight?._vm?.AtualizarListaRovers(cards);

            foreach (var rover in cards)
            {
                if (!_viewOperacaoCenter?.MapaOperacao?.markers?.Added(rover.NumeroSerie) ?? false)
                {
                    if (rover.NumeroSerie == VariaveisControleOperacao.BaseMarkerID)
                    {
                        _viewOperacaoCenter?.MapaOperacao?.markers?.AddMarker(
                            rover.NumeroSerie,
                            true,
                            lat: Variaveis.GpsService?.UltimaLeitura?.Latitude ?? 0,
                            lon: Variaveis.GpsService?.UltimaLeitura?.Longitude ?? 0,
                            heading: Variaveis.GpsService?.UltimaLeitura?.OrientacaoReal ?? 0,
                            label: "Base"
                        );
                    }
                    else
                    {
                        var roverDados = VariaveisControleOperacao.RoversNaRede.FirstOrDefault(x => x.RoverId == rover.NumeroSerie);
                        if (roverDados != null)
                        {
                            _viewOperacaoCenter?.MapaOperacao?.markers?.AddMarker(
                                rover.NumeroSerie,
                                false,
                                lat: roverDados.DadosLeitura?.Gnss?.Latitude ?? 0,
                                lon: roverDados.DadosLeitura?.Gnss?.Longitude ?? 0,
                                heading: roverDados.DadosLeitura?.Gnss?.OrientacaoReal ?? 0
                            );
                        }
                    }
                }
            }
        }

        public void AtualizarDadosTela(OperacaoParametrosModel rover)
        {
            if (rover == null) return;
            var obj = rover.DadosLeitura;
            if (obj == null) return;

            var simulacao = obj.Controle?.SimulacaoMPC?.Select(x => new double[] { x.longitude, x.latitude })?.ToList();
            _viewOperacaoCenter?.MapaOperacao?.markers.UpdateMarkerPosition(rover.RoverId, lat: obj.Gnss?.Latitude, lon: obj.Gnss?.Longitude, heading: obj.Gnss?.OrientacaoReal, predict: simulacao);
            _viewOperacaoCenter?.MapaOperacao?.markers.UpdateMarkerInfo(rover.RoverId, status: obj.Operacao?.Status ?? AgroBase.Models.Enums.StatusOperacao.NaoIniciado);

            _viewOperacaoBottom?._vm?.AtualizarListaAlertasRoverSelecionado(rover.RoverId);

            if (rover.RoverId == VariaveisControleOperacao.SelectedRoverId)
            {
                var conexao = obj.ModulosSaude?.FirstOrDefault(x => x.modulo == AgroBase.Models.Enums.T_Code.Ipb);
                double c = conexao?.saude ?? 0;
                double conexao_latencia = conexao?.detalhes?["avg_rtt"]?.Value<double>() ?? 0.0;
                double conexao_perda = conexao?.detalhes?["loss_pct"]?.Value<double>() ?? 0.0;
                double bwTot = conexao?.detalhes?["bw_total_mbps"]?.Value<double>() ?? 0;
                string comunicacao = $"{conexao_latencia:0.00} ms {bwTot:0.00} Mbps";
                string comunicacao_extended = $"{conexao_latencia:0.00} ms {conexao_perda:F2}% {bwTot:0.00} Mbps";

                _viewOperacaoLeft?._vm?.AtualizarRover(
                    rover?.Descricao ?? "",
                    obj.Controle?.PercentualVelocidadeSPKmh ?? 0,
                    obj.Controle?.Angulo ?? 0,
                    obj.Controle?.TipoMovimento ?? AgroBase.Models.Enums.TipoMovimentoDirecional.Diagnostico,
                    obj.Refrigeracao?.Temperatura ?? 0,
                    obj.Bateria?.PercentualBateria ?? 0,
                    obj.Atuador?.PercentualReservatorio ?? 0,
                    $"{c}%",
                    $"{obj.Gnss?.QualidadeFix ?? AgroBase.Models.Enums.TiposCorrecaoGPS.SemCorrecao} {obj.Gnss?.PrecisaoCm:F2} cm"
                );

                _viewOperacaoRight?._vm?.AtualizarResumo(r =>
                {
                    r.Operacao = (obj.Operacao?.Liberada ?? false) ? "🔓 Liberada" : "🔒 Bloqueada";
                    r.Modo = obj.Operacao == null ? "-" : obj.Operacao.Modo.ToString();
                    r.Status = obj.Operacao == null ? "-" : $"{obj.Operacao.Status}" + (obj.Operacao.Status == AgroBase.Models.Enums.StatusOperacao.Aguardando ? $" ({obj.Operacao.TempoAguardandoSegs:0}s)" : "");
                    r.Carro = obj.Trajetoria == null ? "-" : obj.Trajetoria.StatusCarro.ToString();
                    r.Temperatura = $"{(obj.PerformanceNcp?.CPU_temp ?? 0):0.00} °C";
                    r.RuaAtual = obj.Trajetoria == null ? "-" : $"{obj.Trajetoria.CorredorAtualDistanciaPercorrida:0.00} m / " + $"{obj.Trajetoria.CorredorAtualDistanciaTotal:0.00} m " + $"({obj.Trajetoria.CorredorAtualIdx + 1})";
                    r.AreaTotal = obj.Trajetoria == null ? "-" : $"{obj.Trajetoria.DistanciaPercorrida:0.00} m / " + $"{obj.Trajetoria.DistanciaTotal:0.00} m";
                    r.Bateria = obj.Bateria == null ? "-" : $"{obj.Bateria.TensaoInstantanea:0.00} V " + $"({TimeSpan.FromMinutes(obj.Bateria.TempoEstimadoRestanteMinutos):dd\\.hh\\:mm\\:ss} " + $"{obj.Bateria.DistanciaEstimadaRestanteMetros:0.00} m)";
                    r.Herbicida = obj.Atuador == null ? "-" : $"{obj.Atuador.VolumeReservatorioL:0.00} L " + $"({TimeSpan.FromMinutes(obj.Atuador.TempoEstimadoRestanteMinutos):hh\\:mm\\:ss} " + $"{obj.Atuador.DistanciaEstimadaRestanteMetros:0.00} m)";
                    r.Infestacao = obj.Atuador == null ? "-" : $"{obj.Atuador.HerbicidaPorAtuacaoMl:0.00} mL/atuação";
                    r.Conexao = comunicacao == null ? "-" : $"{comunicacao}";
                    r.Duracao = obj.Operacao == null ? "00:00:00 / 00:00:00" : $"{TimeSpan.FromSeconds(obj.Operacao.TempoDecorridoSegs):hh\\:mm\\:ss} / " + $"{(string.IsNullOrWhiteSpace(obj.Trajetoria?.TempoEstimadoOperacao) ? "00:00:00" : obj.Trajetoria.TempoEstimadoOperacao)}";

                    // Opcionais para progress bars, caso queira evoluir o resumo
                    r.RuaAtualPercentual = obj.Trajetoria?.PercentualRuaAtual ?? 0;
                    r.AreaTotalPercentual = obj.Trajetoria?.PercentualOperacao ?? 0;
                    r.BateriaPercentual = obj.Bateria?.PercentualBateria ?? 0;
                    r.HerbicidaPercentual = obj.Atuador?.PercentualReservatorio ?? 0;
                    r.InfestacaoPercentual = obj.Atuador?.PercentualErvasTerreno ?? 0;
                });
            }
        }

        private void OnRoverSelecionadoChanged(string roverId)
        {
            _viewOperacaoRight?._vm?.DestacarRoverNoMapa(roverId);
        }

        private void OnRoverSelecionadoChanged(RoverCardModel rover)
        {
            bool dados_base = rover == null;
            if (dados_base)
            {
                if (!VariaveisControleOperacao.BaseEmFoco)
                {
                    _viewOperacaoCenter?.PararStreamCameraFrontal();
                    _viewOperacaoCenter?.PararStreamCameraErvas();
                    VariaveisControleOperacao.EnviarComandoIniciarUDP(VariaveisControleOperacao.RoverEmFoco?.IP, false);
                }
                VariaveisControleOperacao.RoverEmFoco?.RuasPercorrer?.Clear();
                AtualizarDadosMapa(VariaveisControleOperacao.RoverEmFoco);
                VariaveisControleOperacao.SelectedRoverId = VariaveisControleOperacao.BaseMarkerID;
                _viewOperacaoCenter?.MapaOperacao?.markers?.SetMarkerFocused(VariaveisControleOperacao.SelectedRoverId, true);

                _viewOperacaoCenter?._vm?.SelecionarRoverLista(rover);

                AtualizarTopOperacaoRover(VariaveisControleOperacao.SelectedRoverId, true);
                _viewOperacaoLeft?._vm?.DefinirSemRover();
            }
            else
            {
                VariaveisControleOperacao.SelectedRoverId = rover.NumeroSerie.ToString();
                _viewOperacaoCenter?.MapaOperacao?.markers?.SetMarkerFocused(VariaveisControleOperacao.SelectedRoverId, true);
                AtualizarDadosTela(VariaveisControleOperacao.RoverEmFoco);

                VariaveisControleOperacao.RequisitarParametrosOperacao();
                _viewOperacaoCenter?.IniciarStreamCameraFrontal();
                _viewOperacaoCenter?.IniciarStreamCameraErvas();
                VariaveisControleOperacao.EnviarComandoIniciarUDP(VariaveisControleOperacao.RoverEmFoco?.IP, true);

                _viewOperacaoCenter?._vm?.SelecionarRoverLista(rover);

                AtualizarTopOperacaoRover(VariaveisControleOperacao.SelectedRoverId, ModoOperacaoAtual == ModoOperacao.Manual);
            }
        }
        private void OnSecaoSelecionadaChanged(SecaoRightBar secao)
        {
            _viewOperacaoCenter?._vm?.DefinirSecao(secao);
        }

        private void OnLerParametrosSolicitado()
        {
            if (VariaveisControleOperacao.RoverEmFoco == null)
                return;

            VariaveisControleOperacao.RequisitarParametrosOperacao();

            _viewOperacaoRight?._vm?.AtualizarParametros(VariaveisControleOperacao.RoverEmFoco);
        }
        private void OnSalvarParametrosSolicitado(OperacaoParametrosModel parametros)
        {
            if (VariaveisControleOperacao.RoverEmFoco == null)
                return;

            var rover = VariaveisControleOperacao.RoverEmFoco;

            VariaveisControleOperacao.EnviarParametrosOperacao(new OperacaoParametrosModel()
            {
                Modo = parametros.Modo ?? AgroBase.Models.Enums.ModoOperacao.NaoDefinido,
                Descricao = parametros.Descricao,
                QtdCamerasSolo = parametros.QtdCamerasSolo,
                QtdBicos = parametros.QtdBicos,
                CapacidadeReservatorio = parametros.CapacidadeReservatorio,

                Controle = parametros.Controle,

                ModulosMandatorios = rover?.ModulosMandatorios,
                ParametrosMandatorios = rover?.ParametrosMandatorios,

                RuasPercorrer = _viewOperacaoCenter?.MapaOperacao?.RuasMapaCarregado?.Where(x => x.Selected)?.Select(x => x.Id)?.ToList(),
                Mapa = _viewOperacaoCenter?.MapaOperacao?.CriarDadosMapa()
            });
        }





        

        #endregion



    }


    public enum ModoOperacao
    {
        Automatico = 1,
        Manual = 2
    }

    public enum DockStep
    {
        ConfigConexao = 1,
        PreparacaoMapa = 2,
        ParametrizacaoRover = 3
    }

}