import requests
import pyodbc
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading
import time
from datetime import datetime, timedelta

# ==============================
# Conexão com o banco de dados
# ==============================

DB_CONNECTION_STRING = (
    'DRIVER={ODBC Driver 18 for SQL Server};'
    'SERVER=10.77.77.10;'
    'DATABASE=GINSENG;'
    'UID=supginseng;'
    'PWD=Ginseng@;'
    'PORT=1433;'
    'TrustServerCertificate=yes'
)

# Configurações de paralelismo
MAX_WORKERS = 5          # Número de requisições paralelas
PAGE_SIZE = 50           # Itens por página
MAX_RETRIES = 5          # Máximo de tentativas por página (dentro do paralelo)
RETRY_DELAY = 5          # Segundos entre tentativas
FINAL_RETRY_DELAY = 30   # Segundos entre rodadas de retry final

# Lock para print thread-safe
print_lock = threading.Lock()

# Estatísticas globais
stats = {
    "pages_downloaded": 0,
    "pages_failed": 0,
    "items_downloaded": 0,
    "items_inserted": 0,
    "errors": 0
}
stats_lock = threading.Lock()

# ==============================
# 1) Buscar token da API
# ==============================

def get_token():
    url = "https://api.grupoginseng.com.br/api/rgb_token"
    response = requests.get(url)

    if response.status_code != 200:
        raise Exception(f"Erro ao buscar token: {response.status_code} {response.text}")

    data = response.json()
    token = data["data"][0]["token"]
    return token


# ==============================
# 2) Consultar produtos
# ==============================

def insert_items_to_db(cursor, items):
    """Insere uma lista de itens no banco de dados, deletando SKUs existentes antes"""

    # Query para deletar SKU existente
    delete_query = "DELETE FROM [dbo].[rgb_product] WHERE [sku] = ?"

    insert_query = """
    INSERT INTO [dbo].[rgb_product] (
        [sku], [marketId], [tacticId], [strategicId], [brand], [internalCode],
        [description], [discontinued], [purpose], [discountAllowed], [maxDiscount],
        [createdAt], [discontinuedDate], [updatedAt], [ncmId], [cest],
        [grossWeight], [netWeight], [purchaseBlocked]
    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    """

    inserted = 0
    deleted = 0
    for item in items:
        try:
            sku = item.get("id")

            # 1. Deletar SKU se já existir
            cursor.execute(delete_query, sku)
            if cursor.rowcount > 0:
                deleted += cursor.rowcount

            # 2. Inserir o novo registro
            cursor.execute(insert_query,
                sku,
                item.get("marketId"),
                item.get("tacticId"),
                item.get("strategicId"),
                item.get("brand"),
                item.get("internalCode"),
                item.get("description"),
                item.get("discontinued"),
                item.get("purpose"),
                item.get("discountAllowed"),
                item.get("maxDiscount"),
                item.get("createdAt"),
                item.get("discontinuedDate"),
                item.get("updatedAt"),
                item.get("ncmId"),
                item.get("cest"),
                item.get("grossWeight"),
                item.get("netWeight"),
                item.get("purchaseBlocked")
            )
            inserted += 1
        except Exception as e:
            with stats_lock:
                stats["errors"] += 1
                if stats["errors"] <= 5:
                    print(f"  ✗ Erro ao inserir SKU {item.get('id')}: {e}")

    # Atualizar estatística de deletados
    with stats_lock:
        stats["skus_updated"] = stats.get("skus_updated", 0) + deleted

    return inserted


def fetch_and_insert_page(token, start, total_pages, cursor, db_lock):
    """Busca uma página específica com retry e insere no banco imediatamente"""
    url = "https://api.grupoboticario.com.br/global/v1/franchising/gb-stores-data/product/products"

    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json"
    }

    # Data de ontem para filtrar produtos atualizados
    yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")

    params = {
        "count": PAGE_SIZE,
        "start": start,
        "product.updatedAt": yesterday
    }

    page_num = (start // PAGE_SIZE) + 1

    for attempt in range(1, MAX_RETRIES + 1):
        try:
            response = requests.get(url, headers=headers, params=params, timeout=60)

            if response.status_code == 200:
                data = response.json()
                items = data.get("items", [])

                # Inserir no banco imediatamente (com lock para thread-safety)
                with db_lock:
                    inserted = insert_items_to_db(cursor, items)
                    cursor.connection.commit()

                with stats_lock:
                    stats["pages_downloaded"] += 1
                    stats["items_downloaded"] += len(items)
                    stats["items_inserted"] += inserted

                with print_lock:
                    print(f"  ✓ Página {page_num}/{total_pages}: {len(items)} baixados, {inserted} inseridos (Total: {stats['items_inserted']})")

                return {"start": start, "success": True}
            else:
                with print_lock:
                    print(f"  ✗ Página {page_num} (start={start}): Erro {response.status_code} - Tentativa {attempt}/{MAX_RETRIES}")

        except Exception as e:
            with print_lock:
                print(f"  ✗ Página {page_num} (start={start}): {str(e)[:50]} - Tentativa {attempt}/{MAX_RETRIES}")

        if attempt < MAX_RETRIES:
            time.sleep(RETRY_DELAY)

    with stats_lock:
        stats["pages_failed"] += 1

    return {"start": start, "success": False}


def get_total_products(token, date_filter):
    """Faz uma requisição inicial para descobrir o total de produtos"""
    url = "https://api.grupoboticario.com.br/global/v1/franchising/gb-stores-data/product/products"

    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json"
    }

    params = {
        "count": 1,
        "start": 0,
        "product.updatedAt": date_filter
    }

    response = requests.get(url, headers=headers, params=params, timeout=60)

    if response.status_code == 200:
        data = response.json()
        return data.get("total", 0)

    return None


