agrobot_base/AgroBase/AgroBase/Forms/frmPrincipal.cs

using AgroBase.Forms;
using AgroBase.Forms.Atuador;
using AgroBase.Forms.Movimentacao;
using AgroBase.Forms.Operacoes;
using AgroBase.Forms.Sensoriamento;
using AgroBase.Forms.Simuladores;
using AgroBase.Models;
using AgroBase.Services;
using System;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using static AgroBase.Models.Enums;

namespace AgroBase
{
    public partial class frmPrincipal : Form
    {
        AsyncTaskTimerModel tmrLoopDispositivos;

        public frmPrincipal()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            tmrLoopDispositivos = new AsyncTaskTimerModel("tmrLoopDispositivos", tmrLoopDispositivos_Tick, 1000, this);
            tmrLoopDispositivos.Start();

            btnJoyAtt_Click(new object(), new EventArgs());

            cmbModoOperacao.Items.Clear();
            cmbModoOperacao.Items.AddRange(Enum.GetNames(typeof(ModoOperacao)));
            cmbModoOperacao.SelectedIndex = (int)(Variaveis.OperacaoEmAndamento?.Parametros?.Modo ?? ModoOperacao.NaoDefinido);
        }

        private async void frmPrincipal_FormClosing(object sender, FormClosingEventArgs e)
        {
            // Executa o encerramento dos processos de forma segura
            await FuncoesGlobais.SafeExecuteAsync(async () => await frmInstancial.EncerrarProcessos());
            e.Cancel = true;
        }


        private void btnAtualizarRotinas_Click(object sender, EventArgs e)
        {
            AtualizarListaRotinas();
        }

        private void AtualizarListaRotinas()
        {
            var selecionados = clbRotinas.CheckedItems.Cast<string>().ToHashSet();

            string[] novosTimers;

            // Bloqueia para coletar os dados mais recentes
            lock (AsyncTaskTimerModel._timersLock)
            {
                novosTimers = AsyncTaskTimerModel.Timers
                    .Select(x => $"{x.StackTrace} -> {x.Id} - Interval: {x.Interval} - Tick: {x.TimeTick.TotalSeconds} s - State: {x.State.ToString()}")
                    .ToArray();
            }

            // Dicionário para facilitar comparação entre os itens atuais e os novos
            var itensAtuais = clbRotinas.Items.Cast<string>().ToHashSet();
            var novosItens = novosTimers.ToHashSet();

            // 1. Remover itens que não existem mais
            foreach (var item in itensAtuais.Except(novosItens))
            {
                clbRotinas.Items.Remove(item);
            }

            // 2. Adicionar novos itens que ainda não estão presentes
            foreach (var item in novosItens.Except(itensAtuais))
            {
                clbRotinas.Items.Add(item);
            }

            // 3. (Opcional) Atualizar os itens existentes
            // Neste caso, não precisa porque `string` é imutável e não há "atualização parcial".

            // Restaura a seleção
            foreach (var item in selecionados)
            {
                int index = clbRotinas.Items.IndexOf(item);
                if (index >= 0)
                    clbRotinas.SetItemChecked(index, true);
            }
        }

        #region DISPOSITIVOS

        private async Task tmrLoopDispositivos_Tick()
        {
            var op = Variaveis.OperacaoEmAndamento;

            AtualizaDadosGerais();

            lblStripMqtt.Text = "MQTT: " + (Variaveis.MqttServiceLocal.StatusConexao() ? "Conectado" : "Desconectado");

            lblStripPython.Text = "IA: " + (VariaveisOperacao.Operadores.Conectado ? "Conectado" : "Desconectado");
            lblStripPython.ForeColor = VariaveisOperacao.Operadores.Conectado ? Color.Green : Color.Red;

            lblStripOperacaoLiberada.Text = "Operação Liberada: " + (op.Sensoriamento.Operacao.OperacaoLiberada ? "Sim" : "Não");
            lblStripOperacaoLiberada.ForeColor = op.Sensoriamento.Operacao.OperacaoLiberada ? Color.Green : Color.Red;

            Variaveis.DebugMode = chbDebugMode.Checked;
        }

