import requests
import random
import os
import hashlib
import mysql.connector
from PIL import Image
from io import BytesIO
from deep_translator import GoogleTranslator
import cairosvg
import time
import re  # Adicionado para validação de tokens

# Configuração do banco de dados
DB_CONFIG = {
    "host": "localhost",
    "user": "victor",
    "password": "toninho13",
    "database": "qualifica_brasil"
}

# Configuração das APIs de imagens
API_KEYS = {
    "pexels": ["s0n5sD62LD1ET94Wxt2uyySPoaQfnmUeaMUuU1YY33sg1Snvi2evRnbV"],
    "unsplash": ["SEU_TOKEN_UNSPLASH"],
    "pixabay": ["SEU_TOKEN_PIXABAY"],
    "openverse": []  # Openverse não exige token
}

API_URLS = {
    "pexels": "https://api.pexels.com/v1/search",
    "unsplash": "https://api.unsplash.com/search/photos",
    "pixabay": "https://pixabay.com/api/",
    "openverse": "https://api.openverse.engineering/v1/images/"
}

# pexels s0n5sD62LD1ET94Wxt2uyySPoaQfnmUeaMUuU1YY33sg1Snvi2evRnbV
#
# Unsplash Access Key - 5VERLgULUrKSOqQY2YnJ88Ineo8RnBvY54Yr_SznR5A
# Unsplash Secret Key - IFD_LptdbaTpJE4TGGLS-k8-guy3wIc4pYTTFXXDgp4

os.makedirs("imagens_cursos", exist_ok=True)

def log(msg):
    """Imprime mensagens de log com timestamp"""
    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}")

def traduzir_texto(texto, destino="en"):
    """Traduz um texto para o inglês."""
    log(f"Traduzindo: {texto} -> {destino}")
    try:
        traduzido = GoogleTranslator(source="auto", target=destino).translate(texto)
        log(f"Tradução concluída: {traduzido}")
        return traduzido
    except Exception as e:
        log(f"⚠️ Erro ao traduzir '{texto}': {e}")
        return texto  

def escolher_token(api):
    """Escolhe um token aleatório para a API."""
    return random.choice(API_KEYS[api]) if API_KEYS[api] else None

def gerar_hash(nome):
    """Gera um hash SHA1 para nomes de arquivos únicos."""
    hash_obj = hashlib.sha1(nome.encode())
    return hash_obj.hexdigest()[:10]

def validar_tokens(tokens):
    """Remove tokens inválidos (números, telefones ou caracteres especiais isolados)."""
    if not tokens or re.fullmatch(r"[\s\d\-\(\)\.]+", tokens):
        return False
    return True

def buscar_imagem(tokens):
    """Busca imagens nas APIs e retorna a melhor opção."""
    if not tokens:
        log("⚠️ Nenhum token de busca disponível.")
        return None

    melhores_tokens = " ".join(tokens.split("|")[:5])

    if not validar_tokens(melhores_tokens):
        log(f"⚠️ Tokens inválidos ignorados: {melhores_tokens}")
        return None

    tokens_traduzidos = traduzir_texto(melhores_tokens, "en")

    log(f"📌 Tokens originais: {melhores_tokens}")
    log(f"📌 Tokens traduzidos: {tokens_traduzidos}")

    for api in ["pexels", "unsplash", "pixabay", "openverse"]:
        token = escolher_token(api)
        params = {"query": tokens_traduzidos, "per_page": 3}  
        headers = {"Authorization": token} if token else {}
        if api == "pixabay":
            params["key"] = token  

        log(f"🔍 Buscando imagens na API: {api}")

        try:
            response = requests.get(API_URLS[api], headers=headers, params=params, timeout=5)
            if response.status_code == 401:
                log(f"⚠️ Erro de autenticação na API {api}. Verifique o token.")
                continue
            if response.status_code != 200:
                log(f"⚠️ Erro ao buscar na API {api}: {response.status_code}")
                continue

            data = response.json()
            img_urls = []

            if api == "pexels":
                img_urls = [photo["src"]["large"] for photo in data.get("photos", [])]
            elif api == "unsplash":
                img_urls = [result["urls"]["regular"] for result in data.get("results", [])]
            elif api == "pixabay":
                img_urls = [hit["largeImageURL"] for hit in data.get("hits", [])]
            elif api == "openverse":
                img_urls = [result["url"] for result in data.get("results", [])]

            if not img_urls:
                log(f"⚠️ Nenhuma imagem encontrada na API {api}.")
                continue

            for img_url in img_urls:
                if "wikimedia.org" not in img_url:
                    return salvar_imagem(img_url, tokens_traduzidos)

            log("⚠️ Todas as imagens eram do Wikimedia. Tentando outra API...")
        
        except requests.exceptions.RequestException as e:
            log(f"⚠️ Erro ao conectar à API {api}: {e}")

    log("⚠️ Nenhuma imagem válida encontrada.")
    return None