def fetch_and_insert_all_products(token):
    """Consulta todos os produtos com paginação paralela e insere no banco imediatamente"""

    # Calcular data de ontem (dia anterior)
    yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")

    print(f"Consultando produtos e inserindo no banco...")
    print(f"  Filtro de data: {yesterday} (produtos atualizados ontem)")

    # Reset stats
    global stats
    stats = {
        "pages_downloaded": 0,
        "pages_failed": 0,
        "items_downloaded": 0,
        "items_inserted": 0,
        "errors": 0,
        "skus_updated": 0  # SKUs que já existiam e foram atualizados
    }

    # 1. Descobrir o total de produtos
    print("  Descobrindo total de produtos...")
    total = get_total_products(token, yesterday)

    if total is None:
        print("  ✗ Erro ao descobrir total de produtos")
        return None

    print(f"  Total de produtos na API: {total}")

    if total == 0:
        print(f"  ⚠ Nenhum produto atualizado em {yesterday}")
        return stats

    # 2. Calcular páginas necessárias
    total_pages = (total + PAGE_SIZE - 1) // PAGE_SIZE
    starts = [i * PAGE_SIZE for i in range(total_pages)]

    print(f"  Total de páginas: {total_pages}")
    print(f"  Requisições paralelas: {MAX_WORKERS}")

    # 3. Preparar banco de dados
    print("  Preparando banco de dados...")
    conn = pyodbc.connect(DB_CONNECTION_STRING)
    cursor = conn.cursor()

    print(f"  Estratégia: Deletar SKU existente antes de inserir (upsert)")
    print(f"  Iniciando download e inserção...\n")

    # Lock para acesso ao banco (uma conexão compartilhada)
    db_lock = threading.Lock()

    # 4. Buscar páginas em paralelo e inserir imediatamente
    failed_pages = []

    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
        futures = {executor.submit(fetch_and_insert_page, token, start, total_pages, cursor, db_lock): start for start in starts}

        for future in as_completed(futures):
            result = future.result()

            if not result["success"]:
                failed_pages.append(result["start"])

    # 5. Verificar páginas que falharam - continua tentando até todas serem bem-sucedidas
    retry_round = 0
    while failed_pages:
        retry_round += 1
        print(f"\n  ⚠ Rodada de retry #{retry_round}: {len(failed_pages)} páginas falharam")
        print(f"  Páginas: {failed_pages[:10]}{'...' if len(failed_pages) > 10 else ''}")
        print(f"  Aguardando {FINAL_RETRY_DELAY} segundos antes de tentar novamente...")
        time.sleep(FINAL_RETRY_DELAY)

        still_failed = []
        for start in failed_pages:
            result = fetch_and_insert_page(token, start, total_pages, cursor, db_lock)
            if not result["success"]:
                still_failed.append(start)

        failed_pages = still_failed

        if failed_pages:
            print(f"  Ainda restam {len(failed_pages)} páginas com falha. Tentando novamente...")

    # Fechar conexão
    cursor.close()
    conn.close()

    print(f"\n  Download e inserção concluídos!")

    return stats


# ==============================
# EXECUTAR
# ==============================

if __name__ == "__main__":
    print("="*60)
    print("RGB PRODUCTS - Consulta de Produtos")
    print("="*60)

    # 1. Buscar token
    print("\n[1/2] Buscando token...")
    token = get_token()
    print(f"✓ Token obtido com sucesso!")
    print(f"  Token: {token[:50]}...")

    # 2. Consultar produtos e inserir no banco (paralelo)
    print("\n[2/2] Baixando e inserindo produtos...")
    result = fetch_and_insert_all_products(token)

    if result:
        print(f"\n{'='*60}")
        print("RESUMO FINAL")
        print(f"{'='*60}")
        print(f"  Páginas baixadas:    {result['pages_downloaded']}")
        print(f"  Páginas com falha:   {result['pages_failed']}")
        print(f"  Itens baixados:      {result['items_downloaded']}")
        print(f"  Itens inseridos:     {result['items_inserted']}")
        print(f"  SKUs atualizados:    {result.get('skus_updated', 0)} (já existiam)")
        print(f"  Erros de inserção:   {result['errors']}")
        print(f"{'='*60}")

        if result['pages_failed'] == 0 and result['errors'] == 0:
            print("✓ SUCESSO TOTAL!")
        else:
            print("⚠ Concluído com alguns problemas")
    else:
        print("\n✗ Não foi possível obter os produtos.")