        public void AtualizaDadosGerais()
        {
            if (Variaveis.DispositivosConectados.Count() == 3 && pnlLateral.Controls.Count == 1)
            {
                SerialService.DispositivosConexaoInicial.ForEach(Dispositivo =>
                {
                    IDispositivosService dispositivoService = Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == Dispositivo);
                    if (dispositivoService != null)
                    {
                        int idx = SerialService.DispositivosConexaoInicial.IndexOf(dispositivoService.Dispositivo);
                        Control controle = dispositivoService.InstanciarDispositivo(idx);
                        controle.Location = new Point(controle.Location.X, controle.Location.Y + (idx * 50));
                        pnlLateral.Controls.Add(controle);
                    }
                });
            }


            var itensAtuais = lstDisponiveis.Items
                .Cast<ListViewItem>()
                .ToDictionary(item => item.Text, item => item);

            var novosItens = SerialService.DispositivosMapeados
                .GroupBy(x => x.Dispositivo)
                .Select(x => new ListViewItem()
                {
                    Text = x.FirstOrDefault().Endereco + " - " +
                           x.Key + " v" +
                           x.FirstOrDefault().Versao +
                           (SerialService.DispositivosMultiplos.Contains(x.FirstOrDefault().Dispositivo)
                               ? (" (" + string.Join(", ", x.Where(y => y.Status != StatusModulo.Desconectado).Select(y => y.Mod_ID)) + ")")
                               : "") +
                           " - " +
                           (x.FirstOrDefault()?.Status ?? StatusModulo.Desconectado)
                })
                .ToDictionary(item => item.Text, item => item);

            // **1. Remover itens que saíram**
            foreach (var item in itensAtuais.Keys.Except(novosItens.Keys))
            {
                lstDisponiveis.Items.Remove(itensAtuais[item]);
            }

            // **2. Adicionar novos itens**
            foreach (var item in novosItens.Keys.Except(itensAtuais.Keys))
            {
                lstDisponiveis.Items.Add(novosItens[item]);
            }

            // **3. Atualizar itens que mudaram**
            foreach (var item in novosItens.Keys.Intersect(itensAtuais.Keys))
            {
                var itemAtual = itensAtuais[item];
                var novoItem = novosItens[item];
                if (itemAtual.Text != novoItem.Text) // Só atualiza se mudou
                {
                    itemAtual.Text = novoItem.Text;
                }
            }


            tkbVelocidade.Minimum = 0;
            tkbVelocidade.Maximum = 100;
            FuncoesGlobais.PreencheValorTrackBar(tkbVelocidade, Variaveis.OperacaoEmAndamento.Parametros.Controle?.DirVelocidadeMovimento ?? 0);

            tkbAngulo.Minimum = 0;
            tkbAngulo.Maximum = 90;
            FuncoesGlobais.PreencheValorTrackBar(tkbAngulo, Variaveis.OperacaoEmAndamento.Controle.Angulo);

            trkKmh.Minimum = 0;
            trkKmh.Maximum = 100;

            trkRPM.Minimum = Variaveis.OperacaoEmAndamento.Parametros.Controle?.MovVelocidadeCErvasPercent ?? 15;
            trkRPM.Maximum = Variaveis.OperacaoEmAndamento.Parametros.Controle?.MovVelocidadeSErvasPercent ?? 50;

            AtualizaRPM((int)Variaveis.OperacaoEmAndamento.Controle.PercentualVelocidadeSP);

