import requests
import random
import os
import hashlib
import mysql.connector

# 🔹 Configuração do banco de dados MySQL
DB_CONFIG = {
    "host": "localhost",
    "user": "victor",
    "password": "sua_senha",
    "database": "seu_banco"
}

# 🔹 Configuração das APIs de imagens com múltiplos tokens
API_KEYS = {
    "pexels": ["PEXELS_TOKEN_1", "PEXELS_TOKEN_2"],
    "unsplash": ["UNSPLASH_TOKEN_1", "UNSPLASH_TOKEN_2"],
    "pixabay": ["PIXABAY_TOKEN_1", "PIXABAY_TOKEN_2"],
    "openverse": []  # Openverse não exige token
}

# 🔹 URLs das APIs
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/"
}

# 🔹 Criar pasta para armazenar as imagens
os.makedirs("imagens_cursos", exist_ok=True)

def obter_tokens():
    """Executa a query no MySQL para obter os tokens de busca e ids dos títulos."""
    conn = mysql.connector.connect(**DB_CONFIG)
    cursor = conn.cursor()

    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()
    
    return [{"tokens_de_busca": row[0], "id_titulos": row[1].split(",")} for row in resultados]

def escolher_token(api):
    """Escolhe um token aleatório da API (se houver múltiplos tokens disponíveis)."""
    return random.choice(API_KEYS[api]) if API_KEYS[api] else None

def gerar_hash(nome):
    """Gera um hash SHA1 aleatório para evitar duplicação de nomes."""
    hash_obj = hashlib.sha1(nome.encode())
    return hash_obj.hexdigest()[:10]

def buscar_imagem(tokens):
    """Busca imagens com base nos tokens e baixa a melhor opção."""
    melhores_tokens = " ".join(tokens.split("|")[:5])  # Usa os primeiros 5 tokens como base

    for api in ["pexels", "unsplash", "pixabay", "openverse"]:
        token = escolher_token(api)
        params = {"query": melhores_tokens, "per_page": 1}

        headers = {"Authorization": token} if token else {}
        if api == "pixabay":
            params["key"] = token  # Pixabay usa o token como parâmetro

        response = requests.get(API_URLS[api], headers=headers, params=params)
        
        if response.status_code == 200:
            data = response.json()
            img_url = None

            if api == "pexels" and "photos" in data and data["photos"]:
                img_url = data["photos"][0]["src"]["large"]
            elif api == "unsplash" and "results" in data and data["results"]:
                img_url = data["results"][0]["urls"]["regular"]
            elif api == "pixabay" and "hits" in data and data["hits"]:
                img_url = data["hits"][0]["largeImageURL"]
            elif api == "openverse" and "results" in data and data["results"]:
                img_url = data["results"][0]["url"]

            if img_url:
                return salvar_imagem(img_url, melhores_tokens)

        print(f"Nenhuma imagem encontrada para '{melhores_tokens}' em {api}. Tentando outra API...")

    return None

def salvar_imagem(img_url, curso):
    """Baixa e salva a imagem no diretório local com um hash no nome."""
    img_data = requests.get(img_url).content
    hash_nome = gerar_hash(curso)
    nome_arquivo = f"imagens_cursos/{curso.replace(' ', '_')}_{hash_nome}.jpg"

    with open(nome_arquivo, "wb") as file:
        file.write(img_data)

    return nome_arquivo

def gerar_inserts():
    """Gera os INSERTS para as tabelas imagens e titulos_imagens."""
    dados = obter_tokens()
    inserts_imagens = []
    inserts_titulos_imagens = []

    for dado in dados:
        tokens = dado["tokens_de_busca"]
        id_titulos = dado["id_titulos"]

        nome_imagem = buscar_imagem(tokens)
        if nome_imagem:
            # Criar SQL para registrar a imagem na tabela `imagens`
            insert_imagem = f"INSERT IGNORE INTO imagens (nome_imagem) VALUES ('{nome_imagem}');"
            inserts_imagens.append(insert_imagem)

            # Criar SQL para vincular a imagem com os títulos na tabela `titulos_imagens`
            for id_titulo in id_titulos:
                insert_titulo_imagem = f"""
                    INSERT IGNORE INTO titulos_imagens (nome_titulo_imagem, id_imagem, id_titulo)
                    VALUES ('{nome_imagem}', (SELECT id_chave_imagem FROM imagens WHERE nome_imagem = '{nome_imagem}'), {id_titulo});
                """
                inserts_titulos_imagens.append(insert_titulo_imagem)

    return inserts_imagens, inserts_titulos_imagens

# 🔹 Gerar os INSERTS
inserts_imagens, inserts_titulos_imagens = gerar_inserts()

# 🔹 Exibir os comandos SQL gerados
print("\n-- INSERTS PARA IMAGENS --")
print("\n".join(inserts_imagens))

print("\n-- INSERTS PARA TITULOS_IMAGENS --")
print("\n".join(inserts_titulos_imagens))