def salvar_imagem(img_url, curso):
    """Baixa e salva a imagem no diretório."""
    log(f"🔹 Baixando imagem de: {img_url}")

    response = requests.get(img_url, timeout=5)
    content_type = response.headers.get("Content-Type", "")

    hash_nome = gerar_hash(curso)

    if "svg" in content_type:
        log(f"🔄 Convertendo SVG para PNG: {img_url}")
        nome_arquivo = f"imagens_cursos/{curso.replace(' ', '_')}_{hash_nome}.png"
        cairosvg.svg2png(bytestring=response.content, write_to=nome_arquivo)
        return nome_arquivo

    nome_arquivo = f"imagens_cursos/{curso.replace(' ', '_')}_{hash_nome}.jpg"
    with open(nome_arquivo, "wb") as file:
        file.write(response.content)

    log(f"✅ Imagem salva como: {nome_arquivo}")
    return nome_arquivo

def obter_tokens():
    """Executa a query no MySQL para obter os tokens de busca e IDs dos títulos."""
    log("Conectando ao banco de dados...")
    conn = mysql.connector.connect(**DB_CONFIG)
    cursor = conn.cursor(dictionary=True)

    log("Executando consulta SQL...")
    cursor.execute("""
        SELECT t2.titulo2 AS tokens_de_busca,
               GROUP_CONCAT(t2.id) AS atribuicao
        FROM (
            SELECT DISTINCT nome_tipo_classificacao,
                            t1.titulo AS titulo2,
                            t1.id_titulo AS id
            FROM (
                SELECT GROUP_CONCAT(
                           CASE
                               WHEN ct.id_tipo_token IN (1, 2, 3, 4, 7, 20, 22)
                               THEN t.nome_token
                               ELSE NULL
                           END
                           ORDER BY ordem SEPARATOR '|'
                       ) AS titulo,
                       id_titulo
                FROM tokens t
                LEFT JOIN frases ON id_token = id_chave_token
                LEFT JOIN classificacoes_tokens ct ON ct.nome_token = acentuada
                GROUP BY id_titulo
            ) t1
            LEFT JOIN campos_cursos cc ON t1.id_titulo = cc.id_titulo
            LEFT JOIN tipos_classificacoes tc ON id_chave_tipo_classificacao = cc.id_tipo_classificacao
            WHERE nome_tipo_classificacao = "curso"
               OR nome_tipo_classificacao = "titulo_do_curso"
        ) AS t2
        GROUP BY t2.titulo2;
    """)

    resultados = cursor.fetchall()
    conn.close()

    log(f"Consulta finalizada. {len(resultados)} registros encontrados.")

    tokens_list = []
    for row in resultados:
        tokens_de_busca = row["tokens_de_busca"] if row["tokens_de_busca"] is not None else ""
        id_titulos = row["atribuicao"].split(",") if row["atribuicao"] else []
        tokens_list.append({"tokens_de_busca": tokens_de_busca, "id_titulos": id_titulos})

    return tokens_list


def gerar_inserts():
    """Obtém tokens do banco e busca imagens."""
    log("🔎 Obtendo tokens do banco de dados...")
    dados = obter_tokens()

    for dado in dados:
        tokens_de_busca = dado["tokens_de_busca"]
        buscar_imagem(tokens_de_busca)

# Executar busca
gerar_inserts()