            AtualizarListaRotinas();
        }

        #endregion

        #region VERSIONAMENTO DE ARQUIVOS

        private async void btnForcarAtualizacao_Click(object sender, EventArgs e)
        {
            VersionamentoService.ForcarDownloadArquivos = true;
            await VersionamentoService.AtualizarArquivoVersionamento(true);
        }

        public void AtualizarProgressoSyncArquivos(string msg, double val)
        {
            BeginInvoke((MethodInvoker)(() =>
            {
                try
                {
                    lblProgressoAtualizacao.Text = msg;
                    FuncoesGlobais.PreencheValorProgressBar(pgbAtualizacaoArquivos, val);
                }
                catch { }
            }));
        }

        #endregion

        #region OPERACAO

        private void cmbModoOperacao_SelectedIndexChanged(object sender, EventArgs e)
        {
            Variaveis.OperacaoEmAndamento = OperacaoModel.CarregarParametrosOperacaoPadrao((ModoOperacao)cmbModoOperacao.SelectedIndex, CarregarModulos: true);
        }

        private void btnIniciarOperacao_Click(object sender, EventArgs e)
        {
            var op = Variaveis.OperacaoEmAndamento;

            if (op.Sensoriamento.Operacao.OperacaoIniciada)
            {
                Task.Run(async () => await op.FinalizarOperacao());

                btnIniciarOperacao.Text = "Abrir Operação";
                cmbModoOperacao.Enabled = true;
            }
            else
            {
                op.AbrirForm();
            }

            lblStripOperacaoStatus.Text = op.Sensoriamento.Operacao.OperacaoIniciada ? "Iniciado" : "Não iniciado";
        }

        private void btnConfigurarOperacao_Click(object sender, EventArgs e)
        {
            frmParametrizacaoOperacao frmParametrizacaoOperacao = new frmParametrizacaoOperacao();
            frmParametrizacaoOperacao.ShowDialog();
        }


        #endregion

        #region CONTROLE

        private void btnJoyAtt_Click(object sender, EventArgs e)
        {
            GeneralJoystick.AtualizaDispositivo();
        }

        private void btnJoyEdt_Click(object sender, EventArgs e)
        {

        }

        private void btnVer_Click(object sender, EventArgs e)
        {
            frmInstancial.frmJoystick.Show();
        }

        public void AtualizaRPM(int Percentual)
        {
            int RPM = Convert.ToInt32((Percentual / 100.0) * VariaveisEquipamento.RPM_Max_Roda);
            double Velocidade = FuncoesMatematicas.CalculaVelocidadeRPM(RPM);

            FuncoesGlobais.PreencheValorTrackBar(trkRPM, RPM);
            FuncoesGlobais.PreencheValorTrackBar(trkKmh, Percentual);

            Variaveis.OperacaoEmAndamento.Controle.PercentualVelocidadeSP = Percentual;
            lblRPM.Text = $"RPM: {RPM}";
            lblKmh.Text = $"Velocidade: {Percentual.ToString("0")}% {Velocidade.ToString("0.00")} km/h";
        }

        private void tkbVelocidadeMP_ValueChanged(object sender, EventArgs e)
        {
            if (Variaveis.OperacaoEmAndamento.Parametros.Controle == null)
                return;
            Variaveis.OperacaoEmAndamento.Parametros.Controle.DirVelocidadeMovimento = tkbVelocidade.Value;
            lblVelocidade.Text = "Velocidade: " + Variaveis.OperacaoEmAndamento.Parametros.Controle.DirVelocidadeMovimento + "%";
        }

        private void tkbAngulo_ValueChanged(object sender, EventArgs e)
        {
            Variaveis.OperacaoEmAndamento.Controle.Angulo = tkbAngulo.Value;
            lblAngulo.Text = "Angulo: " + Variaveis.OperacaoEmAndamento.Controle.Angulo + "º";
        }

        private void trkRPM_Scroll(object sender, EventArgs e)
        {
            /*try
            {
                int RPM = ((TrackBar)sender).Value;
                AtualizaRPM(RPM);
            }
            catch (Exception ex)
            {

            }*/
        }

        private void trkKmh_ValueChanged(object sender, EventArgs e)
        {
            try
            {
                int Percentual = trkKmh.Value;
                AtualizaRPM(Percentual);
            }
            catch (Exception ex)
            {

            }
        }

        #endregion

        #region ATALHOS

        private void btnDiagnosticos_Click(object sender, EventArgs e)
        {
            frmDiagnosticos frm = new frmDiagnosticos();
            frm.ShowDialog();
        }

        private void btnAcompanhamento_Click(object sender, EventArgs e)
        {
            frmAcompanhamento frm = new frmAcompanhamento();
            frm.Show();
        }

        private void btnCamera_Click(object sender, EventArgs e)
        {
            frmAtuCamera frmCamera = new frmAtuCamera();
            frmCamera.Show();
        }

        private void btnMapas_Click(object sender, EventArgs e)
        {
            frmMapa frmMapa = new frmMapa();
            frmMapa.Show();
        }

        private void btnGPS_Click(object sender, EventArgs e)
        {
            frmGPS frmGps = new frmGPS();
            frmGps.Show();
        }

        private void btnSenCamera_Click(object sender, EventArgs e)
        {
            frmSenCamera frmCamera = new frmSenCamera();
            frmCamera.Show();
        }
        
        private void btnIHM_Click(object sender, EventArgs e)
        {
            this.WindowState = FormWindowState.Minimized;

            frmInstancial.frmIHM.ShowDialog();
        }

        private void btnContornos_Click(object sender, EventArgs e)
        {
            frmMovCamera frmMovCamera = new frmMovCamera();
            frmMovCamera.Show();
        }

        private void btnAtuCalibragem_Click(object sender, EventArgs e)
        {
            frmAtuCalibragem frm = new frmAtuCalibragem();
            frm.Show();
        }

        private void btnSonar_Click(object sender, EventArgs e)
        {
            frmSonar frm = new frmSonar();
            frm.Show();
        }

        private void btnSimulador_Click(object sender, EventArgs e)
        {
            frmSimulacaoMapaGPS frm = new frmSimulacaoMapaGPS();
            frm.Show();
        }

        private void btnKinect_Click(object sender, EventArgs e)
        {
            if (KinectService.Iniciado)
            {
                frmKinect frmKinect = new frmKinect();
                frmKinect.Show();
            }
            else
            {
                MessageBox.Show("Módulo Kinect não está conectado!");
            }
        }

        private void btnResultados_Click(object sender, EventArgs e)
        {
            frmResultadosOperacao frmResultadosOperacao = new frmResultadosOperacao();
            frmResultadosOperacao.Show();
        }

        private void btnLoRaConfig_Click(object sender, EventArgs e)
        {
            if (false)//(Variaveis.LoraService.Iniciado)
            {
                frmLoraConfig frm = new frmLoraConfig();
                frm.Show();
            }
            else
            {
                MessageBox.Show("Módulo LoRa de comunicação não está conectado ou não está no modo de parametrização!");
            }
        }

        private void btnWT901C_Click(object sender, EventArgs e)
        {
            if (WT901CService.Iniciado || true)
            {
                frmWT901C frm = new frmWT901C();
                frm.Show();
            }
            else
            {
                MessageBox.Show("Módulo WT901C485 não está conectado!");
            }
        }

        private void btnBLD300R_Click(object sender, EventArgs e)
        {
            frmBLD frm = new frmBLD();
            frm.Show();
        }

        private void btnMKS_Click(object sender, EventArgs e)
        {
            frmMKS frm = new frmMKS();
            frm.Show();
        }

        private void btnEthernet_Click(object sender, EventArgs e)
        {
            frmEthernet frm = new frmEthernet();
            frm.Show();
        }

        private void btnOID_Click(object sender, EventArgs e)
        {
            frmOID frm = new frmOID();
            frm.Show();
        }

        private void btnTreinamentoIA_Click(object sender, EventArgs e)
        {
            frmTreinamentoIA frm = new frmTreinamentoIA();
            frm.Show();
        }

        private void btnVisualWorker_Click(object sender, EventArgs e)
        {
            frmOperarioSonar frm = new frmOperarioSonar();
            frm.Show();
        }

        private void btnSimuladorMapeamentoVisual_Click(object sender, EventArgs e)
        {
            frmSimulacaoMapeamentoVisual frm = new frmSimulacaoMapeamentoVisual();
            frm.Show();
        }

        private void btnUsrCan115_Click(object sender, EventArgs e)
        {
            frmCanEthernetConfig frm = new frmCanEthernetConfig();
            frm.Show();
        }

        #endregion

        private void lblStripOperacaoLiberada_Click(object sender, EventArgs e)
        {
            MessageBox.Show($"{Variaveis.OperacaoEmAndamento.Sensoriamento.Operacao.ErroOperacaoLiberada}", "Status da Operacao", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

        
    }
}