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 Mesagem'><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 Status_${ResutadosZabix}'>
                                <h2>Status 404</h2>
                                <p>Estamos sem serivço temporariamente</p>
                            </div>`;
                            throw new Error(`Erro na API dos Chamados: ${ResutadosZabix}`);
                        }

                        if (ResutadosZabix === 404) {

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

                        if (ResutadosZabix === 502) {

                            Elementohost.innerHTML = `
                            <div class='Alerta Status_${ResutadosZabix}'>
                                <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 Status_${ResutadosZabix}'>
                                <h2>Status 404</h2>
                                <p>Este Serviço, demorou muito para responder, por favor contate o <a href="https://api.whatsapp.com/send?phone=5521966344698">suporte</a></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 || "Desativado";
                            let hostConsult = host.host_name;
                            seletorEnseg.innerHTML += `<option value="${hostConsult}">${hostName}</option>`;
                        });

                        Preinfo = "<div class='Alerta Mesagem'><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

                            // Busca o host correspondente pelo host_name
                            const selectedHost = filteredHosts.find(host => host.host_name === selectedHostName);


                            if (!selectedHost) return;

                            let hostAtivos = `<div> <p> Status do Host - Sem Resposta </p></div>`;
                            let hostMemoriaTotalRam = `<div> <p>Total de Ram -  Sem Resposta </p></div>`;
                            let discos = {};
                            let hostMemoriaUsoRam = `<div class="Ram"><p id="ElementosUtili_Memory_Null">Ram: ...</p></div>`;
                            let hostCPU = `<div class="CPU"><p id="ElementosUtili_CPU_Null">CPU: ....</p></div>`;

                            selectedHost.metrics.forEach(metric => {


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

                                    if (valor == 0) {
                                        hostAtivos = `<div class="Desativado"> Host Offline </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) {
                                        hostAtivos = `<div class="Ativado"> Host Online </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);

                                    hostMemoriaTotalRam = `<div class="Total_Memorias">Total de Ram ${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]):,total\]/);

                                    if (match) {
                                        let driveLetter = match[1]; // Captura a letra do drive
                                        let totalGB = formatarTamanhoTotal(metric.value); // Converte para GB

                                        function formatarTamanhoTotal(valorEmBytes) {
                                            let valorEmGB = valorEmBytes / Math.pow(1024, 3); // Converte para GB
                                            if (valorEmGB >= 1000) {
                                                let valorEmTB = valorEmGB / 1024; // Converte para TB
                                                return `${valorEmTB.toFixed(2)} TB`;
                                            }
                                            return `${valorEmGB.toFixed(2)} GB`;
                                        }


                                        if (!discos[driveLetter]) {
                                            discos[driveLetter] = { total: 0, used: 0 };
                                        }
                                        discos[driveLetter].total = totalGB;
                                    }


                                }


                                // 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) {
                                        let driveLetter = match[1]; // Captura a letra do drive
                                        let usedGB = formatarTamanhoUsed(metric.value) // Converte para GB

                                        // Função para formatar o tamanho em GB ou TB
                                        function formatarTamanhoUsed(valorEmBytes) {
                                            let valorEmGB = valorEmBytes / Math.pow(1024, 3); // Converte para GB
                                            if (valorEmGB >= 1000) {
                                                let valorEmTB = valorEmGB / 1024; // Converte para TB
                                                return `${valorEmTB.toFixed(2)} TB`;
                                            }
                                            return `${valorEmGB.toFixed(2)} GB`;
                                        }


                                        if (!discos[driveLetter]) {
                                            discos[driveLetter] = { total: 0, used: 0 };
                                        }
                                        discos[driveLetter].used = usedGB;
                                    }



                                }


                                if (metric.key === "system.cpu.util") {
                                    let Alinhadocpu = Math.floor(metric.value);
                                    hostCPU = `<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);
                                    hostMemoriaUsoRam = `<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);
                                }
                            });


                            let alinhamentoDeDiscos = "";
                            for (let drive in discos) {
                                alinhamentoDeDiscos += `<p>Unidade ${drive}: ${discos[drive].used} de ${discos[drive].total}</p>`;
                            }

                            // Se nenhum disco foi encontrado, exibir mensagem padrão
                            let alidanhamento_de_disco = Object.keys(discos).length > 0 ? alinhamentoDeDiscos : "<p>Sem informações de disco disponíveis</p>";


                            hostsPainel.innerHTML = `
                               
                                    <div class="HostCapa">
                                    ${hostCPU}
                                    ${hostMemoriaUsoRam}
                                    </div>
                                    <div class="HostCorpo">
                                        <div class="PainelAtivo">${hostAtivos}</div>
                                        
                                        <div class="PainelStorag">
                                        ${alidanhamento_de_disco}
                                        </div>
                                        <div class="PainelRam">${hostMemoriaTotalRam}</div>
                                    </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);
    }



}