import requests
from bs4 import BeautifulSoup
import json
import pandas as pd
import time
import random
import logging
from urllib.parse import urljoin
from fake_useragent import UserAgent
from http.client import RemoteDisconnected
from requests.exceptions import RequestException
import mysql.connector
import os
import atexit


# Параметри підключення до MySQL
db_config = {
    "host": "104.236.70.14",  
    "user": "integration",     
    "password": "?Q8/{lVK2N08Y<b>k", 
    "database": "Salsify"  
}

# Підключення до бази даних
try:
    connection = mysql.connector.connect(**db_config)
    # print("Підключення до бази даних успішне.")
except mysql.connector.Error as e:
    # print(f"Помилка підключення: {e}")
    exit()


query = """
SELECT DISTINCT dt.SKU, dt.`Build URL` FROM ProductTracker.DailyTracker dt 
INNER JOIN Salsify.MainData md ON dt.SKU = md.SKU 
WHERE (dt.Date = CURRENT_DATE OR dt.Date = CURRENT_DATE - 1) AND dt.`Build URL` IS NOT NULL AND md.Status IN ('Active', 'Liquidation')
"""


try:

    cursor = connection.cursor(dictionary=True)
    cursor.execute(query)
    results = cursor.fetchall()

    df_input = pd.DataFrame(results)

    # Створення списків
    urls = df_input['Build URL'].dropna().tolist()
    additional_data = df_input['SKU'].tolist()

finally:
    # Закриття з'єднання
    if connection.is_connected():
        cursor.close()
        connection.close()
        # print("З'єднання з базою даних закрито.")

# Налаштування логування
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
VPN_ENABLED = True
WG_CONFIG_DIR = os.environ.get("WG_CONFIG_DIR", "/etc/wireguard")
WG_COOLDOWN_SEC = float(os.environ.get("WG_COOLDOWN_SEC", "2.0"))
VPN_ROTATOR = None

try:
    from wg_vpn import WireGuardRotator
except Exception:
    WireGuardRotator = None


all_data = []

max_retries = 3
timeout = 20

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36"
}

def request_with_vpn(url: str, headers: dict, timeout: int | float):
    try:
        response = requests.get(url, headers=headers, timeout=timeout)
    except Exception as e:
        if VPN_ENABLED and VPN_ROTATOR is not None:
            VPN_ROTATOR.rotate(f"request error: {e}")
        raise
    if VPN_ENABLED and response.status_code != 200:
        if VPN_ROTATOR is not None:
            VPN_ROTATOR.rotate(f"HTTP {response.status_code} for {url}")
        raise requests.HTTPError(f"HTTP {response.status_code} for {url}", response=response)
    return response

# Функція для обробки одного URL
def process_url(url):
    for attempt in range(max_retries):
        try:
            # logging.error()
            response = request_with_vpn(url, headers=headers, timeout=timeout)
            response.raise_for_status()
            soup = BeautifulSoup(response.content, 'html.parser')

            # Пошук всіх тегів <a>, які містять .pdf у href
            links = soup.find_all('a', href=True, target="_blank", rel="noreferrer")
            pdf_links = []
            for link in links:
                href = link.get('href', '-')
                # Перевірка, чи це посилання на PDF
                if '.pdf' in href:
                    # Формуємо повний URL
                    formatted_href = urljoin("https:", href).replace(" ", "")
                    
                    # Витягуємо назву PDF із <span>, якщо є
                    span = link.find('span', class_="pl3 f5")
                    text = span.get_text(strip=True) if span else "-"
                    
                    pdf_links.append({'PDF Link': formatted_href, 'PDF Text': text})

            # Якщо PDF не знайдено, додаємо стандартне повідомлення
            if not pdf_links:
                pdf_links.append({'PDF Link': 'PDF not found', 'PDF Text': 'PDF not found'})

            return pdf_links

        except requests.exceptions.RequestException as e:
            logging.error(f"Помилка для {url}: {e}")
            time.sleep(2 + random.uniform(1, 3))
    logging.error(f"Не вдалося отримати дані з {url} після {max_retries} спроб.")
    return []


if VPN_ENABLED and WireGuardRotator is not None:
    VPN_ROTATOR = WireGuardRotator(WG_CONFIG_DIR, cooldown_sec=WG_COOLDOWN_SEC)
    VPN_ROTATOR.ensure_up()
    atexit.register(VPN_ROTATOR.shutdown)
for i, url in enumerate(urls):
    try:
        data = process_url(url)
        if data:

            row = {'Base URL': urls[i], 'SKU': additional_data[i]}
            for j, item in enumerate(data):
                row[f"PDF Link{j+1}"] = item['PDF Link']
                row[f"PDF Text{j+1}"] = item['PDF Text']
            all_data.append(row)
            logging.error(f"Processed {i} of {len(urls)}")
    except Exception as e:
        temp = ''
    time.sleep(random.uniform(1, 3))  

output_path = os.environ.get("OUTPUT_PATH")
if output_path:
    with open(output_path, "w", encoding="utf-8") as f:
        f.write(json.dumps(all_data))
else:
    print(json.dumps(all_data))