import sqlite3
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
import time
from datetime import datetime
import os
import requests
from urllib.parse import urlparse
import hashlib
import glob

class FutebolNaTVScraper:
    def __init__(self, db_path='jogos.db'):
        self.db_path = db_path
        self.clean_previous_data()  # Limpa dados anteriores
        self.setup_directories()
        self.setup_database()
        self.setup_driver()
    
    def clean_previous_data(self):
        """Limpa o diretório logo_times e o banco de dados jogos.db"""
        print("🧹 LIMPANDO DADOS ANTERIORES...")
        
        # Limpa o diretório logo_times
        if os.path.exists('logo_times'):
            try:
                # Remove todos os arquivos do diretório
                files = glob.glob('logo_times/*')
                for f in files:
                    try:
                        os.remove(f)
                        print(f"🗑️  Arquivo removido: {f}")
                    except Exception as e:
                        print(f"⚠️  Erro ao remover {f}: {e}")
                
                print("✅ Diretório logo_times limpo")
            except Exception as e:
                print(f"❌ Erro ao limpar logo_times: {e}")
        else:
            print("✅ Diretório logo_times não existe, criando...")
        
        # Limpa o banco de dados
        if os.path.exists(self.db_path):
            try:
                conn = sqlite3.connect(self.db_path)
                cursor = conn.cursor()
                
                # Remove todos os registros da tabela jogos
                cursor.execute('DELETE FROM jogos')
                conn.commit()
                conn.close()
                
                print("✅ Banco de dados jogos.db limpo")
            except Exception as e:
                print(f"❌ Erro ao limpar banco de dados: {e}")
                # Se houver erro, tenta recriar o arquivo
                try:
                    os.remove(self.db_path)
                    print("✅ Arquivo jogos.db removido e será recriado")
                except:
                    print("⚠️  Não foi possível remover o arquivo jogos.db")
        else:
            print("✅ Banco de dados jogos.db não existe, criando...")
    
    def setup_directories(self):
        """Cria o diretório para logos dos times"""
        os.makedirs('logo_times', exist_ok=True)
        print("✅ Diretório 'logo_times' criado/verificado")
    
    def setup_driver(self):
        """Configura o driver do Selenium com Chromium do sistema"""
        chrome_options = Options()
        
        # Configurações para melhor compatibilidade
        chrome_options.add_argument('--headless')
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--disable-dev-shm-usage')
        chrome_options.add_argument('--disable-gpu')
        chrome_options.add_argument('--window-size=1920,1080')
        chrome_options.add_argument('--remote-debugging-port=9222')
        chrome_options.add_argument('--user-agent=Mozilla/5.0 (X11; Linux aarch64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36')
        
        # Usa o Chromium do sistema (compatível com ARM)
        chrome_options.binary_location = '/usr/bin/chromium-browser'
        
        try:
            # Tenta usar o chromedriver do sistema
            service = Service('/usr/bin/chromedriver')
            self.driver = webdriver.Chrome(service=service, options=chrome_options)
            print("✅ Driver do Chromium configurado com sucesso!")
        except Exception as e:
            print(f"❌ Erro ao configurar com chromedriver do sistema: {e}")
            # Fallback: tenta sem service (pode funcionar em algumas versões)
            try:
                self.driver = webdriver.Chrome(options=chrome_options)
                print("✅ Driver do Chromium configurado (sem service)")
            except Exception as e2:
                print(f"❌ Erro no fallback: {e2}")
                raise
    
    def setup_database(self):
        """Cria a tabela no banco de dados SQLite com colunas para logos"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS jogos (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                data_coleta TEXT,
                url TEXT,
                campeonato TEXT,
                rodada TEXT,
                time_casa TEXT,
                time_visitante TEXT,
                horario TEXT,
                data_jogo TEXT,
                canal_transmissao TEXT,
                logo_time_casa TEXT,
                logo_time_visitante TEXT,
                logo_campeonato TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        conn.commit()
        conn.close()
        print("✅ Banco de dados configurado com sucesso!")
    
    def download_logo_with_requests(self, url, nome_time, tipo='time'):
        """Tenta fazer download com headers personalizados"""
        try:
            if not url:
                return None
            
            # Gera um nome de arquivo único
            nome_seguro = hashlib.md5(nome_time.encode()).hexdigest()[:8]
            filename = f"{tipo}_{nome_seguro}.png"
            filepath = os.path.join('logo_times', filename)
            
            # Não precisa verificar se existe porque limpamos o diretório
            # if os.path.exists(filepath):
            #     return filepath
            
            # Headers para simular um navegador real
            headers = {
                'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36',
                'Accept': 'image/webp,image/apng,image/*,*/*;q=0.8',
                'Accept-Language': 'pt-BR,pt;q=0.9,en;q=0.8',
                'Referer': 'https://www.futebolnatv.com.br/',
                'Sec-Fetch-Dest': 'image',
                'Sec-Fetch-Mode': 'no-cors',
                'Sec-Fetch-Site': 'same-origin',
            }
            
            response = requests.get(url, headers=headers, timeout=10)
            response.raise_for_status()
            
            with open(filepath, 'wb') as f:
                f.write(response.content)
            
            print(f"✅ Logo baixada: {filepath}")
            return filepath
            
        except Exception as e:
            print(f"❌ Erro ao baixar logo para {nome_time}: {e}")
            return None
    
    def scrape_jogos_principais(self, url):
        """Raspa apenas os dados principais dos jogos (sem logos)"""
        print(f"🌐 Acessando: {url}")
        try:
            self.driver.get(url)
            
            # Aguarda os elementos carregarem
            WebDriverWait(self.driver, 20).until(
                EC.presence_of_element_located((By.CLASS_NAME, "gamecard"))
            )
            print("✅ Página carregada com sucesso!")
        except Exception as e:
            print(f"❌ Erro ao carregar a página: {e}")
            try:
                self.driver.save_screenshot('erro_pagina.png')
                print("📸 Screenshot salvo como 'erro_pagina.png'")
            except:
                pass
            return []
        
        time.sleep(3)
        
        # Encontra todos os cards
        game_cards = self.driver.find_elements(By.CLASS_NAME, "gamecard")
        print(f"📋 Encontrados {len(game_cards)} cards de jogo")
        
        jogos = []
        
        for i in range(len(game_cards)):
            try:
                print(f"🔍 Processando jogo {i+1}/{len(game_cards)}...")
                
                # Re-encontra os elementos a cada iteração para evitar stale elements
                current_cards = self.driver.find_elements(By.CLASS_NAME, "gamecard")
                if i >= len(current_cards):
                    print(f"⚠️ Card {i+1} não encontrado, pulando...")
                    continue
                    
                card = current_cards[i]
                jogo = self.extract_jogo_data(card)
                
                if jogo and jogo.get('url'):
                    # Salva apenas os dados principais por enquanto (logos serão None)
                    jogos.append(jogo)
                    print(f"✅ Jogo extraído: {jogo['time_casa']} vs {jogo['time_visitante']}")
                    
            except Exception as e:
                print(f"❌ Erro ao extrair jogo {i+1}: {e}")
                continue
        
        return jogos
    
    def extract_jogo_data(self, card):
        """Extrai dados de um card de jogo individual"""
        try:
            # URL do jogo
            link_element = card.find_element(By.TAG_NAME, "a")
            url = link_element.get_attribute("href")
            
            # Informações do campeonato
            campeonato_element = card.find_element(By.CLASS_NAME, "all-scores-widget-competition-header-container-hora")
            campeonato_text = campeonato_element.find_element(By.CLASS_NAME, "col-sm-8").text
            
            # Separa campeonato e rodada
            if " - " in campeonato_text:
                parts = campeonato_text.split(" - ", 1)
                campeonato = parts[0]
                rodada = parts[1]
            else:
                campeonato = campeonato_text
                rodada = ""
            
            # Horário
            horario_element = card.find_element(By.CLASS_NAME, "box_time")
            horario = horario_element.text
            
            # Data do jogo (do atributo data-dt)
            data_dt = horario_element.get_attribute("data-dt")
            data_jogo = data_dt.split()[0] if data_dt else ""
            
            # Times
            time_casa = ""
            time_visitante = ""
            
            try:
                times_elements = card.find_elements(By.CSS_SELECTOR, ".d-flex.justify-content-between.align-items-center.p-3")
                if len(times_elements) >= 2:
                    time_casa = times_elements[0].find_element(By.TAG_NAME, "span").text.strip()
                    time_visitante = times_elements[1].find_element(By.TAG_NAME, "span").text.strip()
            except:
                # Tenta método alternativo
                try:
                    time_spans = card.find_elements(By.CSS_SELECTOR, ".fs-4.endgame span")
                    if len(time_spans) >= 2:
                        time_casa = time_spans[0].text.strip()
                        time_visitante = time_spans[1].text.strip()
                except:
                    pass
            
            # Canal de transmissão
            canal = ""
            try:
                canal_elements = card.find_elements(By.CSS_SELECTOR, ".col.bcmact.ag.bord-n")
                if canal_elements:
                    canal = canal_elements[0].text.strip()
            except:
                pass
            
            jogo_data = {
                'url': url,
                'campeonato': campeonato.replace("<b>", "").replace("</b>", "").strip(),
                'rodada': rodada.strip(),
                'time_casa': time_casa,
                'time_visitante': time_visitante,
                'horario': horario,
                'data_jogo': data_jogo,
                'canal_transmissao': canal,
                'data_coleta': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'logo_time_casa': None,
                'logo_time_visitante': None,
                'logo_campeonato': None
            }
            
            return jogo_data
            
        except Exception as e:
            print(f"❌ Erro na extração de dados do card: {e}")
            return None
    
    def save_jogos_principais(self, jogos):
        """Salva os jogos principais no banco de dados (sem logos ainda)"""
        if not jogos:
            print("⚠️ Nenhum jogo para salvar")
            return
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        for jogo in jogos:
            # Não precisa verificar duplicatas porque limpamos o banco
            cursor.execute('''
                INSERT INTO jogos 
                (data_coleta, url, campeonato, rodada, time_casa, time_visitante, 
                 horario, data_jogo, canal_transmissao, logo_time_casa, 
                 logo_time_visitante, logo_campeonato)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            ''', (
                jogo['data_coleta'],
                jogo['url'],
                jogo['campeonato'],
                jogo['rodada'],
                jogo['time_casa'],
                jogo['time_visitante'],
                jogo['horario'],
                jogo['data_jogo'],
                jogo['canal_transmissao'],
                jogo['logo_time_casa'],
                jogo['logo_time_visitante'],
                jogo['logo_campeonato']
            ))
            print(f"💾 Jogo salvo: {jogo['time_casa']} vs {jogo['time_visitante']}")
        
        conn.commit()
        conn.close()
        
        print(f"💾 Salvos {len(jogos)} jogos no banco de dados")
    
    def scrape_logos_para_jogos_existentes(self):
        """Para cada jogo no banco sem logos, acessa a URL e busca as logos"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # Busca todos os jogos (já que limpamos o banco, todos estarão sem logos)
        cursor.execute('SELECT id, url, time_casa, time_visitante FROM jogos')
        
        todos_jogos = cursor.fetchall()
        print(f"🔍 Buscando logos para {len(todos_jogos)} jogos...")
        
        for jogo in todos_jogos:
            jogo_id, url, time_casa, time_visitante = jogo
            
            print(f"🖼️  Buscando logos para: {time_casa} vs {time_visitante}")
            
            try:
                logos = self.scrape_logos_pagina_jogo(url)
                
                # Atualiza o banco de dados com as logos
                cursor.execute('''
                    UPDATE jogos 
                    SET logo_time_casa = ?, logo_time_visitante = ?, logo_campeonato = ?
                    WHERE id = ?
                ''', (
                    logos['logo_time_casa'],
                    logos['logo_time_visitante'],
                    logos['logo_campeonato'],
                    jogo_id
                ))
                
                conn.commit()
                print(f"✅ Logos atualizadas para jogo ID {jogo_id}")
                
                # Pausa entre requisições
                time.sleep(2)
                
            except Exception as e:
                print(f"❌ Erro ao buscar logos para jogo ID {jogo_id}: {e}")
                continue
        
        conn.close()
    
    def scrape_logos_pagina_jogo(self, url_jogo):
        """Raspa as logos da página individual do jogo"""
        try:
            print(f"🌐 Acessando página do jogo: {url_jogo}")
            self.driver.get(url_jogo)
            
            # Aguarda o carregamento da página
            WebDriverWait(self.driver, 15).until(
                EC.presence_of_element_located((By.CLASS_NAME, "gamecard1"))
            )
            
            time.sleep(2)  # Espera adicional
            
            logos = {
                'logo_time_casa': None,
                'logo_time_visitante': None,
                'logo_campeonato': None
            }
            
            # Raspa logo do campeonato
            try:
                logo_campeonato_element = self.driver.find_element(By.CSS_SELECTOR, ".all-scores-widget-competition-info-logo-container")
                logo_campeonato_url = logo_campeonato_element.get_attribute('src')
                if logo_campeonato_url:
                    logos['logo_campeonato'] = self.download_logo_with_requests(logo_campeonato_url, 'campeonato', 'campeonato')
            except Exception as e:
                print(f"⚠️ Não foi possível raspar logo do campeonato: {e}")
            
            # Raspa logos dos times
            try:
                time_elements = self.driver.find_elements(By.CSS_SELECTOR, ".box_time img.img_plac")
                
                if len(time_elements) >= 2:
                    # Logo do time da casa (primeiro time)
                    logo_casa_url = time_elements[0].get_attribute('src')
                    nome_time_casa = time_elements[0].get_attribute('alt') or 'time_casa'
                    if logo_casa_url:
                        logos['logo_time_casa'] = self.download_logo_with_requests(logo_casa_url, nome_time_casa, 'time_casa')
                    
                    # Logo do time visitante (segundo time)
                    logo_visitante_url = time_elements[1].get_attribute('src')
                    nome_time_visitante = time_elements[1].get_attribute('alt') or 'time_visitante'
                    if logo_visitante_url:
                        logos['logo_time_visitante'] = self.download_logo_with_requests(logo_visitante_url, nome_time_visitante, 'time_visitante')
                
                print(f"✅ Logos encontradas: Casa={logos['logo_time_casa']}, Visitante={logos['logo_time_visitante']}")
                
            except Exception as e:
                print(f"❌ Erro ao raspar logos dos times: {e}")
            
            return logos
            
        except Exception as e:
            print(f"❌ Erro ao acessar página do jogo {url_jogo}: {e}")
            return {'logo_time_casa': None, 'logo_time_visitante': None, 'logo_campeonato': None}
    
    def run_scraping_completo(self):
        """Executa o scraping completo em duas fases"""
        print("🚀 INICIANDO SCRAPING COMPLETO")
        print("=" * 50)
        
        # FASE 1: Raspar jogos principais
        print("\n📋 FASE 1: Raspando jogos principais...")
        urls = [
            "https://www.futebolnatv.com.br/jogos-hoje",
            "https://www.futebolnatv.com.br/jogos-amanha"
        ]
        
        todos_jogos = []
        
        for url in urls:
            try:
                jogos = self.scrape_jogos_principais(url)
                todos_jogos.extend(jogos)
                print(f"✅ Encontrados {len(jogos)} jogos em {url}")
                time.sleep(2)
            except Exception as e:
                print(f"❌ Erro ao raspar {url}: {e}")
        
        if todos_jogos:
            self.save_jogos_principais(todos_jogos)
            print(f"💾 FASE 1 CONCLUÍDA: {len(todos_jogos)} jogos salvos no banco")
        else:
            print("❌ Nenhum jogo encontrado na Fase 1")
            return
        
        # FASE 2: Buscar logos para jogos existentes
        print("\n🖼️  FASE 2: Buscando logos para os jogos...")
        self.scrape_logos_para_jogos_existentes()
        
        print("\n✅ SCRAPING COMPLETO CONCLUÍDO!")
        self.display_estatisticas()
    
    def display_estatisticas(self):
        """Exibe estatísticas finais do scraping"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # Total de jogos
        cursor.execute('SELECT COUNT(*) FROM jogos')
        total_jogos = cursor.fetchone()[0]
        
        # Jogos com logos
        cursor.execute('SELECT COUNT(*) FROM jogos WHERE logo_time_casa IS NOT NULL AND logo_time_visitante IS NOT NULL')
        jogos_com_logos = cursor.fetchone()[0]
        
        # Conta arquivos no diretório logo_times
        if os.path.exists('logo_times'):
            arquivos_logos = len([f for f in os.listdir('logo_times') if os.path.isfile(os.path.join('logo_times', f))])
        else:
            arquivos_logos = 0
        
        conn.close()
        
        print("\n📊 ESTATÍSTICAS FINAIS:")
        print(f"   Total de jogos: {total_jogos}")
        print(f"   Jogos com logos: {jogos_com_logos}")
        print(f"   Arquivos de logos: {arquivos_logos}")
        print(f"   Logos salvas em: {os.path.abspath('logo_times')}")
    
    def display_results(self):
        """Exibe os resultados finais"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT campeonato, rodada, time_casa, time_visitante, horario, 
                   logo_time_casa, logo_time_visitante 
            FROM jogos 
            ORDER BY data_jogo, horario
        ''')
        
        jogos = cursor.fetchall()
        conn.close()
        
        print("\n" + "="*80)
        print("🎯 JOGOS ENCONTRADOS NO BANCO DE DADOS")
        print("="*80)
        
        for i, jogo in enumerate(jogos, 1):
            campeonato, rodada, time_casa, time_visitante, horario, logo_casa, logo_visitante = jogo
            
            print(f"\n⚽ Jogo {i}:")
            print(f"  📊 {campeonato}")
            print(f"  🔢 {rodada}")
            print(f"  🏠 {time_casa} vs {time_visitante} 🚌")
            print(f"  ⏰ {horario}")
            print(f"  🖼️  Logos: Casa={logo_casa}, Visitante={logo_visitante}")
    
    def close(self):
        """Fecha o driver do Selenium"""
        if hasattr(self, 'driver'):
            self.driver.quit()
            print("🔚 Driver fechado")

def main():
    scraper = FutebolNaTVScraper()
    
    try:
        scraper.run_scraping_completo()
        scraper.display_results()
    except Exception as e:
        print(f"❌ Erro durante o scraping: {e}")
    finally:
        scraper.close()

if __name__ == "__main__":
    main()