agrobot_base/AgroBase/AgroBase/Forms/frmInstancial.cs

using AgroBase.Forms.IHM;
using AgroBase.Models;
using AgroBase.Services;
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AgroBase.Forms
{
    public partial class frmInstancial : Form
    {
        public static AsyncTaskTimerModel tmrVarreduraDispositivos;

        public static frmPrincipal frmPrincipal = new frmPrincipal();
        public static frmJoystick frmJoystick = new frmJoystick();
        public static frmIHM frmIHM = new frmIHM()
        {
            FormBorderStyle = FormBorderStyle.None,
            //WindowState = FormWindowState.Maximized,
            //TopMost = true
        };

        private static readonly SemaphoreSlim _startupGate =
            new SemaphoreSlim(1, 1);

        private static readonly SemaphoreSlim _shutdownGate =
            new SemaphoreSlim(1, 1);

        private static CancellationTokenSource _appCts;

        private static bool _startupConcluido;
        private static bool _shutdownIniciado;

        private bool _allowClose;

        public frmInstancial()
        {
            InitializeComponent();

            /*
             * O construtor precisa ser leve.
             * Nada de abrir MQTT, Redis, Python, CAN, Livox ou operadores aqui.
             * O WinForms ainda está criando handles e a aplicação ainda não
             * possui lifecycle seguro para aguardar falhas.
             */
            ThreadPool.SetMinThreads(
                workerThreads: 50,
                completionPortThreads: 50
            );
        }

        private async void frmInstancial_Load(object sender, EventArgs e)
        {
            try
            {
                await InicializarServicosAsync();
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Load] Falha crítica na inicialização: " +
                    ex
                );

                try
                {
                    MessageBox.Show(
                        "Falha ao inicializar o sistema:\n\n" +
                        ex.Message,
                        "AgroBase",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Error
                    );
                }
                catch { }
            }
        }

        private void frmInstancial_Shown(object sender, EventArgs e)
        {
            try
            {
                if (!Variaveis.Producao)
                {
                    frmIHM.FormClosing -= FrmIHM_FormClosing;
                    frmPrincipal.FormClosing -= frmPrincipal_FormClosing;

                    frmIHM.FormClosing += FrmIHM_FormClosing;
                    frmPrincipal.FormClosing += frmPrincipal_FormClosing;

                    frmPrincipal.Show();
                }
                else
                {
                    frmIHM.FormClosing -= frmPrincipal_FormClosing;
                    frmIHM.FormClosing += frmPrincipal_FormClosing;

                    frmIHM.Show();
                }

                Hide();
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Shown] " + ex
                );
            }
        }

        private static async Task InicializarServicosAsync()
        {
            await _startupGate.WaitAsync()
                .ConfigureAwait(false);

            try
            {
                if (_startupConcluido)
                    return;

                _shutdownIniciado = false;
                Variaveis.Fechando = false;

                _appCts?.Dispose();
                _appCts = new CancellationTokenSource();

                FuncoesGlobais.AddApplicationToStartup();

                /*
                 * Ordem pensada para campo:
                 * 1. limpar processos externos velhos;
                 * 2. subir infraestrutura local;
                 * 3. subir comunicação MQTT/UDP;
                 * 4. iniciar rotinas e operadores;
                 * 5. iniciar varredura física.
                 */

                PythonService.EncerrarProcessos();

                RedisService.Iniciar();
                RedisService.LimparDadosIniciais();

                GeneralJoystick.IniciarRotinas();

                await Variaveis.IniciarMqttAsync(_appCts.Token)
                    .ConfigureAwait(false);

                /*
                 * Hoje pode ficar comentado se UDP não for usado no rover,
                 * mas o método fica aqui no lugar certo do lifecycle.
                 */
                Variaveis.IniciarUDP();

                APIService.IniciarRotinas();
                VersionamentoService.IniciarRotinas();

                LivoxManagerProcess.Start();

                await VariaveisOperacao
                    .Operadores
                    .IniciarProcessamento(false)
                    .ConfigureAwait(false);

                AudioAlertaService.SelecionarVoz(
                    VariaveisEquipamento.VozAlerta
                );

                IniciarTimerVarreduraDispositivos();

                _startupConcluido = true;

                Variaveis.MostrarLog(
                    "[frmInstancial] Inicialização concluída."
                );
            }
            catch
            {
                await EncerrarProcessosInternoAsync(
                    sairProcesso: false
                ).ConfigureAwait(false);

                throw;
            }
            finally
            {
                _startupGate.Release();
            }
        }

        private static void IniciarTimerVarreduraDispositivos()
        {
            if (tmrVarreduraDispositivos != null)
                return;

            tmrVarreduraDispositivos =
                new AsyncTaskTimerModel(
                    "tmrVarreduraDispositivos",
                    tmrVarreduraDispositivos_Tick,
                    SerialService.InteraloVerificacao,
                    null,
                    15000
                );

            tmrVarreduraDispositivos.Start();
        }

        private static async Task tmrVarreduraDispositivos_Tick()
        {
            if (Variaveis.Fechando)
                return;

            await SerialService
                .RealizarVarreduraPortasUSB()
                .ConfigureAwait(false);
        }

        /*
         * Método mantido para compatibilidade com chamadas antigas.
         * Não é mais chamado no Load, porque o startup correto é
         * Variaveis.IniciarMqttAsync().
         */
        private async void IniciarConexaoMqtt()
        {
            try
            {
                await Variaveis.IniciarMqttAsync();
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.IniciarConexaoMqtt] " +
                    ex.Message
                );
            }
        }

        public static Task EncerrarProcessos()
        {
            return EncerrarProcessos(sairProcesso: false);
        }

        public static async Task EncerrarProcessos(
            bool sairProcesso)
        {
            await _shutdownGate.WaitAsync()
                .ConfigureAwait(false);

            try
            {
                if (_shutdownIniciado)
                    return;

                _shutdownIniciado = true;

                await EncerrarProcessosInternoAsync(
                    sairProcesso
                ).ConfigureAwait(false);
            }
            finally
            {
                _shutdownGate.Release();
            }
        }

        private static async Task EncerrarProcessosInternoAsync(
            bool sairProcesso)
        {
            Variaveis.Fechando = true;

            try { _appCts?.Cancel(); } catch { }

            /*
             * Primeiro paramos timers para nenhuma rotina reentrar
             * enquanto desmontamos serial, CAN, MQTT e processos.
             */
            try
            {
                await AsyncTaskTimerModel
                    .PararTimersAsync()
                    .ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro ao parar timers: " +
                    ex.Message
                );
            }

            tmrVarreduraDispositivos = null;

            try
            {
                await SerialService
                    .EncerrarAsync()
                    .ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro ao encerrar SerialService: " +
                    ex.Message
                );
            }

            /*
             * Tenta avisar dispositivos antes de fechar CAN/MQTT/processos.
             */
            try
            {
                foreach (var disp in Variaveis.DispositivosConectados)
                {
                    try
                    {
                        disp.EnviarProtocolosConfiguracao(false);
                        disp.SalvarParametros(disp.Dados);
                    }
                    catch (Exception ex)
                    {
                        Variaveis.MostrarLog(
                            "[frmInstancial.Encerrar] Erro ao salvar " +
                            disp.Dispositivo + ": " + ex.Message
                        );
                    }
                }
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro ao percorrer dispositivos: " +
                    ex.Message
                );
            }

            /*
             * Dá uma janela curta para a fila CAN drenar.
             * Usa DateTime aqui só por compatibilidade com o padrão atual,
             * mas sem travar indefinidamente.
             */
            try
            {
                var timeout = DateTime.Now.AddSeconds(10);

                while (!CanManager.CanService.FilaLiberada &&
                       DateTime.Now < timeout)
                {
                    await Task.Delay(200)
                        .ConfigureAwait(false);
                }
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro aguardando fila CAN: " +
                    ex.Message
                );
            }

            try
            {
                LivoxManagerProcess.Dispose();
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro ao encerrar Livox: " +
                    ex.Message
                );
            }

            try
            {
                PythonService.EncerrarProcessos();
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro ao encerrar Python: " +
                    ex.Message
                );
            }

            try
            {
                Variaveis.StopUdpChannel();
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro ao encerrar UDP: " +
                    ex.Message
                );
            }

            try
            {
                await GPSService
                    .EncerrarAsync()
                    .ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro ao encerrar GPS: " +
                    ex.Message
                );
            }

            try
            {
                await Variaveis
                    .EncerrarMqttAsync()
                    .ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.Encerrar] Erro ao encerrar MQTT: " +
                    ex.Message
                );
            }

            try
            {
                _appCts?.Dispose();
                _appCts = null;
            }
            catch { }

            _startupConcluido = false;

            if (sairProcesso)
            {
                try
                {
                    Environment.Exit(0);
                }
                catch { }
            }
        }

        private async void frmPrincipal_FormClosing(
            object sender,
            FormClosingEventArgs e)
        {
            if (_allowClose)
                return;

            e.Cancel = true;

            try
            {
                await EncerrarProcessos(
                    sairProcesso: false
                );

                _allowClose = true;

                BeginInvoke(
                    new Action(() =>
                    {
                        try
                        {
                            Close();
                        }
                        catch { }
                    })
                );
            }
            catch (Exception ex)
            {
                Variaveis.MostrarLog(
                    "[frmInstancial.FormClosing] " + ex
                );

                try
                {
                    Environment.Exit(1);
                }
                catch { }
            }
        }

        private void FrmIHM_FormClosing(
            object sender,
            FormClosingEventArgs e)
        {
            /*
             * Em modo desenvolvimento, fechar a IHM apenas oculta a janela.
             * Em produção, o evento de fechamento da IHM é associado ao
             * frmPrincipal_FormClosing e faz shutdown real.
             */
            e.Cancel = true;
            frmIHM.Hide();
        }
    }
}