MonitoramentoIniciar();

function MonitoramentoIniciar() {
    const interval_Moni = 500; // Tempo em milissegundos (1 segundo)

    try {
        const checkElements_Moni = setInterval(() => {
            try {
                const moniConstruida = document.getElementById('Monitoramento');

                if (moniConstruida) {
                    let Preinfo = "<div class='Alerta'><h2>Carregando ...</h2></div>";
                    const HostsPainel = document.getElementById('ItensHosts');
                    HostsPainel.innerHTML = Preinfo;

                    monitoramentoIniciar();

                    async function monitoramentoIniciar() {
                        const { Zabix, ResutadosZabix } = await IntegracaoZabix();


                        RespostasZabixMonitoramento(ResutadosZabix, HostsPainel);

                        const dataZabix = await Zabix.json();
                        const ElementosZabix = dataZabix.data[0].hosts;


                        ApresentarHosts(ElementosZabix);
                        console.log(ElementosZabix)
                    }



                    function RespostasZabixMonitoramento(ResutadosZabix, Elementohost) {

                        if (ResutadosZabix === 500) {

                            Elementohost.innerHTML = `
                            <div class='Alerta'>
                                <h2>Status 404</h2>
                                <p>Sem serviços no momento</p>
                            </div>`;
                            throw new Error(`Erro na API dos Chamados: ${ResutadosZabix}`);
                        }

                        if (ResutadosZabix === 404) {

                            Elementohost.innerHTML = `
                            <div class='Alerta'>
                                <h2>Status 404</h2>
                                <p>Nenhum serviço encontrado</p>
                            </div>`;
                            throw new Error(`Erro na API dos Chamados: ${ResutadosZabix}`);
                        }

                        if (ResutadosZabix === 401) {

                            Elementohost.innerHTML = `
                            <div class='Alerta'>
                                <h2>Status 404</h2>
                                <p>Usuário não autenticado!</p>
                            </div>`;
                            throw new Error(`Erro na API dos Chamados: ${ResutadosZabix}`);
                        }

                        if (ResutadosZabix === 502) {

                            Elementohost.innerHTML = `
                            <div class='Alerta'>
                                <h2>Status 404</h2>
                                <p>Estamos realizando manutenções, volte mais tarde</p>
                            </div>`;
                            throw new Error(`Erro na API dos Chamados: ${ResutadosZabix} `);
                        }

                        if (ResutadosZabix === 504) {

                            Elementohost.innerHTML = `
                            <div class='Alerta'>
                                <h2>Status 404</h2>
                                <p>Estamos realizando manutenções, volte mais tarde</p>
                            </div>`;
                            throw new Error(`Erro na API dos Chamados: ${ResutadosZabix} `);
                        }

                    }

                    function ApresentarHosts(hosts) {
                        const filteredHosts = hosts.filter(host =>
                            host.metrics.some(metric => metric.key === "system.hostname")
                        );

                        const seletorEnseg = document.getElementById('Hostes');
                        const hostsPainel = document.getElementById('ItensHosts');

                        if (!seletorEnseg) return;

                        // Evita múltiplos eventos sendo adicionados ao select
                        seletorEnseg.innerHTML = `<option value="">Disponiveis</option>`;
                        filteredHosts.forEach(host => {
                            let hostName = host.metrics.find(metric => metric.key === "system.hostname")?.value || "Desconhecido";
                            seletorEnseg.innerHTML += `<option value="${hostName}">${hostName}</option>`;
                        });

                        Preinfo = "<div class='Alerta'><h2>Selecione um Host</h2></div>";
                        HostsPainel.innerHTML = Preinfo;

                        // Removendo eventos anteriores antes de adicionar um novo
                        seletorEnseg.replaceWith(seletorEnseg.cloneNode(true));
                        document.getElementById('Hostes').addEventListener('change', function () {
                            const selectedHostName = this.value;
                            hostsPainel.innerHTML = ""; // Limpa o painel

                            const selectedHost = filteredHosts.find(host =>
                                host.metrics.some(metric => metric.key === "system.hostname" && metric.value === selectedHostName)
                            );

                            if (!selectedHost) return;

                            let hostContentPainelFixo = "";
                            let hostContentPainelMovel = "";

                            selectedHost.metrics.forEach(metric => {


                                if (metric.key === "icmpping") {
                                    const valor = metric.value;

                                    if (valor == 0) {
                                        hostContentPainelFixo += `<div class="Desativado"> Host Desativado</div>`; // Aplicação do Desativado dentro do item host
                                    }
                                    // Reação de aplicação de inserção para o caso do ping for 1
                                    if (valor == 1) {
                                        hostContentPainelFixo += `<div class="Ativado"> Host Ativado </div>`; // Aplicação do ativo dentro do item host
                                    }


                                }


                                if (metric.key === "vm.memory.size[total]") {
                                    const valorMemoria = metric.value;
                                    const totalGB = (valorMemoria / Math.pow(1024, 3)).toFixed(2);

                                    hostContentPainelFixo += `<div class="Total_Memorias">Total de Ram ${totalGB} GB</div>`

                                }

                                let hostContentArmazen = ""
                                // Suponha que metric.key pode ter diferentes letras de unidade
                                if (metric.key.startsWith("vfs.fs.dependent.size[")) {
                                    // Expressão regular para capturar a letra da unidade
                                    const match = metric.key.match(/vfs\.fs\.dependent\.size\[([A-Z]):,total\]/);

                                    if (match) {
                                        const driveLetter = match[1]; // Captura a letra do drive
                                        const valorDisco = metric.value;

                                        const totalGB = (valorDisco / Math.pow(1024, 3)).toFixed(2);

                                        hostContentArmazen += `<div class="Total_Memorias_disco">Disco de Total - ${driveLetter}: ${totalGB} GB</div>`;
                                    }


                                }



                                // Suponha que metric.key pode ter diferentes letras de unidade
                                if (metric.key.startsWith("vfs.fs.dependent.size[")) {
                                    // Expressão regular para capturar a letra da unidade
                                    const match = metric.key.match(/vfs\.fs\.dependent\.size\[([A-Z]):,used\]/);

                                    if (match) {
                                        const driveLetter = match[1]; // Captura a letra do drive
                                        const valorDisco = metric.value;

                                        const usedGB = (valorDisco / Math.pow(1024, 3)).toFixed(2);

                                        hostContentArmazen += `<div class="Total_Uso_Memorias_disco">Disco em uso - ${driveLetter}: ${usedGB} GB</div>`;
                                    }
                                }

                                hostContentPainelFixo += hostContentArmazen;

                                if (metric.key === "system.cpu.util") {
                                    let Alinhadocpu = Math.floor(metric.value);
                                    hostContentPainelMovel += `<div class="CPU"><p id="ElementosUtili_CPU_${Alinhadocpu}">CPU ${Alinhadocpu}%</p></div>`;


                                    setTimeout(() => {

                                        const Elementoshost_CPU = document.getElementById(`ElementosUtili_CPU_${Alinhadocpu}`);

                                        if (Alinhadocpu == 100) {
                                            Elementoshost_CPU.classList.add('Consumo_Limite');

                                        }
                                        //Maior ou igual á 75 ou Menor ou igual á 99
                                        if (Alinhadocpu >= 75 && Alinhadocpu <= 99) {
                                            Elementoshost_CPU.classList.add('Consumo_Alto');

                                        }
                                        //Maior ou igual á 30 ou Menor ou igual á 74
                                        if (Alinhadocpu >= 30 && Alinhadocpu <= 74) {
                                            Elementoshost_CPU.classList.add('Consumo_Medio');
                                        }

                                        if (Alinhadocpu >= 0 && Alinhadocpu <= 29) {
                                            Elementoshost_CPU.classList.add('Consumo_Baixo');

                                        }

                                    }, 1);
                                }

                                if (metric.key === "vm.memory.util") {
                                    let AlinhadoMemory = Math.floor(metric.value);
                                    hostContentPainelMovel += `<div class="Ram"><p id="ElementosUtili_Memory_${AlinhadoMemory}">Ram ${AlinhadoMemory}%</p></div>`;

                                    setTimeout(() => {

                                        const Elementoshost_Memory = document.getElementById(`ElementosUtili_Memory_${AlinhadoMemory}`);

                                        if (AlinhadoMemory == 100) {
                                            Elementoshost_Memory.classList.add('Consumo_Limite');

                                        }
                                        //Maior ou igual á 75 ou Menor ou igual á 99
                                        if (AlinhadoMemory >= 75 && AlinhadoMemory <= 99) {
                                            Elementoshost_Memory.classList.add('Consumo_Alto');

                                        }
                                        //Maior ou igual á 30 ou Menor ou igual á 74
                                        if (AlinhadoMemory >= 30 && AlinhadoMemory <= 74) {
                                            Elementoshost_Memory.classList.add('Consumo_Medio');
                                        }

                                        if (AlinhadoMemory >= 0 && AlinhadoMemory <= 29) {
                                            Elementoshost_Memory.classList.add('Consumo_Baixo');

                                        }

                                    }, 1);
                                }
                            });

                            hostsPainel.innerHTML = `
                               
                                    <div class="HostCapa">${hostContentPainelMovel}</div>
                                    <div class="HostCorpo">${hostContentPainelFixo}</div>
                                
                            `;


                        });
                    }
                    localStorage.setItem('Carregou_tela_Moni', 'true');
                    clearInterval(checkElements_Moni);
                }
            } catch (error) {
                console.error('Erro dentro da tela home:', error);
                clearInterval(checkElements_Moni);
            }
        }, interval_Moni);
    } catch (error) {
        console.error('Erro fora da tela home:', error);
    }



}