using AgroBase.Models;
using AgroBase.Models.Modules;
using AgroBase.Properties;
using AgroBase.Services;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AgroBase.Forms.Operacoes
{
    public partial class frmResultadosOperacao : Form
    {
        List<OperacaoSensoriamentoLogModel> LogsOperacao = new List<OperacaoSensoriamentoLogModel>();
        List<GPSModel> LogsGPS = new List<GPSModel>();
        List<DirSensoriamentoLogModel> LogsDirecional = new List<DirSensoriamentoLogModel>();
        List<MovSensoriamentoLogModel> LogsMovimentacao = new List<MovSensoriamentoLogModel>();
        List<AtuSensoriamentoLogModel> LogsAtuador = new List<AtuSensoriamentoLogModel>();
        List<SensoriamentoMensagemJsonModel> LogsSensoriamento = new List<SensoriamentoMensagemJsonModel>();
        List<PzmSensoriamentoLogModel> LogsPzem = new List<PzmSensoriamentoLogModel>();
        List<WitSensoriamentoLogModel> LogsWt901C = new List<WitSensoriamentoLogModel>();
        List<UltrasonicA05Model> LogsA05 = new List<UltrasonicA05Model>();
        //List<KinectModel> LogsKinect = new List<KinectModel>();
        List<List<CamSoloSensoriamentoLogModel>> LogsCam_Solo = new List<List<CamSoloSensoriamentoLogModel>>();
        List<string> pathImagensSolo = new List<string>();
        List<PictureBox> picsCamSolo = new List<PictureBox>();
        List<CamCaminhoSensoriamentoLogModel> LogsCam_Caminho = new List<CamCaminhoSensoriamentoLogModel>();
        string pathImagensCaminho = "";
        string pathImagensSonarRGB = "";
        string pathImagensMapaCalor = "";
        
        DateTime MomentoAtual = DateTime.Now;
        AsyncTaskTimerModel tmrPlay;
        MapasModel Mapa = new MapasModel();
        private Visualizador3DService visualizador3D;
        private MapaDinamicoModel MapaDinamico;
        private int idxMomentoAtual
        {
            get
            {
                return LogsOperacao.IndexOf(LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual));
            }
        }
        private int idxMomentoFiltro = 0;
        private List<int> idxValoresFiltro = new List<int>();

        private string[] cmbItemsBuscaPor = new string[] { "Pico Máximo", "Pico Mínimo" };

        GraficoInterativoModel graficoMovGeral;
        GraficoInterativoModel graficoMovTemperatura;
        GraficoInterativoModel graficoMovAlimentacao;
        GraficoInterativoModel graficoAtu;
        GraficoInterativoModel graficoSen;
        GraficoInterativoModel graficoCpu;
        GraficoInterativoModel graficoCameras;
        GraficoInterativoModel graficoErvas;


        public frmResultadosOperacao()
        {
            // Ativa o double buffering
            this.DoubleBuffered = true;
            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            this.SetStyle(ControlStyles.UserPaint, true);
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

            InitializeComponent();

            InitializeGLControl();
        }

        private void InitializeGLControl()
        {
            VersaoArquivoModel arquivo = VersionamentoService.ArquivoModelo3D("obj");

            visualizador3D = new Visualizador3DService();
            visualizador3D.InitializeGLControl(pnl3D, arquivo.CaminhoCompleto);
        }


        private void frmResultadosOperacao_Load(object sender, EventArgs e)
        {
            tmrPlay = new AsyncTaskTimerModel("tmrPlay", tmrPlay_Tick, 1000, this);

            picDIR_DF.Image = FuncoesGlobais.EspelharImagemHorizontalmente(Resources.roda_superior);
            picDIR_DT.Image = FuncoesGlobais.EspelharImagemHorizontalmente(Resources.roda_superior);

            MapaDinamico = new MapaDinamicoModel(this, pnlZoomMapa);
        }

        private async Task tmrPlay_Tick()
        {
            if (trbMomento.Value < trbMomento.Maximum)
            {
                trbMomento.Value++;
            }
            else
            {
                tmrPlay.Stop();
            }
        }

        private void trbMomento_ValueChanged(object sender, EventArgs e)
        {
            MomentoAtual = LogsOperacao.Skip(trbMomento.Value).FirstOrDefault().Momento;
            AtualizarDadosMomento();
        }

        private void btnPlay_Click(object sender, EventArgs e)
        {
            tmrPlay.Toogle();
            btnPlay.Text = tmrPlay.IsRunning ? "Pause" : "Pay";
        }

        private void btnCarregarOperacao_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.Filter = "Arquivos de Operação|*.lgop";
            ofd.InitialDirectory = Application.StartupPath + "\\" + Variaveis.CaminhoOperacoes;
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                OperacaoDadosModel data = JsonConvert.DeserializeObject<OperacaoDadosModel>(File.ReadAllText(ofd.FileName));

                LogsOperacao = JsonConvert.DeserializeObject<OperacaoSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.operacao)).ToList();
                LogsGPS = JsonConvert.DeserializeObject<GPSModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.gps ?? Enums.T_Code.Gps.ToString())).ToList();
                LogsDirecional = JsonConvert.DeserializeObject<DirSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.dir ?? Enums.T_Code.Dir.ToString())).ToList();
                LogsMovimentacao = JsonConvert.DeserializeObject<MovSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.mov ?? Enums.T_Code.Mov.ToString())).ToList();
                LogsAtuador = JsonConvert.DeserializeObject<AtuSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.atu ?? Enums.T_Code.Atu.ToString())).ToList();
                LogsSensoriamento = JsonConvert.DeserializeObject<SensoriamentoMensagemJsonModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.sen ?? Enums.T_Code.Sen.ToString())).ToList();
                LogsPzem = JsonConvert.DeserializeObject<PzmSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.pzm ?? Enums.T_Code.Pzm.ToString())).ToList();
                LogsWt901C = JsonConvert.DeserializeObject<WitSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.wit ?? Enums.T_Code.Wit.ToString())).ToList();
                LogsA05 = JsonConvert.DeserializeObject<UltrasonicA05Model[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.a05 ?? Enums.T_Code.A05.ToString())).ToList();
                //LogsKinect = JsonConvert.DeserializeObject<KinectModel[]>(DeserializarDadosOperacao(ofd.FileName, data.knt ?? Enums.T_Code.Knt.ToString())).ToList();
                LogsCam_Caminho = JsonConvert.DeserializeObject<CamCaminhoSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, data.cam_caminho)).ToList();
                pathImagensSonarRGB = ofd.FileName.Replace("data.lgop", data.knt + "/rgb_");
                pathImagensMapaCalor = ofd.FileName.Replace("data.lgop", data.knt + "/heat_");
                pathImagensCaminho = ofd.FileName.Replace("data.lgop", data.cam_caminho + "/");

                LogsCam_Solo = new List<List<CamSoloSensoriamentoLogModel>>();
                pathImagensSolo = new List<string>();
                picsCamSolo = new List<PictureBox>();
                flwCameras.Controls.Clear();
                foreach (string cam in data.cam_solo)
                {
                    LogsCam_Solo.Add(JsonConvert.DeserializeObject<CamSoloSensoriamentoLogModel[]>(OperacaoModel.DeserializarDadosOperacao(ofd.FileName, cam)).ToList());
                    pathImagensSolo.Add(ofd.FileName.Replace("data.lgop", cam + "/"));
                    PictureBox pic = new PictureBox()
                    {
                        Name = "picCamSolo_" + cam,
                        Width = 250,
                        Height = 166,
                        SizeMode = PictureBoxSizeMode.StretchImage
                    };
                    flwCameras.Controls.Add(pic);
                    picsCamSolo.Add(pic);
                }

                Mapa = new MapasModel()
                {
                    pnlMapa = pnlMapa
                };
                MapasService.CriarArquivoMapa(new List<List<GPSModel>>() { LogsGPS }, 1517, data.id);
                Mapa.btnCarregar_Click(sender, e, Variaveis.CaminhoSistema + "/" + Variaveis.CaminhoMapasConvertidos + data.id + ".json");

                trbMomento.Maximum = LogsOperacao.Count - 1;
                trbMomento.Minimum = 0;
                trbMomento.Value = 0;

                MomentoAtual = LogsOperacao[0].Momento;

                this.Text = "Resultados da Operação " + LogsOperacao[0].Momento.ToString("dd/MM/yyyy");


                InicializarGraficos();
                InicializarCombosBusca();


                AtualizarDadosMomento();
            }
        }

        private void InicializarGraficos()
        {
            var Momentos = LogsOperacao.Select(x => x.Momento.ToString("mm:ss:fff")).ToList();

            graficoMovGeral = new GraficoInterativoModel(chartMovGeral, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "RPM SP", 
                    //Valores = LogsMovimentacao.GroupBy(x => new {ID = x.Modulo_ID, Momento = x.Momento}).Select(x => x.Average(y => y.RPM_SP)).ToList(), 
                    Valores = LogsOperacao.Select(x => (double)x.Controle.RPM_SP).ToList(), 
                    Visivel = true,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF SP",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.RPM_SP).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF Roda",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.RPM_Roda).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.RPM_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF km/h",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Velocidade).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET SP",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.RPM_SP).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET Roda",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.RPM_Roda).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.RPM_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET km/h",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Velocidade).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT SP",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.RPM_SP).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT Roda",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.RPM_Roda).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.RPM_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT km/h",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Velocidade).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF SP",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.RPM_SP).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF Roda",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.RPM_Roda).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.RPM_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF km/h",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Velocidade).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
            });

            graficoMovTemperatura = new GraficoInterativoModel(chartMovTemperatura, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Temperatura).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Temperatura).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Temperatura).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF Motor",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Temperatura).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "EF Driver",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.TemperaturaDriver).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "ET Driver",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.TemperaturaDriver).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DT Driver",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.TemperaturaDriver).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "DF Driver",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.TemperaturaDriver).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
            });

            graficoMovAlimentacao = new GraficoInterativoModel(chartMovTensao, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Tensao).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Tensao).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Tensao).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Tensao).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "AM EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Corrente_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AM ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Corrente_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AM DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Corrente_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AM DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Corrente_Motor).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "AB EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Corrente_Barramento).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AB ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Corrente_Barramento).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AB DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Corrente_Barramento).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "AB DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Corrente_Barramento).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "W EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.Potencia).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "W ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.Potencia).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "W DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.Potencia).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "W DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.Potencia).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },

                new GraficoInterativoSerieModel()
                {
                    Titulo = "% EF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "EF").Select(x => x.CicloTrabalho).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "% ET",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "ET").Select(x => x.CicloTrabalho).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "% DT",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DT").Select(x => x.CicloTrabalho).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "% DF",
                    Valores = LogsMovimentacao.Where(x => x.Modulo_ID == "DF").Select(x => x.CicloTrabalho).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
            });

            graficoAtu = new GraficoInterativoModel(chartAtuador, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Pressão SP",
                    Valores = LogsAtuador.Select(x => x?.PressaoLinha_SP ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Pressão",
                    Valores = LogsAtuador.Select(x => x?.PressaoLinha ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Potência",
                    Valores = LogsAtuador.Select(x => x?.PotenciaBomba ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Volume",
                    Valores = LogsAtuador.Select(x => x?.VolumeReservatorio ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Reservatório",
                    Valores = LogsAtuador.Select(x => x?.PercentualReservatorio ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Vazão",
                    Valores = LogsAtuador.Select(x => x?.VazaoFluxoMLpSMedia ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                }
            });

            graficoSen = new GraficoInterativoModel(chartSensoriamento, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 3v3", 
                    Valores = LogsSensoriamento.Select(x => x?.SensoresCorrente?.FirstOrDefault(y => y.ID.Contains("3V"))?.BusVoltage ?? 0).ToList(), 
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 3v3",
                    Valores = LogsSensoriamento.Select(x => x?.SensoresCorrente?.FirstOrDefault(y => y.ID.Contains("3V"))?.Current ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 5v0",
                    Valores = LogsSensoriamento.Select(x => x?.SensoresCorrente?.FirstOrDefault(y => y.ID.Contains("5V"))?.BusVoltage ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 5v0",
                    Valores = LogsSensoriamento.Select(x => x?.SensoresCorrente?.FirstOrDefault(y => y.ID.Contains("5V"))?.Current ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 7v2",
                    Valores = LogsSensoriamento.Select(x => x?.SensoresCorrente?.FirstOrDefault(y => y.ID.Contains("7V2"))?.BusVoltage ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 7v2",
                    Valores = LogsSensoriamento.Select(x => x?.SensoresCorrente?.FirstOrDefault(y => y.ID.Contains("7V2"))?.Current ?? 0).ToList(),
                    Visivel = false,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V 12v",
                    Valores = LogsSensoriamento.Select(x => x?.SensoresCorrente?.FirstOrDefault(y => y.ID.Contains("12V"))?.BusVoltage ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A 12v",
                    Valores = LogsSensoriamento.Select(x => x?.SensoresCorrente?.FirstOrDefault(y => y.ID.Contains("12V"))?.Current ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "V Bat",
                    Valores = LogsPzem.Select(x => x?.Tensao ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "A Bat",
                    Valores = LogsPzem.Select(x => x?.Corrente ?? 0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                }
            });

            graficoCpu = new GraficoInterativoModel(chartCpu, Momentos, new List<GraficoInterativoSerieModel>()
            {
                new GraficoInterativoSerieModel()
                {
                    Titulo = "CPU %",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.CPU_load ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "GPU %",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.GPU_load ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "HDD %",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.HDD_load ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "RAM %",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.RAM_usage ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "CPU Temp",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.CPU_temp ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "GPU Temp",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.GPU_temp ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Threads Ativas",
                    Valores = LogsOperacao.Select(x => (double)(x?.DadosPerformance.ActiveThreads ?? 0)).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Threads de Trabalho %",
                    Valores = LogsOperacao.Select(x => (double)((x?.DadosPerformance.MaxWorkerThreads ?? 1) - (x?.DadosPerformance.WorkerThreads ?? 0)) / (x?.DadosPerformance.MaxWorkerThreads ?? 1) * 100.0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
                new GraficoInterativoSerieModel()
                {
                    Titulo = "Threads de Portas %",
                    Valores = LogsOperacao.Select(x => (double)((x?.DadosPerformance.MaxCompletionPortThreads ?? 1) - (x?.DadosPerformance.CompletionPortThreads ?? 0)) / (x?.DadosPerformance.MaxCompletionPortThreads ?? 1) * 100.0).ToList(),
                    Visivel = true,
                    MostrarValor = true
                },
            });

            // Obtemos todos os tipos de ervas identificadas ao longo dos logs
            var todasErvas = LogsOperacao
                .SelectMany(log => log.Atuador.ErvasIdentificadas)
                .SelectMany(bico => bico.Keys)
                .Distinct()
                .ToList();

            Dictionary<DateTime, Dictionary<string, int>> agrupamento = new Dictionary<DateTime, Dictionary<string, int>>();
            foreach (var log in LogsOperacao)
            {
                if (!agrupamento.Any(x => x.Key == log.Momento))
                {
                    agrupamento.Add(log.Momento, new Dictionary<string, int>());
                }
                foreach (var bico in log.Atuador.ErvasIdentificadas)
                {
                    if (bico.Any())
                    {
                        foreach (var erva in bico)
                        {
                            if (!agrupamento[log.Momento].ContainsKey(erva.Key))
                            {
                                agrupamento[log.Momento].Add(erva.Key, erva.Value);
                            }
                            else
                            {
                                agrupamento[log.Momento][erva.Key] += erva.Value;
                            }
                        }
                    }
                }
            }
            graficoErvas = new GraficoInterativoModel(chartErvas, Momentos, new List<GraficoInterativoSerieModel>(
                todasErvas
                    .Select(erva => new GraficoInterativoSerieModel
                    {
                        Titulo = erva,
                        Valores = LogsOperacao
                            .Select(log =>
                            {
                                if (agrupamento.ContainsKey(log.Momento) && agrupamento[log.Momento].ContainsKey(erva))
                                    return (double)agrupamento[log.Momento][erva];
                                else
                                    return 0.0; // Adiciona zero se a erva não foi detectada neste momento
                            })
                            .ToList(),
                        Visivel = true,
                        MostrarValor = true,
                        ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Pie
                    })
                    .ToList()
                )
            )
            {
                Titulo = "Ervas Identificadas"
            };

            List<GraficoInterativoSerieModel> seriesCamerasSolo = new List<GraficoInterativoSerieModel>();
            foreach (var camSolo in LogsCam_Solo)
            {
                string camNome = "Solo " + (LogsCam_Solo.IndexOf(camSolo) + 1);
                seriesCamerasSolo.AddRange(new List<GraficoInterativoSerieModel>()
                {
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} RAM %",
                        Valores = camSolo.Select(x => (double)(x?.Leitura?.device_data?.Memory_Usage?.Percent ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} CPU Temp",
                        Valores = camSolo.Select(x => (double)(x?.Leitura?.device_data?.Temperature?.css ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} RAM Temp",
                        Valores = camSolo.Select(x => (double)(x?.Leitura?.device_data?.Temperature?.mss ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} VCC Temp",
                        Valores = camSolo.Select(x => (double)(x?.Leitura?.device_data?.Temperature?.upa ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    }
                });
            }

            if (LogsCam_Caminho.Any(x => x.Leitura.device_data != null))
            {
                var camCaminho = LogsCam_Caminho;
                string camNome = "Caminho";
                seriesCamerasSolo.AddRange(new List<GraficoInterativoSerieModel>()
                {
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} RAM %",
                        Valores = camCaminho.Select(x => (double)(x?.Leitura?.device_data?.Memory_Usage?.Percent ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} CPU Temp",
                        Valores = camCaminho.Select(x => (double)(x?.Leitura?.device_data?.Temperature?.css ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} RAM Temp",
                        Valores = camCaminho.Select(x => (double)(x?.Leitura?.device_data?.Temperature?.mss ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    },
                    new GraficoInterativoSerieModel()
                    {
                        Titulo = $"{camNome} VCC Temp",
                        Valores = camCaminho.Select(x => (double)(x?.Leitura?.device_data?.Temperature?.upa ?? 0)).ToList(),
                        Visivel = true,
                        MostrarValor = true
                    }
                });
            }

            graficoCameras = new GraficoInterativoModel(chartCameras, Momentos, seriesCamerasSolo);

        }

        private void InicializarCombosBusca()
        {
            CarregarInformacoesBusca(gpbMOV_Alimentacao_Filtro, graficoMovAlimentacao.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbMOV_Temperatura_Filtro, graficoMovTemperatura.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbMOV_Geral_Filtro, graficoMovGeral.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbSEN_Filtro, graficoSen.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbCpu_Filtro, graficoCpu.Series.Select(x => x.Titulo).ToArray());
            CarregarInformacoesBusca(gpbCameras_Filtro, graficoCameras.Series.Select(x => x.Titulo).ToArray());
        }

        private void CarregarInformacoesBusca(GroupBox gpb, string[] Componentes)
        {
            ComboBox cmbFiltro = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Filtro"));
            cmbFiltro.Items.Clear();
            cmbFiltro.Items.AddRange(cmbItemsBuscaPor);
            ComboBox cmbComponente = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Componente"));
            cmbComponente.Items.Clear();
            cmbComponente.Items.AddRange(Componentes);
            cmbComponente.SelectedIndexChanged += cmbComponente_SelectedIndexChanged;
            Button btnRedefinir = gpb.Controls.OfType<Button>().FirstOrDefault(x => x.Name.Contains("Redefinir"));
            btnRedefinir.Click += btnRedefinirBusca_Click;
            Button btnBuscar = gpb.Controls.OfType<Button>().FirstOrDefault(x => x.Name.Contains("Buscar"));
            btnBuscar.Click += btnBuscarMomento_Click;
            Button btnAnterior = gpb.Controls.OfType<Button>().FirstOrDefault(x => x.Name.Contains("Anterior"));
            btnAnterior.Click += btnAnteriorFiltro_Click;
            Button btnProximo = gpb.Controls.OfType<Button>().FirstOrDefault(x => x.Name.Contains("Proximo"));
            btnProximo.Click += btnProximoFiltro_Click; ;
        }

        private void btnAnteriorFiltro_Click(object sender, EventArgs e)
        {
            if (idxValoresFiltro.Any() && idxMomentoFiltro > 0)
            {
                idxMomentoFiltro--;
                trbMomento.Value = idxValoresFiltro[idxMomentoFiltro];
                AtualizarDadosMomento();
            }
        }

        private void btnProximoFiltro_Click(object sender, EventArgs e)
        {
            if (idxValoresFiltro.Any() && idxMomentoFiltro < idxValoresFiltro.Count() - 1)
            {
                idxMomentoFiltro++;
                trbMomento.Value = idxValoresFiltro[idxMomentoFiltro];
                AtualizarDadosMomento();
            }
        }

        private void cmbComponente_SelectedIndexChanged(object sender, EventArgs e)
        {
            AtualizarDadosMomento();
        }

        private void btnRedefinirBusca_Click(object sender, EventArgs e)
        {
            GroupBox gpb = (GroupBox)((Button)sender).Parent;
            ComboBox cmbFiltro = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Filtro"));
            cmbFiltro.SelectedIndex = -1;
            ComboBox cmbComponente = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Componente"));
            cmbComponente.SelectedIndex = -1;
            idxMomentoFiltro = 0;
            idxValoresFiltro = new List<int>();

            AtualizarDadosMomento();
        }

        private void btnBuscarMomento_Click(object sender, EventArgs e)
        {
            GroupBox gpb = (GroupBox)((Button)sender).Parent;
            ComboBox cmbFiltro = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Filtro"));
            if (cmbFiltro.SelectedIndex < 0)
            {
                return;
            }
            ComboBox cmbComponente = gpb.Controls.OfType<ComboBox>().FirstOrDefault(x => x.Name.Contains("Componente"));
            if (cmbComponente.SelectedIndex < 0)
            {
                return;
            }

            GraficoInterativoModel grafico = null;

            if (gpb.Name.Contains("SEN"))
            {
                grafico = graficoSen;
            }
            else if (gpb.Name.Contains("MOV_Temperatura"))
            {
                grafico = graficoMovTemperatura;
            }
            else if (gpb.Name.Contains("MOV_Alimentacao"))
            {
                grafico = graficoMovAlimentacao;
            }
            else if (gpb.Name.Contains("MOV_Geral"))
            {
                grafico = graficoMovGeral;
            }
            else if (gpb.Name.Contains("Cpu"))
            {
                grafico = graficoCpu;
            }
            else if (gpb.Name.Contains("Cameras"))
            {
                grafico = graficoCameras;
            }
            if (grafico != null)
            {
                var Dados = grafico.Series.FirstOrDefault(x => x.Titulo == cmbComponente.Text).Valores.Select((x, i) => new { valor = x, idx = i }).ToList();
                if (cmbFiltro.SelectedIndex == 0)
                {
                    Dados = Dados.OrderByDescending(x => x.valor).ToList();
                }
                else if (cmbFiltro.SelectedIndex == 1)
                {
                    Dados = Dados.OrderBy(x => x.valor).ToList();
                }

                idxValoresFiltro = Dados.Select(x => x.idx).ToList();
                idxMomentoFiltro = 0;

                trbMomento.Value = idxValoresFiltro[idxMomentoFiltro];
            }
        }

        private Bitmap CarregarImagemCamera(string Caminho)
        {
            string caminhoCompleto = Caminho + trbMomento.Value + ".jpg";
            Bitmap frame = new Bitmap(1, 1);
            using (Graphics g = Graphics.FromImage(frame))
            {
                g.Clear(Color.Black);
            }
            Bitmap blackFrame = new Bitmap(frame);

            if (File.Exists(caminhoCompleto))
            {
                try
                {
                    return new Bitmap(Image.FromFile(caminhoCompleto));
                }
                catch (Exception ex)
                {

                }
            }

            return blackFrame;
        }

        private Bitmap DesenharDeteccoesErvas(CameraCoordenadasFrameModel frame, Bitmap bitmapOriginal)
        {
            // Criar um novo bitmap com base no original para desenhar por cima
            Bitmap bitmapComObjetos = new Bitmap(bitmapOriginal);

            // Pegar o gráfico do bitmap que será retornado
            using (Graphics g = Graphics.FromImage(bitmapComObjetos))
            {
                // Proporção de escala
                double scaleX = (double)bitmapComObjetos.Width / frame.x_max;
                double scaleY = (double)bitmapComObjetos.Height / frame.y_max;

                // Iterar sobre os objetos detectados
                foreach (var objeto in frame.objetos)
                {
                    // Ajustar coordenadas e tamanho de acordo com a escala
                    int xAtual = (int)(objeto.x * scaleX);
                    int yAtual = (int)(objeto.y * scaleY);
                    int larguraAtual = (int)(objeto.largura * scaleX);
                    int alturaAtual = (int)(objeto.altura * scaleY);

                    // Desenhar o retângulo ao redor do objeto
                    g.DrawRectangle(new Pen(Color.Red, 2), xAtual, yAtual, larguraAtual, alturaAtual);

                    // Desenhar a descrição do objeto (id: descricao)
                    string descricao = $"{objeto.id}: {objeto.descricao}";
                    g.DrawString(descricao, new Font("Arial", 20), Brushes.White, new PointF(xAtual, yAtual - 15));
                }
            }

            // Retornar o bitmap modificado
            return bitmapComObjetos;
        }

        private void AtualizarDadosMomento()
        {
            if (!LogsOperacao.Any())
            {
                return;
            }

            txtMomento.Text = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual).Momento.ToString("HH:mm:ss");

            AtualizarInformacoesOperacao();

            AtualizarInformacoesCameras();

            AtualizarInformacoesGPS();

            AtualizarInformacoesDirecional();

            AtualizarInformacoesMovimentacao();

            AtualizarInformacoesAtuador();

            AtualizarInformacoesSensoriamento();

            //AtualizarInformacoesKinect();

            AtualizarInformacoesCPU();
        }

        private void AtualizarInformacoesOperacao()
        {
            var Log = LogsOperacao[idxMomentoAtual];
            var LogAtu = LogsAtuador[idxMomentoAtual];

            double herbicidaConsumido = Log.Atuador.HerbicidaConsumido != 0 ? Log.Atuador.HerbicidaConsumido : LogAtu.VolumeVazaoML;
            double percentualHerbicidaConsumido = FuncoesMatematicas.Clamp(((herbicidaConsumido / 1000.0) / LogsAtuador.FirstOrDefault().VolumeReservatorio) * 100.0, 0, 100);
            int totalAtuacoes = Log.Atuador.ErvasIdentificadas.Sum(dict => dict.Values.Sum());
            double herbicidaPorErva = Log.Atuador.HerbicidaPorErva != 0 ? Log.Atuador.HerbicidaPorErva : (herbicidaConsumido / (totalAtuacoes > 0 ? totalAtuacoes : 1));

            double distanciaPercorrida = Log.Trajetoria.DistanciaPercorrida;

            lblPercentualBateria.Text = $"Bateria {Log.Bateria.PorcentagemBateria.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbPercentualBateria, Log.Bateria.PorcentagemBateria);
            lblBateriaConsumida.Text = $"Consumido {Log.Bateria.BateriaConsumida.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbPercentualReservatorio, LogAtu.PercentualReservatorio);
            lblPercentualReservatorio.Text = $"Reservatório {LogAtu.PercentualReservatorio.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbHerbicidaConsumido, percentualHerbicidaConsumido);
            lblHerbicidaConsumido.Text = $"Consumido {herbicidaConsumido.ToString("0.00")} ml";
            FuncoesGlobais.PreencheValorProgressBar(pgbBateriaConsumida, Log.Bateria.BateriaConsumida);
            txtTempoMovimento.Text = FuncoesGlobais.ConverterSegundosParaHHmmss((int)Log.Movimentacao.TempoMovimentoSegs);
            txtStatusOperacao.Text = Log.StatusOperacao.ToString();
            txtStatusCarro.Text = Log.Trajetoria.StatusCarro.ToString();
            txtHerbicidaPorErva.Text = herbicidaPorErva.ToString("0.00") + " ml";
            txtDentroRua.Text = Log.Trajetoria.CorredorAtual.Dentro ? "Sim" : "Não";
            txtDirecaoCarro.Text = Log.Trajetoria.DirecaoCaminho.ToString();
            txtErvasNoRadar.Text = Log.Atuador.ErvasNoRadar.ToString();
            txtErvasTerreno.Text = Log.Atuador.PercentualErvasTerreno.ToString("0.00");
            txtTipoMovimento.Text = Log.Controle.TipoMovimento.ToString();
            txtVelocidade.Text = Log.Movimentacao.VelocidadeMedia.ToString("0.00") + " km/h (" + (Log.Movimentacao.VelocidadeMedia / 3.6).ToString("0.00") + " m/s)";
            txtDirecaoControle.Text = (Log.Controle?.Direcao ?? Enums.Direcao.Parado).ToString();
            txtVelocidadeControle.Text = ((Log.Controle?.PercentualVelocidadeSP ?? 0) / VariaveisEquipamento.RPM_Max_Roda * 100).ToString() + " rpm";
            txtErvasIdentificadas.Text = $"{totalAtuacoes}";

            txtDistanciaEsquerda.Text = Log.Trajetoria.DistanciaEsquerda.ToString("0.00");
            txtDistanciaDireita.Text = Log.Trajetoria.DistanciaDireita.ToString("0.00");
            txtNaMargem.Text = Log.Trajetoria.NaMargemDoCorredor ? "Sim" : "Não";

            lblPercentualOperacao.Text = $"Operação {Log.Trajetoria.ProgressoTrajeto.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbPercentualOperacao, Log.Trajetoria.ProgressoTrajeto);
            txtDistanciaPercorrida.Text = distanciaPercorrida.ToString("0.00") + " m / " + Log.Trajetoria.DistanciaTotal.ToString("0.00") + " m";

            double percentualRua = Log.Trajetoria.CorredorAtual.Progresso;
            lblPercentualRua.Text = $"Rua {percentualRua.ToString("0.00")}%";
            FuncoesGlobais.PreencheValorProgressBar(pgbPercentualRua, percentualRua);

            DateTime dataFim = Log.DataFim.Year != Log.DataInicio.Year ? LogsOperacao[LogsOperacao.Count - 1].Momento : Log.DataFim;
            txtDuracaoOperacao.Text = Log.TempoDecorrido.ToString("HH:mm:ss") + " / " + new DateTime().AddSeconds((dataFim - Log.DataInicio).TotalSeconds).ToString("HH:mm:ss");

            pnlOrientacaoCaminho.Invalidate();
            pnlOrientacaoDif.Invalidate();

            OperacaoModel.PopularTreeView(tvwFalhas, Log.CodigoFalha);

            TreeNode noModulos = new TreeNode("Status Módulos");
            tvwFalhas.Nodes.Add(noModulos);
            noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.Atu, LogsAtuador[idxMomentoAtual].Inicializado, LogsAtuador[idxMomentoAtual].UltimoComandoRespondido));
            noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.Sen, LogsSensoriamento[idxMomentoAtual].Conectado, LogsSensoriamento[idxMomentoAtual].UltimoComandoRespondido));
            noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.Mov, LogsMovimentacao[idxMomentoAtual].Inicializado, LogsMovimentacao[idxMomentoAtual].UltimoComandoRespondido));
            noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.Dir, LogsDirecional[idxMomentoAtual].Inicializado, LogsDirecional[idxMomentoAtual].UltimoComandoRespondido));
            noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.Pzm, LogsPzem[idxMomentoAtual].Inicializado, LogsPzem[idxMomentoAtual].UltimoComandoRespondido));
            noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.Wit, LogsWt901C[idxMomentoAtual].Inicializado, LogsWt901C[idxMomentoAtual].UltimoComandoRespondido));
            noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.A05, LogsA05[idxMomentoAtual].Conectado, LogsA05[idxMomentoAtual].UltimoComandoRespondido));
            noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.Gps, LogsGPS[idxMomentoAtual].Inicializado, LogsGPS[idxMomentoAtual].UltimoComandoRespondido));
            //noModulos.Nodes.Add(AtualizarTextoStatusModulo(Enums.T_Code.Knt, LogsCam_Caminho[idxMomentoAtual].Inicializado, LogsCam_Caminho[idxMomentoAtual].UltimaMensagemRecebida));
            tvwFalhas.ExpandAll();
        }

        private void AtualizarInformacoesCameras()
        {
            picCameraCaminho.Image = CarregarImagemCamera(pathImagensCaminho);
            AtualizarInformacoesCameraCaminho();

            for (int i = 0; i < LogsCam_Solo.Count(); i++)
            {
                Bitmap bitmapSolo = CarregarImagemCamera(pathImagensSolo[i]);
                if (chbDesenharErvas.Checked)
                {
                    var LogCamSolo = LogsCam_Solo[i].FirstOrDefault(x => x.Momento == MomentoAtual);
                    if (LogCamSolo != null)
                    {
                        bitmapSolo = DesenharDeteccoesErvas(LogCamSolo.Leitura, bitmapSolo);
                        picsCamSolo[i].Image = bitmapSolo;
                    }
                }
                else
                {
                    picsCamSolo[i].Image = bitmapSolo;
                }
            }


            graficoCameras.AtualizarDados(idxMomentoAtual);

            if (cmbCameras_Componente.SelectedIndex > -1)
            {
                var Valores = graficoCameras.Series.FirstOrDefault(x => x.Titulo == cmbCameras_Componente.Text).Valores.Take(idxMomentoAtual + 1).ToList();
                txtCameras_Atual.Text = Valores[idxMomentoAtual].ToString("0.00");
                txtCameras_Media.Text = Valores.Average().ToString("0.00");
                txtCameras_Mediana.Text = FuncoesMatematicas.CalcularMediana(Valores).ToString("0.00");
                txtCameras_Moda.Text = FuncoesMatematicas.CalcularModa(Valores).ToString("0.00");
                txtCameras_Minimo.Text = Valores.Min().ToString("0.00");
                txtCameras_Maximo.Text = Valores.Max().ToString("0.00");
            }
        }

        private void AtualizarInformacoesGPS()
        {
            var Log = LogsGPS.FirstOrDefault(x => x.Momento == MomentoAtual);
            txtGPS_Altitude.Text = (Log?.Altitude ?? 0).ToString();
            txtGPS_Data.Text = (Log?.DataHora ?? MomentoAtual).ToString("dd/MM HH:mm:ss");
            txtGPS_Latitude.Text = (Log?.Latitude ?? 0).ToString();
            txtGPS_Longitude.Text = (Log?.Longitude ?? 0).ToString();
            txtGPS_Orientacao.Text = (Log?.QualidadeFix ?? Enums.TiposCorrecaoGPS.SemCorrecao).ToString();
            txtGPS_Precisao.Text = (Log?.PrecisaoCm ?? 0).ToString("0.00") + " cm";
            txtGPS_Satelites.Text = (Log?.NumeroSatelites ?? 0).ToString();
            txtGPS_Velocidade.Text = (Log?.Velocidade ?? 0).ToString("0.00") + " (" + ((Log?.Velocidade ?? 0) * GPSUtils.ConversaoNosKmh).ToString("0.00") + " km/h)";

            int ID = Convert.ToInt32(Variaveis.IsAgroMonitor ? Variaveis.OperacaoEmAndamento.DispSen.Dados.LoRaParametrosBase.address : Variaveis.ConexaoLoRa.parametros.address);
            GPSService.EnviarCoordenadasParaMapa(Log?.Latitude ?? 0, Log?.Longitude ?? 0, Log?.CursoVerdadeiro ?? 0, true, ID);

            lblGPS.ForeColor = !Log.Inicializado ? Color.Red : Color.Black;

            pnlOrientacaoGPS.Invalidate();

            var _trajaetoria = LogsGPS.Select(x => new PontoTrajetoriaModel(Enums.TipoPontoRua.Indefinido)
            {
                Posicao = x
            })
            .ToList();


            //var LogKnt = LogsKinect.FirstOrDefault(x => x.Momento == MomentoAtual);
            var LogOpe = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual);

            MapaDinamico.AtualizarDados(
                null, //LogKnt.Iniciado && LogKnt.StatusDetecao ? LogKnt.ObstaculoCritico : null,
                (float)LogOpe.Trajetoria.AnguloCaminho,
                (float)LogOpe.Gps.AnguloCarroDefinido,
                new GPSModel() { Latitude = Log.Latitude, Longitude = Log.Longitude },
                _trajaetoria,
                null, //Variaveis.OperacaoEmAndamento.Mapa.TrajetoriaProjetada.FirstOrDefault(),
                new List<GPSModel>(LogsGPS.Take(LogsGPS.IndexOf(Log) + 1)),
                new List<List<GPSModel>>()
            );
        }

        private void AtualizarInformacoesDirecional()
        {
            AtualizarInformacoesMotorDirecional("DF");
            AtualizarInformacoesMotorDirecional("DT");
            AtualizarInformacoesMotorDirecional("EF");
            AtualizarInformacoesMotorDirecional("ET");

            pnlOrientacaoDirecional.Invalidate();
        }

        private void AtualizarInformacoesMotorDirecional(string ID)
        {
            var Log = LogsDirecional.Where(x => x.Modulo_ID == ID).FirstOrDefault(x => x.Momento == MomentoAtual);
            var LogSen = LogsSensoriamento.FirstOrDefault(x => x.Momento == MomentoAtual);
            var SensorPot = LogSen?.SensoresPotenciometro?.FirstOrDefault(x => x.ID.Contains(ID));

            double Angulo = Log?.Angulo ?? 0;
            double Multiplicador = -1;
            Image img = Resources.roda_superior;
            if (ID.StartsWith("E"))
            {
                img = FuncoesGlobais.EspelharImagemHorizontalmente(img);
                //Multiplicador = -1;
            }
            if (ID == "EF" || ID == "DT")
            {
                Multiplicador = 1;
            }
            //Multiplicador = (Log?.Sentido_SP ?? Enums.Sentido.Parado) == Enums.Sentido.Antihorario ? -1 : 1;

            PictureBox pic = FuncoesGlobais.FindControlRecursive<PictureBox>(tabDirecional, "picDIR_" + ID);
            pic.Image = FuncoesGlobais.RotacionarImagem(img, Angulo * Multiplicador);

            Label lbl = FuncoesGlobais.FindControlRecursive<Label>(tabDirecional, "lblDIR_" + ID);
            lbl.ForeColor = Log.Inicializado ? Color.Green : Color.Red;

            TextBox txtAnguloSP = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_AnguloSP_" + ID);
            txtAnguloSP.Text = (Log?.Angulo_SP ?? 0).ToString();
            TextBox txtAngulo = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Angulo_" + ID);
            txtAngulo.Text = (Log?.Angulo ?? 0).ToString();
            TextBox txtSentidoSP = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_SentidoSP_" + ID);
            txtSentidoSP.Text = (Log?.Sentido_SP ?? Enums.Sentido.Parado).ToString();
            TextBox txtSentido = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Sentido_" + ID);
            txtSentido.Text = (Log?.Sentido ?? Enums.Sentido.Parado).ToString();
            TextBox txtVelocidade = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Velocidade_" + ID);
            txtVelocidade.Text = (Log?.Velocidade ?? 0).ToString();
            TextBox txtControlar = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Controlar_" + ID);
            txtControlar.Text = (Log?.Controlar ?? false) ? "Sim" : "Não";
            TextBox txtStatus = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_Status_" + ID);
            txtStatus.Text = (SensorPot?.Status ?? Enums.StatusSensorPotenciometro.Indefinido).ToString();
            TextBox txtAgPot = FuncoesGlobais.FindControlRecursive<TextBox>(tabDirecional, "txtDIR_AgPot_" + ID);
            txtAgPot.Text = (SensorPot?.Angulo ?? -1).ToString("0.00");
            Label lblAgPot = FuncoesGlobais.FindControlRecursive<Label>(tabDirecional, "lblDIR_AgPot_" + ID);
            lblAgPot.ForeColor = (SensorPot?.Iniciado ?? false) ? Color.Green : Color.Red;
        }

        private void AtualizarInformacoesMovimentacao()
        {
            var Logs = LogsMovimentacao.Where(x => x.Momento == MomentoAtual).ToList();

            graficoMovGeral.AtualizarDados(idxMomentoAtual);
            graficoMovTemperatura.AtualizarDados(idxMomentoAtual);
            graficoMovAlimentacao.AtualizarDados(idxMomentoAtual);

            AtulizarDadosMotorMovimentacao("DF");
            AtulizarDadosMotorMovimentacao("DT");
            AtulizarDadosMotorMovimentacao("EF");
            AtulizarDadosMotorMovimentacao("ET");
        }

        private void AtulizarDadosMotorMovimentacao(string ID)
        {
            var Log = LogsMovimentacao.FirstOrDefault(x => x.Momento == MomentoAtual && x.Modulo_ID == ID);
            var Log_Sen = LogsSensoriamento.FirstOrDefault(x => x.Momento == MomentoAtual);
            bool freio =
                (ID.Contains("ET") && Log_Sen.ServoFreios?.FirstOrDefault(x => x.ID.Contains("ET"))?.Angulo > 0 && Log_Sen.ServoFreios?.FirstOrDefault(x => x.ID.Contains("ET"))?.Angulo < 180) ||
                (ID.Contains("DT") && Log_Sen.ServoFreios?.FirstOrDefault(x => x.ID.Contains("DT"))?.Angulo > 0 && Log_Sen.ServoFreios?.FirstOrDefault(x => x.ID.Contains("DT"))?.Angulo < 180) ||
                (ID.Contains("EF") && Log_Sen.ServoFreios?.FirstOrDefault(x => x.ID.Contains("EF"))?.Angulo > 0 && Log_Sen.ServoFreios?.FirstOrDefault(x => x.ID.Contains("EF"))?.Angulo < 180) ||
                (ID.Contains("DF") && Log_Sen.ServoFreios?.FirstOrDefault(x => x.ID.Contains("DF"))?.Angulo > 0 && Log_Sen.ServoFreios?.FirstOrDefault(x => x.ID.Contains("DF"))?.Angulo < 180);

            GroupBox gpbRpm = FuncoesGlobais.FindControlRecursive<GroupBox>(tabMovGreal, "gpbMOV_Geral_" + ID);
            gpbRpm.ForeColor = !Log.Inicializado ? Color.Red : Color.Black;
            CheckBox chbAlm = FuncoesGlobais.FindControlRecursive<CheckBox>(gpbRpm, "chbMOV_Alm_" + ID);
            chbAlm.Checked = Log.CodAlarme > 0;
            chbAlm.Text = $"Alarme ({Log.CodAlarme})";
            CheckBox chbEn = FuncoesGlobais.FindControlRecursive<CheckBox>(gpbRpm, "chbMOV_En_" + ID);
            chbEn.Checked = Log.Ativado;
            CheckBox chbBrk = FuncoesGlobais.FindControlRecursive<CheckBox>(gpbRpm, "chbMOV_Brk_" + ID);
            chbBrk.Checked = Log.EmFreio;
            TextBox txtSentidoSP = FuncoesGlobais.FindControlRecursive<TextBox>(gpbRpm, "txtMOV_SentidoSP_" + ID);
            txtSentidoSP.Text = freio ? Enums.Direcao.EmFreio.ToString() : Log.Sentido_SP.ToString();
            TextBox txtSentido = FuncoesGlobais.FindControlRecursive<TextBox>(gpbRpm, "txtMOV_Sentido_" + ID);
            txtSentido.Text = Log.EmFreio ? Enums.Direcao.EmFreio.ToString() : Log.Sentido.ToString();

            if (cmbMOV_Temperatura_Componente.SelectedIndex > -1)
            {
                var Valores = graficoMovTemperatura.Series.FirstOrDefault(x => x.Titulo == (ID + " " + cmbMOV_Temperatura_Componente.Text.Split(' ')[1])).Valores.Take(idxMomentoAtual + 1).ToList();

                GroupBox gpbTmp = FuncoesGlobais.FindControlRecursive<GroupBox>(tabMovTemperatura, "gpbMOV_Temperatura_" + ID);
                TextBox txtTmpAtual = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTmp, "txtMOV_TemperaturaAt_" + ID);
                txtTmpAtual.Text = Valores[idxMomentoAtual].ToString("0.00");
                TextBox txtTmpMinima = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTmp, "txtMOV_TemperaturaMn_" + ID);
                txtTmpMinima.Text = Valores.Min().ToString("0.00");
                TextBox txtTmpMaxima = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTmp, "txtMOV_TemperaturaMx_" + ID);
                txtTmpMaxima.Text = Valores.Max().ToString("0.00");

                int dado = (cmbMOV_Temperatura_Componente.SelectedIndex) / 4;

                double RetornaDadoTemperatura(MovSensoriamentoLogModel x) => dado == 0 ? x?.Temperatura ?? 0 : x?.TemperaturaDriver ?? 0;

                double valMin = 0;

                txtMOV_Temperatura_Media.Text = LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoTemperatura(x) > valMin && (chbMOV_Temperatura_Media.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Average(x => RetornaDadoTemperatura(x)).ToString("0.00");
                txtMOV_Temperatura_Mediana.Text = FuncoesMatematicas.CalcularMediana(LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoTemperatura(x) > valMin && (chbMOV_Temperatura_Moda.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Select(x => RetornaDadoTemperatura(x)).ToList()).ToString("0.00");
                txtMOV_Temperatura_Moda.Text = FuncoesMatematicas.CalcularModa(LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoTemperatura(x) > valMin && (chbMOV_Temperatura_Mediana.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Select(x => RetornaDadoTemperatura(x)).ToList()).ToString("0.00");
            }

            if (cmbMOV_AlImentacao_Componente.SelectedIndex > -1)
            {
                var Valores = graficoMovAlimentacao.Series.FirstOrDefault(x => x.Titulo == (cmbMOV_AlImentacao_Componente.Text.Split(' ')[0] + " " + ID)).Valores.Take(idxMomentoAtual + 1).ToList();

                GroupBox gpbTns = FuncoesGlobais.FindControlRecursive<GroupBox>(tabMovAlimentacao, "gpbMOV_Alimentacao_" + ID);
                TextBox txtTnsAtual = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTns, "txtMOV_AlimentacaoAt_" + ID);
                txtTnsAtual.Text = Valores[idxMomentoAtual].ToString("0.00");
                TextBox txtTnsMinima = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTns, "txtMOV_AlimentacaoMn_" + ID);
                txtTnsMinima.Text = Valores.Min().ToString("0.00");
                TextBox txtTnsMaxima = FuncoesGlobais.FindControlRecursive<TextBox>(gpbTns, "txtMOV_AlimentacaoMx_" + ID);
                txtTnsMaxima.Text = Valores.Max().ToString("0.00");

                int dado = (cmbMOV_AlImentacao_Componente.SelectedIndex) / 4;

                double RetornaDadoAlimentacao(MovSensoriamentoLogModel x) => dado == 0 ? x?.Tensao ?? 0 : dado == 1 ? x?.Corrente_Motor ?? 0 : dado == 2 ? x?.Corrente_Barramento ?? 0 : dado == 3 ? x?.Potencia ?? 0 : x?.CicloTrabalho ?? 0;

                double valMin = 0;

                txtMOV_Alimentacao_Media.Text = LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoAlimentacao(x) > valMin && (chbMOV_Alimentacao_Media.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Average(x => RetornaDadoAlimentacao(x)).ToString("0.00");
                txtMOV_Alimentacao_Mediana.Text = FuncoesMatematicas.CalcularMediana(LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoAlimentacao(x) > valMin && (chbMOV_Alimentacao_Moda.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Select(x => RetornaDadoAlimentacao(x)).ToList()).ToString("0.00");
                txtMOV_Alimentacao_Moda.Text = FuncoesMatematicas.CalcularModa(LogsMovimentacao.Where(x => x.Momento <= MomentoAtual && RetornaDadoAlimentacao(x) > valMin && (chbMOV_Alimentacao_Mediana.Checked ? x.Modulo_ID == ID : true)).DefaultIfEmpty().Select(x => RetornaDadoAlimentacao(x)).ToList()).ToString("0.00");
            }
        }

        private void AtualizarInformacoesAtuador()
        {
            graficoAtu.AtualizarDados(idxMomentoAtual);
            graficoErvas.AtualizarDados(idxMomentoAtual);

            pnlAtuadores.Invalidate();

            var Log = LogsAtuador.FirstOrDefault(x => x.Momento == MomentoAtual);
            if (Log == null)
            {
                return;
            }

            lblATU_QualidadeWifi.Text = $"Qualidade Wi-Fi: {Log.QualidadeWifi} dBm";
            lblATU_LatenciaLoop.Text = $"Latencia de Loop: {Log.LatenciaLoop} ms";
        }

        private void AtualizarInformacoesSensoriamento()
        {
            graficoSen.AtualizarDados(idxMomentoAtual);

            if (cmbSen_Componente.SelectedIndex > -1)
            {
                var Valores = graficoSen.Series.FirstOrDefault(x => x.Titulo == cmbSen_Componente.Text).Valores.Take(idxMomentoAtual + 1).ToList();
                txtSen_Atual.Text = Valores[idxMomentoAtual].ToString("0.00");
                txtSen_Media.Text = Valores.Average().ToString("0.00");
                txtSen_Mediana.Text = FuncoesMatematicas.CalcularMediana(Valores).ToString("0.00");
                txtSen_Moda.Text = FuncoesMatematicas.CalcularModa(Valores).ToString("0.00");
                txtSen_Minimo.Text = Valores.Min().ToString("0.00");
                txtSen_Maximo.Text = Valores.Max().ToString("0.00");
            }

            var LogWit = LogsWt901C.FirstOrDefault(x => x.Momento == MomentoAtual);
            lblMagnetometro.ForeColor = !LogWit.Inicializado ? Color.Red : Color.Black;
            pnlOrientacaoMagnetometro.Invalidate();
            pnlInclinacao.Invalidate();
            visualizador3D.AtualizarAngulos(LogWit.AngleX, LogWit.AngleY, LogWit.AngleZ);
            txtTemperatura.Text = LogWit.Temperatura.ToString("0.00");
            txtAltitude.Text = LogWit.Altitude.ToString("0.00");
            txtPressao.Text = LogWit.Pressao + " Pa (" + (LogWit.Pressao / 101300.0).ToString("0.00") + " atm)";

            var LogSen = LogsSensoriamento.FirstOrDefault(x => x.Momento == MomentoAtual);
            pnlManual.BackColor = LogSen.Sinaleiros?.FirstOrDefault(x => x.ID.Contains("MN"))?.Leitura == Enums.StatusLED.Aceso ? Color.Yellow : Color.Gold;
            pnlAutomatico.BackColor = LogSen.Sinaleiros?.FirstOrDefault(x => x.ID.Contains("AT"))?.Leitura == Enums.StatusLED.Aceso ? Color.Yellow : Color.Gold;
            pnlOperacao.BackColor = LogSen.Sinaleiros?.FirstOrDefault(x => x.ID.Contains("OP"))?.Leitura == Enums.StatusLED.Aceso ? Color.Green : Color.DarkGreen;
            lblSEN_QualidadeWifi.Text = $"Qualidade Wi-Fi: {LogSen.QualidadeWifi} dBm";
            lblSEN_LatenciaLoop.Text = $"Latencia de Loop: {LogSen.LatenciaLoop} ms";

            var LogA05 = LogsA05.FirstOrDefault(x => x.Momento == MomentoAtual);

            foreach (var pnl in pnlUltrassom.Controls.OfType<Panel>().OrderBy(x => x.Name))
            {
                int id = int.Parse(pnl.Name.Replace("pnlP_", ""));
                var _Sensor = LogA05.Configuracao.Sensores.FirstOrDefault(x => (int)x.Posicao == id);

                pnl.Visible = _Sensor != null;
                pnl.BackColor = LogA05.Conectado && _Sensor != null && _Sensor.SensorAtuado ? Color.Red : Color.Gray;
                
                pnl.Tag = _Sensor != null ? $"{_Sensor.ID:00};{_Sensor.LeituraCm:F2}" : null;  // Armazena o ID e a Leitura no Tag do Panel

                pnl.Paint += (s, _e) =>
                {
                    // Pega o ID e a leitura armazenados no Tag, se houver
                    string tag = pnl.Tag?.ToString();
                    if (!string.IsNullOrEmpty(tag))
                    {
                        var parts = tag.Split(';');
                        string sensorID = parts[0];
                        string leitura = parts.Length > 1 ? parts[1] : "";

                        Font font = new Font("Arial", 9, FontStyle.Bold);
                        // Calcula a posição para o ID do sensor (primeira linha)
                        SizeF idSize = _e.Graphics.MeasureString(sensorID, font);
                        float idX = (pnl.Width - idSize.Width) / 2;
                        float idY = (pnl.Height - idSize.Height) / 8; // Ajuste para centralizar no terço superior
                        _e.Graphics.DrawString(sensorID, font, Brushes.White, idX, idY);

                        // Calcula a posição para o valor de leitura (segunda linha)
                        Font fontLeitura = new Font("Arial", 7, FontStyle.Regular);
                        SizeF leituraSize = _e.Graphics.MeasureString(leitura, fontLeitura);
                        float leituraX = (pnl.Width - leituraSize.Width) / 2;
                        float leituraY = idY + idSize.Height + 1; // Posiciona logo abaixo do ID
                        _e.Graphics.DrawString(leitura, fontLeitura, Brushes.White, leituraX, leituraY);
                    }
                };

                pnl.Invalidate();  // Redesenha o Panel para aplicar as mudanças
            }

        }

        /*private void AtualizarInformacoesKinect()
        {
            var Log = LogsKinect.FirstOrDefault(x => x.Momento == MomentoAtual);
            txtEspacoLivreEsquerda.Text = Log.EspacoLivreEsquerda.ToString("0.00");
            txtEspacoLivreDireita.Text = Log.EspacoLivreDireita.ToString("0.00");
            txtDesvioNecessario.Text = Log.DesvioNecessario ? "Sim" : "Não";
            txtDirecaoDesvio.Text = Log.DirecaoDesvio.ToString();

            if (gridObstaculos.Columns.Count == 0)
            {
                gridObstaculos.Columns.Clear();

                gridObstaculos.Columns.Add("clDistancia", "Distância");
                gridObstaculos.Columns.Add("clLargura", "Largura");
                gridObstaculos.Columns.Add("clAltura", "Altura");
                gridObstaculos.Columns.Add("clEspacoEsquerda", "Espaço à Esquerdo");
                gridObstaculos.Columns.Add("clEspacoDireita", "Espaço à Direita");
                gridObstaculos.Columns.Add("clDesvioNecessario", "Desvio Necessário");
                gridObstaculos.Columns.Add("clDirecaoDesvio", "Direção Desvio");
            }

            gridObstaculos.Rows.Clear();

            foreach (var obstaculo in Log.Obstaculos.Where(x => x.DesvioNecessario).OrderBy(x => x.DistanciaMedia_mm))
            {
                gridObstaculos.Rows.Add
                (
                    obstaculo.DistanciaMedia_mm.ToString("0.00"),
                    obstaculo.Largura_mm.ToString("0.00"),
                    obstaculo.Altura_mm.ToString("0.00"),
                    obstaculo.DistanciaLivreEsquerda.ToString("0.00"),
                    obstaculo.DistanciaLivreDireita.ToString("0.00"),
                    obstaculo.DesvioNecessario ? "Sim" : "Não",
                    obstaculo.DirecaoDesvio.ToString()
                );
            }

            picMapaCalor.Image = CarregarImagemCamera(pathImagensMapaCalor);

            picSonarRGB.Image = CarregarImagemCamera(pathImagensSonarRGB);

            if (chbGrade.Checked)
            {
                Bitmap bitmap = (Bitmap)picSonarRGB.Image.Clone();
                bitmap = (Bitmap)KinectService.ExibirObstaculos(bitmap, Log.Subdivisoes, Log.Obstaculos).Clone();
                picSonarRGB.Image = (Bitmap)bitmap.Clone();
            }
        }*/

        private void AtualizarInformacoesCameraCaminho()
        {
            var Log = LogsCam_Caminho.FirstOrDefault(x => x.Momento == MomentoAtual);

            if (Log != null)
            {
                txtCamCaminhoAngulo.Text = Log.Angulo.ToString("0.00");
                txtCamCaminhoEsquerda.Text = Log.AnguloEsquerdo.ToString("0.00");
                txtCamCaminhoDireita.Text = Log.AnguloDireito.ToString("0.00");
            }

            pnlCaminho.Invalidate();
        }

        private void AtualizarInformacoesCPU()
        {
            graficoCpu.AtualizarDados(idxMomentoAtual);

            if (cmbCpu_Componente.SelectedIndex > -1)
            {
                var Valores = graficoCpu.Series.FirstOrDefault(x => x.Titulo == cmbCpu_Componente.Text).Valores.Take(idxMomentoAtual + 1).ToList();
                txtCpu_Atual.Text = Valores[idxMomentoAtual].ToString("0.00");
                txtCpu_Media.Text = Valores.Average().ToString("0.00");
                txtCpu_Mediana.Text = FuncoesMatematicas.CalcularMediana(Valores).ToString("0.00");
                txtCpu_Moda.Text = FuncoesMatematicas.CalcularModa(Valores).ToString("0.00");
                txtCpu_Minimo.Text = Valores.Min().ToString("0.00");
                txtCpu_Maximo.Text = Valores.Max().ToString("0.00");
            }
        }



        private void pnlOrientacaoDirecional_Paint(object sender, PaintEventArgs e)
        {
            var LogOp = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual);
            double Angulo = LogOp?.Controle?.Angulo ?? 0;
            Enums.Direcao direcaoControle = (LogOp?.Controle.TiposControle?.FirstOrDefault(x => x.Tipo == Enums.T_Code.Dir).UltimaDirecao ?? Enums.Direcao.Parado);
            Angulo *=
                direcaoControle == Enums.Direcao.Esquerda ? -1 :
                direcaoControle == Enums.Direcao.Direita ? 1 :
                0;
            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)Angulo, 90);
        }

        private void pnlOrientacaoGPS_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsGPS.FirstOrDefault(x => x.Momento == MomentoAtual);

            double AnguloGps = Log?.OrientacaoReal ?? 0;
            double AnguloMovimento = Log?.OrientacaoMovimento ?? 0;
            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)AnguloGps, 90, (float)AnguloMovimento);
        }

        private void pnlOrientacaoMagnetometro_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual);

            double AnguloWit = (Log?.WitMotion?.AngleZ ?? 0);
            double AnguloWitCorrigido = (Log?.WitMotion.AnguloCorrigido ?? 0);
            
            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)AnguloWit, 90, (float)AnguloWitCorrigido);
        }

        private void pnlOrientacaoCaminho_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsOperacao.FirstOrDefault(x => x.Momento == MomentoAtual);

            double Angulo = Log?.Trajetoria.ProximoPonto.Orientacao ?? 0;
            double AnguloMedio = Log?.Trajetoria.AnguloCaminho ?? 0;

            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)Angulo, 90, (float)AnguloMedio);
        }

        private void pnlOrientacaoDif_Paint(object sender, PaintEventArgs e)
        {
            var Logs = LogsOperacao.Where(x => x.Momento == MomentoAtual).ToList();
            double Angulo = Logs.Any() ? Logs.Average(x => x.Trajetoria.ErroOrientacaoAngularProximoPonto) : 0;
            FuncoesGlobais.DesenharInclinacao((Panel)sender, e, (float)Angulo, 90);
        }

        private void pnlAtuadores_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsAtuador.FirstOrDefault(x => x.Momento == MomentoAtual);
            if (Log == null)
            {
                return;
            }

            AtuadorFuncoesGerais.DesenharAtuadores(pnlAtuadores, e, Log.Bicos, Log.BombaLigada, Log.PressaoLinha, Log.TempoPulverizadorAtuado);
        }

        private void pnlInclinacao_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsWt901C.FirstOrDefault(x => x.Momento == MomentoAtual);

            Graphics g = e.Graphics;
            int centerX = pnlInclinacao.Width / 2;
            int centerY = pnlInclinacao.Height / 2;
            int radius = 10;

            // Desenhar fundo com bordas arredondadas
            GraphicsPath path = new GraphicsPath();
            int cornerRadius = 20;
            path.AddArc(0, 0, cornerRadius, cornerRadius, 180, 90);
            path.AddArc(pnlInclinacao.Width - cornerRadius, 0, cornerRadius, cornerRadius, 270, 90);
            path.AddArc(pnlInclinacao.Width - cornerRadius, pnlInclinacao.Height - cornerRadius, cornerRadius, cornerRadius, 0, 90);
            path.AddArc(0, pnlInclinacao.Height - cornerRadius, cornerRadius, cornerRadius, 90, 90);
            path.CloseAllFigures();

            g.SmoothingMode = SmoothingMode.AntiAlias;
            g.FillPath(new SolidBrush(Color.LightBlue), path);
            g.DrawPath(new Pen(Color.DarkBlue, 2), path);

            // Desenhar linhas de referência
            Pen pen = new Pen(Color.Gray, 1);
            g.DrawLine(pen, centerX, 0, centerX, pnlInclinacao.Height);
            g.DrawLine(pen, 0, centerY, pnlInclinacao.Width, centerY);

            // Desenhar linhas adicionais para ângulos
            for (int i = -90; i <= 90; i += 15)
            {
                int posX = centerX + (int)(i * (pnlInclinacao.Width / 2 - radius) / 90);
                int posY = centerY - (int)(i * (pnlInclinacao.Height / 2 - radius) / 90);
                g.DrawLine(pen, centerX, centerY, posX, centerY);
                g.DrawLine(pen, centerX, centerY, centerX, posY);
            }

            // Desenhar régua na linha central
            for (int i = -90; i <= 90; i += 15)
            {
                int posX = centerX + (int)(i * (pnlInclinacao.Width / 2 - radius) / 90);
                int posY = centerY - (int)(i * (pnlInclinacao.Height / 2 - radius) / 90);

                // Marcas horizontais
                g.DrawLine(pen, posX, centerY - 5, posX, centerY + 5);
                g.DrawString(i.ToString(), new Font("Arial", 8), Brushes.Black, posX - 10, centerY + 10);

                // Marcas verticais
                g.DrawLine(pen, centerX - 5, posY, centerX + 5, posY);
                g.DrawString(i.ToString(), new Font("Arial", 8), Brushes.Black, centerX + 10, posY - 5);
            }

            // Calcular a posição do círculo com base nos ângulos
            int circlePosX = centerX + (int)((Log?.AngleX ?? 0) * (pnlInclinacao.Width / 2 - radius) / 90);
            int circlePosY = centerY - (int)((Log?.AngleY ?? 0) * (pnlInclinacao.Height / 2 - radius) / 90);

            // Desenhar o círculo
            Brush brush = new SolidBrush(Color.Red);
            g.FillEllipse(brush, circlePosX - radius, circlePosY - radius, radius * 2, radius * 2);
        }

        private void pnlCaminho_Paint(object sender, PaintEventArgs e)
        {
            var Log = LogsCam_Caminho.FirstOrDefault(x => x.Momento == MomentoAtual);
            if (Log == null || Log.Leitura == null) return;

            Panel pnlContornos = (Panel)sender;

            Graphics graphics = e.Graphics;
            graphics.Clear(pnlContornos.BackColor); // Limpa o fundo

            // Determina as dimensões máximas dos contornos
            float larguraMaxContornos = 512; // Substitua pelo valor real
            float alturaMaxContornos = 512; // Substitua pelo valor real

            // Proporção de escala baseada no tamanho do Panel e nas dimensões dos contornos
            float proporcaoX = pnlContornos.Width / larguraMaxContornos;
            float proporcaoY = pnlContornos.Height / alturaMaxContornos;
            float escala = Math.Min(proporcaoX, proporcaoY); // Mantém a proporção sem distorcer

            // Calcula o novo tamanho dos contornos após o redimensionamento
            float novaLargura = larguraMaxContornos * escala;
            float novaAltura = alturaMaxContornos * escala;

            // Calcula o deslocamento para centralizar os contornos no Panel
            float deslocamentoX = (pnlContornos.Width - novaLargura) / 2;
            float deslocamentoY = (pnlContornos.Height - novaAltura) / 2;

            List<Point> pontosCamera = new List<Point>();
            var Classe = Log.ClassMap.FirstOrDefault(x => x.Key == "rua");
            foreach (var cameraClass in Log.Leitura.Classes.Where(x => x.Classe == Classe.Key))
            {
                if (cameraClass.Contornos == null || cameraClass.Contornos.Length == 0) continue;

                using (Pen pen = new Pen(Color.Blue, 2))
                {
                    for (int i = 0; i < cameraClass.Contornos.Length - 1; i++)
                    {
                        Point contorno = new Point() { X = cameraClass.Contornos[i][0], Y = cameraClass.Contornos[i][1] };
                        Point contornoP = new Point() { X = cameraClass.Contornos[i + 1][0], Y = cameraClass.Contornos[i + 1][1] };

                        // Aplica a escala e o deslocamento às coordenadas
                        Point start = new Point((int)(contorno.X * escala + deslocamentoX), (int)(contorno.Y * escala + deslocamentoY));
                        Point end = new Point((int)(contornoP.X * escala + deslocamentoX), (int)(contornoP.Y * escala + deslocamentoY));

                        if (chbDesenharContornos.Checked)
                        {
                            graphics.DrawLine(pen, start, end);
                        }

                        pontosCamera.Add(contorno);
                    }

                    // Se necessário, fechar o contorno conectando o último ponto ao primeiro
                    if (cameraClass.Contornos.Length > 1 && chbDesenharContornos.Checked)
                    {
                        var primeiro = cameraClass.Contornos.First();
                        var ultimo = cameraClass.Contornos.Last();
                        Point start = new Point((int)(ultimo[0] * escala + deslocamentoX), (int)(ultimo[1] * escala + deslocamentoY));
                        Point end = new Point((int)(primeiro[0] * escala + deslocamentoX), (int)(primeiro[1] * escala + deslocamentoY));
                        graphics.DrawLine(pen, start, end);
                    }
                }
            }

            if (chbDesenharExtremos.Checked)
            {
                using (Pen pen = new Pen(Classe.Value, 2))
                {
                    var PontosExtremos = CameraCaminhoModel.DefinirPontosExtremos(pontosCamera);
                    for (int i = 0; i < PontosExtremos.Count - 1; i++)
                    {
                        // Aplica a escala e o deslocamento às coordenadas
                        Point start = new Point((int)(PontosExtremos[i].X * escala + deslocamentoX), (int)(PontosExtremos[i].Y * escala + deslocamentoY));
                        Point end = new Point((int)(PontosExtremos[i + 1].X * escala + deslocamentoX), (int)(PontosExtremos[i + 1].Y * escala + deslocamentoY));

                        graphics.DrawLine(pen, start, end);
                    }
                }
            }
        }
    
        private string AtualizarTextoStatusModulo(Enums.T_Code Disp, bool conectado, DateTime ultimoComando)
        {
            // Formata o texto com tabulação
            return $"{Disp.ToString(), -5}\tConectado: {(conectado ? "Sim" : "Não"),-5}\tÚltimo comando: {ultimoComando:dd/MM/yyyy HH:mm:ss.fff}";
        }
    }
}