from flask import Flask, jsonify, Blueprint
from pyzabbix import ZabbixAPI
from .auth import token_required
from flask_mysqldb import MySQL
from datetime import datetime

zabbix = Blueprint('zabbix', __name__)
mysql = MySQL()

# Função para formatar uptime (segundos → dias, horas, minutos, segundos)
def formatar_tempo(segundos):
    try:
        segundos = int(segundos)
        dias = segundos // 86400
        horas = (segundos % 86400) // 3600
        minutos = (segundos % 3600) // 60
        segundos = segundos % 60
        return f"{dias}d {horas}h {minutos}m {segundos}s"
    except (ValueError, TypeError):
        return "N/A"

# Função para converter timestamp para data legível
def formatar_data(timestamp):
    try:
        timestamp = int(timestamp)
        return datetime.utcfromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')
    except (ValueError, TypeError):
        return "N/A"

# Função para conectar ao Zabbix e obter os dados tratados
def get_zabbix_data(group_name_filter=None):
    data = []
    try:
        zabbix = ZabbixAPI("https://mimir.itguys.com.br/zabbix/api_jsonrpc.php")
        zabbix.login('vitoria.oliveira', '123Mudar')

        groups = zabbix.hostgroup.get(output="extend")

        for group in groups:
            if group_name_filter and group_name_filter.lower() not in group['name'].lower():
                continue
            
            group_data = {
                'group_id': group['groupid'],
                'group_name': group['name'],
                'hosts': []
            }

            hosts = zabbix.host.get(groupids=group['groupid'], output="extend")

            for host in hosts:
                host_data = {
                    'host_name': host['name'],
                    'metrics': []
                }

                items = zabbix.item.get(
                    hostids=host['hostid'], 
                    output=["itemid", "name", "key_", "lastvalue", "lastclock"]
                )

                for item in items:
                    key = item.get('key_', 'N/A')
                    value = item.get('lastvalue', 'N/A')
                    timestamp = item.get('lastclock', 'N/A')

                    if key == "system.uptime":
                        value = formatar_tempo(value)

                    metric = {
                        'key': key,
                        'value': value,
                        'last_update': formatar_data(timestamp)
                    }
                    host_data['metrics'].append(metric)

                network_packet_loss = zabbix.item.get(
                    hostids=host['hostid'], 
                    filter={"key_": "net.ping.loss"}, 
                    output=["lastvalue", "lastclock"]
                )

                for loss in network_packet_loss:
                    host_data['metrics'].append({
                        'key': 'net.ping.loss',
                        'value': loss.get('lastvalue', 'N/A'),
                        'last_update': formatar_data(loss.get('lastclock', 'N/A'))
                    })

                group_data['hosts'].append(host_data)

            data.append(group_data)
        
        return data  # Retorna os dados coletados
    except Exception as e:
        print(f"Erro ao obter dados do Zabbix: {str(e)}")
        raise  # Re-raise the exception

# Rota para obter dados do Zabbix
@zabbix.route('/metrics', methods=['POST'])
@token_required
def get_data(data):
    try:
        domain = data.get('domain')

        cur = mysql.connection.cursor()
        cur.execute("SELECT grupo_zabbix FROM empresa WHERE dominio = %s", (domain,))
        result = cur.fetchone()
        cur.close()

        if result:
            group_name_filter = result['grupo_zabbix']
            print(f"Grupo Zabbix encontrado no banco: {group_name_filter}")
        else:
            return jsonify({"error": "Grupo Zabbix não encontrado para o domínio."}), 404

        # Coletar os dados do Zabbix
        zabbix_data = get_zabbix_data(group_name_filter=group_name_filter)

        return jsonify({"message": "Dados obtidos com sucesso.", "data": zabbix_data})
    except Exception as e:
        print(f"Erro ao processar a solicitação: {str(e)}")
        return jsonify({"error": str(e)}), 500