app.py

"""
Web Scraper - Interfaccia Web con Streamlit
Dashboard completa per controllare e monitorare lo scraper
"""

import streamlit as st
import pandas as pd
import json
import os
from datetime import datetime
from pathlib import Path
import sys
import time
from typing import Dict, List, Optional
import queue
import threading
from concurrent.futures import ThreadPoolExecutor

# Importa gli scraper
from scraper_base import WebScraperBase

# Configurazione pagina
st.set_page_config(
    page_title="Web Scraper Dashboard",
    page_icon="🕷️",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Directory per i risultati
RESULTS_DIR = Path("results")
RESULTS_DIR.mkdir(exist_ok=True)

# Inizializza lo stato della sessione
def init_session_state():
    """Inizializza tutte le variabili di sessione"""
    if 'scraping_results' not in st.session_state:
        st.session_state.scraping_results = []
    if 'scraping_logs' not in st.session_state:
        st.session_state.scraping_logs = []
    if 'saved_configs' not in st.session_state:
        st.session_state.saved_configs = []
    if 'last_scrape_time' not in st.session_state:
        st.session_state.last_scrape_time = None
    if 'log_queue' not in st.session_state:
        st.session_state.log_queue = queue.Queue()

# Chiama l'inizializzazione
init_session_state()


def add_log(message: str, level: str = "info"):
    """Aggiunge un messaggio al log in modo thread-safe"""
    try:
        timestamp = datetime.now().strftime("%H:%M:%S")
        log_entry = {
            'timestamp': timestamp,
            'level': level,
            'message': message
        }
        
        # Verifica che scraping_logs esista
        if 'scraping_logs' not in st.session_state:
            st.session_state.scraping_logs = []
        
        st.session_state.scraping_logs.append(log_entry)
        
        # Mantieni solo gli ultimi 100 log
        if len(st.session_state.scraping_logs) > 100:
            st.session_state.scraping_logs = st.session_state.scraping_logs[-100:]
    except Exception as e:
        # Fallback in caso di errore con session_state
        print(f"LOG ERROR [{level}]: {message}")
        print(f"Session state error: {e}")

def add_log_thread_safe(message: str, level: str = "info"):
    """Aggiunge un messaggio al log tramite coda (thread-safe)"""
    try:
        if 'log_queue' in st.session_state:
            st.session_state.log_queue.put((message, level))
        else:
            # Fallback diretto se la coda non è disponibile
            add_log(message, level)
    except Exception:
        # Ultimo fallback
        print(f"LOG [{level}]: {message}")

def process_log_queue():
    """Processa i messaggi dalla coda di log"""
    try:
        if 'log_queue' in st.session_state:
            while not st.session_state.log_queue.empty():
                message, level = st.session_state.log_queue.get()
                add_log(message, level)
    except Exception as e:
        print(f"Error processing log queue: {e}")


def run_scraping_simple(config: Dict):
    """Esegue lo scraping in modo sincrono (senza thread)"""
    try:
        add_log(f"Avvio scraping: {config['url']}", "info")
        
        scraper = WebScraperBase(config['url'])
        soup = scraper.get_page(config['url'])
        
        if soup:
            # Estrai dati usando i selettori
            selectors = {}
            for sel in config.get('selectors', []):
                if sel['name'] and sel['selector']:
                    selectors[sel['name']] = sel['selector']
            
            keyword_filter = config.get('keyword_filter')
            extension_filter = config.get('extension_filter')
            link_selector = config.get('link_selector') or 'a'
            
            if not selectors and not (keyword_filter or extension_filter):
                add_log("⚠️ Imposta almeno un selettore o un filtro (keyword/estensione)", "warning")
                return False
            
            data = scraper.extract_data(soup, selectors) if selectors else []
            filtered_links = scraper.filter_links(
                soup,
                selector=link_selector,
                keyword=keyword_filter,
                file_extension=extension_filter
            ) if (keyword_filter or extension_filter) else []
            
            combined_results = []
            if data:
                combined_results.extend(data)
            if filtered_links:
                combined_results.extend(filtered_links)
            
            if not combined_results:
                add_log("⚠️ Nessun risultato trovato con i criteri forniti", "warning")
                return False
            
            # Assicurati che le variabili di sessione esistano
            if 'scraping_results' not in st.session_state:
                st.session_state.scraping_results = []
            if 'last_scrape_time' not in st.session_state:
                st.session_state.last_scrape_time = None
                
            st.session_state.scraping_results = combined_results
            
            # Salva risultati
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            filename = RESULTS_DIR / f"scraping_{timestamp}.json"
            scraper.save_to_json(combined_results, str(filename))
            
            st.session_state.last_scrape_time = datetime.now()
            
            summary_parts = []
            if data:
                summary_parts.append(f"{len(data)} elementi strutturati")
            if filtered_links:
                summary_parts.append(f"{len(filtered_links)} link filtrati")
            if not summary_parts:
                summary_parts.append(f"{len(combined_results)} elementi")
            
            add_log(f"✅ Scraping completato: {', '.join(summary_parts)}", "success")
            return True
        else:
            add_log("❌ Errore nel caricamento della pagina", "error")
            return False
    
    except Exception as e:
        add_log(f"❌ Errore durante lo scraping: {str(e)}", "error")
        return False

def run_scraping_task(config: Dict):
    """Esegue lo scraping in un thread separato (thread-safe)"""
    try:
        add_log_thread_safe(f"Avvio scraping: {config['url']}", "info")
        
        scraper = WebScraperBase(config['url'])
        soup = scraper.get_page(config['url'])
        
        if soup:
            # Estrai dati usando i selettori
            selectors = {}
            for sel in config.get('selectors', []):
                if sel['name'] and sel['selector']:
                    selectors[sel['name']] = sel['selector']
            
            keyword_filter = config.get('keyword_filter')
            extension_filter = config.get('extension_filter')
            link_selector = config.get('link_selector') or 'a'
            
            if not selectors and not (keyword_filter or extension_filter):
                add_log_thread_safe("⚠️ Imposta almeno un selettore o un filtro (keyword/estensione)", "warning")
                return
            
            data = scraper.extract_data(soup, selectors) if selectors else []
            filtered_links = scraper.filter_links(
                soup,
                selector=link_selector,
                keyword=keyword_filter,
                file_extension=extension_filter
            ) if (keyword_filter or extension_filter) else []
            
            combined_results = []
            if data:
                combined_results.extend(data)
            if filtered_links:
                combined_results.extend(filtered_links)
            
            if not combined_results:
                add_log_thread_safe("⚠️ Nessun risultato trovato con i criteri forniti", "warning")
                return
            
            # Aggiorna i risultati in modo sicuro
            try:
                # Assicurati che le variabili di sessione esistano
                if 'scraping_results' not in st.session_state:
                    st.session_state.scraping_results = []
                if 'last_scrape_time' not in st.session_state:
                    st.session_state.last_scrape_time = None
                    
                st.session_state.scraping_results = combined_results
                
                # Salva risultati
                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
                filename = RESULTS_DIR / f"scraping_{timestamp}.json"
                scraper.save_to_json(combined_results, str(filename))
                
                st.session_state.last_scrape_time = datetime.now()
                
                summary_parts = []
                if data:
                    summary_parts.append(f"{len(data)} elementi strutturati")
                if filtered_links:
                    summary_parts.append(f"{len(filtered_links)} link filtrati")
                if not summary_parts:
                    summary_parts.append(f"{len(combined_results)} elementi")
                
                add_log_thread_safe(f"✅ Scraping completato: {', '.join(summary_parts)}", "success")
            except Exception as state_error:
                add_log_thread_safe(f"❌ Errore aggiornamento stato: {str(state_error)}", "error")
        else:
            add_log_thread_safe("❌ Errore nel caricamento della pagina", "error")
    
    except Exception as e:
        add_log_thread_safe(f"❌ Errore durante lo scraping: {str(e)}", "error")

def run_scraping_async(config: Dict):
    """Avvia lo scraping in un thread separato in modo sicuro"""
    try:
        # Usa ThreadPoolExecutor per una gestione migliore dei thread
        with ThreadPoolExecutor(max_workers=1) as executor:
            future = executor.submit(run_scraping_task, config)
            # Non aspettiamo il risultato per non bloccare l'UI
            return future
    except Exception as e:
        add_log(f"❌ Impossibile avviare il thread di scraping: {str(e)}", "error")
        return None


def main():
    # Processa la coda di log all'inizio
    process_log_queue()
    
    # Header
    st.title("🕷️ Web Scraper Dashboard")
    st.markdown("---")
    
    # Sidebar - Configurazione
    with st.sidebar:
        st.header("⚙️ Configurazione")
        
        # URL target
        url = st.text_input(
            "URL Target",
            placeholder="https://example.com",
            help="URL della pagina da scrapare"
        )
        
        # Selettori CSS
        st.subheader("Selettori CSS")
        
        num_selectors = st.number_input(
            "Numero di selettori",
            min_value=1,
            max_value=10,
            value=3
        )
        
        selectors = []
        for i in range(num_selectors):
            col1, col2 = st.columns(2)
            with col1:
                name = st.text_input(
                    f"Nome {i+1}",
                    key=f"name_{i}",
                    placeholder="titolo"
                )
            with col2:
                selector = st.text_input(
                    f"Selettore {i+1}",
                    key=f"selector_{i}",
                    placeholder="h2.title"
                )
            
            if name and selector:
                selectors.append({'name': name, 'selector': selector})
        
        st.subheader("Filtri Keyword / Estensione (opzionali)")
        keyword_filter_value = st.text_input(
            "Parola chiave (in link o testo)",
            key="keyword_filter_input",
            placeholder="report",
            help="Mantiene solo i risultati che contengono la parola chiave nel testo o nell'URL"
        )
        extension_filter_value = st.text_input(
            "Estensione file (es. pdf)",
            key="extension_filter_input",
            placeholder="pdf",
            help="Inserisci l'estensione da cercare nei link (usa 'pdf' oppure '.pdf')"
        )
        link_selector_value = st.text_input(
            "Selettore link per i filtri",
            key="link_selector_input",
            value="a",
            help="Verrà utilizzato per individuare i link da filtrare (default: 'a')"
        )
        
        keyword_filter = keyword_filter_value.strip() if keyword_filter_value else ""
        extension_filter = extension_filter_value.strip() if extension_filter_value else ""
        link_selector = link_selector_value.strip() if link_selector_value else "a"
        has_filters = bool(keyword_filter or extension_filter)
        
        st.markdown("---")
        
        # Opzione: scegli tra sincrono e asincrono
        use_async = st.checkbox("🚀 Esegui in background (non bloccante)", value=False,
                               help="Esegui lo scraping in background senza bloccare l'interfaccia")
        
        # Pulsante avvio
        if st.button("▶️ Avvia Scraping", use_container_width=True, type="primary"):
            if url and (selectors or has_filters):
                config = {
                    'url': url,
                    'selectors': selectors,
                    'keyword_filter': keyword_filter or None,
                    'extension_filter': extension_filter or None,
                    'link_selector': link_selector or 'a'
                }
                
                if use_async:
                    # Esegui in background
                    future = run_scraping_async(config)
                    if future:
                        st.success("🚀 Scraping avviato in background! Controlla i log per l'avanzamento.")
                        st.rerun()
                    else:
                        st.error("❌ Impossibile avviare lo scraping in background.")
                else:
                    # Esegui in modo sincrono
                    with st.spinner("🔄 Scraping in corso..."):
                        success = run_scraping_simple(config)
                    
                    if success:
                        st.success("✅ Scraping completato!")
                        st.rerun()
                    else:
                        st.error("❌ Scraping fallito. Controlla i log.")
            else:
                st.error("⚠️ Inserisci URL e almeno un selettore o un filtro Keyword/Estensione!")
        
        # Salva/Carica configurazione
        st.markdown("---")
        st.subheader("💾 Configurazioni")
        
        config_name = st.text_input("Nome Configurazione", placeholder="mia_config")
        
        if st.button("Salva Config", use_container_width=True):
            if config_name and url and (selectors or has_filters):
                config = {
                    'name': config_name,
                    'url': url,
                    'selectors': selectors,
                    'keyword_filter': keyword_filter or None,
                    'extension_filter': extension_filter or None,
                    'link_selector': link_selector or 'a'
                }
                # Assicurati che saved_configs esista
                if 'saved_configs' not in st.session_state:
                    st.session_state.saved_configs = []
                st.session_state.saved_configs.append(config)
                st.success(f"✅ Configurazione '{config_name}' salvata!")
        
        # Assicurati che saved_configs esista
        if 'saved_configs' not in st.session_state:
            st.session_state.saved_configs = []
            
        if st.session_state.saved_configs:
            selected_config = st.selectbox(
                "Carica Configurazione",
                [""] + [c['name'] for c in st.session_state.saved_configs]
            )
            
            if selected_config:
                st.info(f"ℹ️ Configurazione '{selected_config}' selezionata. Clicca 'Avvia Scraping' per usarla (selettori e filtri inclusi).")
    
    # Main content
    tab1, tab2, tab3, tab4 = st.tabs(["📊 Risultati", "📝 Log", "📁 File Salvati", "📖 Guida"])
    
    # Tab 1: Risultati
    with tab1:
        st.header("Risultati Scraping")
        
        # Assicurati che le variabili di sessione esistano
        if 'scraping_results' not in st.session_state:
            st.session_state.scraping_results = []
        if 'last_scrape_time' not in st.session_state:
            st.session_state.last_scrape_time = None
            
        if st.session_state.scraping_results:
            # Statistiche
            col1, col2, col3 = st.columns(3)
            with col1:
                st.metric("Elementi Estratti", len(st.session_state.scraping_results))
            with col2:
                st.metric("Campi", len(st.session_state.scraping_results[0].keys()) if st.session_state.scraping_results else 0)
            with col3:
                if st.session_state.last_scrape_time:
                    st.metric("Ultimo Scraping", st.session_state.last_scrape_time.strftime("%H:%M:%S"))
            
            st.markdown("---")
            
            # Visualizza dati
            df = pd.DataFrame(st.session_state.scraping_results)
            
            # Filtri
            st.subheader("Filtri")
            search = st.text_input("🔍 Cerca", placeholder="Cerca nei risultati...")
            
            # Applica filtri
            if search:
                mask = df.astype(str).apply(lambda x: x.str.contains(search, case=False, na=False)).any(axis=1)
                df = df[mask]
            
            # Mostra tabella
            st.dataframe(df, use_container_width=True, height=400)
            
            # Download
            st.markdown("---")
            st.subheader("📥 Download")
            
            col1, col2 = st.columns(2)
            
            with col1:
                # Assicurati che scraping_results esista
                if 'scraping_results' not in st.session_state:
                    st.session_state.scraping_results = []
                json_data = json.dumps(st.session_state.scraping_results, ensure_ascii=False, indent=2)
                st.download_button(
                    "⬇️ Download JSON",
                    json_data,
                    file_name=f"scraping_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
                    mime="application/json",
                    use_container_width=True
                )
            
            with col2:
                csv_data = df.to_csv(index=False)
                st.download_button(
                    "⬇️ Download CSV",
                    csv_data,
                    file_name=f"scraping_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
                    mime="text/csv",
                    use_container_width=True
                )
        else:
            st.info("👆 Configura e avvia uno scraping per vedere i risultati")
            
            # Esempio
            with st.expander("💡 Esempio di configurazione"):
                st.code("""
URL: https://example.com
                
Selettori:
- Nome: titolo    | Selettore: h1
- Nome: testo     | Selettore: p.description
- Nome: link      | Selettore: a.read-more
                """)
    
    # Tab 2: Log
    with tab2:
        st.header("Log Attività")
        
        # Processa eventuali log in coda
        process_log_queue()
        
        col1, col2 = st.columns([3, 1])
        with col2:
            if st.button("🗑️ Pulisci Log", use_container_width=True):
                st.session_state.scraping_logs = []
                st.rerun()
        
        # Assicurati che la lista esista
        if 'scraping_logs' not in st.session_state:
            st.session_state.scraping_logs = []
        
        if st.session_state.scraping_logs:
            for log in reversed(st.session_state.scraping_logs[-50:]):  # Ultimi 50
                level_emoji = {
                    'info': 'ℹ️',
                    'success': '✅',
                    'warning': '⚠️',
                    'error': '❌'
                }
                
                level_color = {
                    'info': 'blue',
                    'success': 'green',
                    'warning': 'orange',
                    'error': 'red'
                }
                
                st.markdown(
                    f":{level_color.get(log['level'], 'gray')}[{level_emoji.get(log['level'], '•')} "
                    f"`{log['timestamp']}` {log['message']}]"
                )
        else:
            st.info("Nessun log disponibile")
    
    # Tab 3: File Salvati
    with tab3:
        st.header("File Salvati")
        
        files = list(RESULTS_DIR.glob("*.json"))
        
        if files:
            st.write(f"📁 Trovati {len(files)} file")
            
            for file in sorted(files, reverse=True)[:20]:  # Ultimi 20
                col1, col2, col3 = st.columns([3, 1, 1])
                
                with col1:
                    st.text(file.name)
                
                with col2:
                    size_kb = file.stat().st_size / 1024
                    st.text(f"{size_kb:.1f} KB")
                
                with col3:
                    with open(file, 'r', encoding='utf-8') as f:
                        data = f.read()
                    st.download_button(
                        "⬇️",
                        data,
                        file_name=file.name,
                        mime="application/json",
                        key=f"download_{file.name}"
                    )
        else:
            st.info("Nessun file salvato")
    
    # Tab 4: Guida
    with tab4:
        st.header("📖 Guida Rapida")
        
        st.markdown("""
        ### Come usare il Web Scraper
        
        #### 1. Configurazione
        1. Inserisci l'**URL** della pagina da scrapare
        2. Aggiungi i **selettori CSS** per i dati da estrarre
        3. (Opzionale) Imposta i **Filtri Keyword / Estensione** per cercare link specifici
        4. Clicca **Avvia Scraping**
        
        #### 2. Selettori CSS
        I selettori CSS identificano gli elementi HTML:
        
        | Esempio | Significato |
        |---------|-------------|
        | `h2.title` | Tag h2 con classe "title" |
        | `#main-content` | Elemento con id "main-content" |
        | `a[href*="blog"]` | Link che contengono "blog" |
        | `div > p` | Paragrafi figli diretti di div |
        
        #### 2-bis. Filtri Keyword / Estensione
        - Campo **Parola chiave**: trova link o testi che contengono la parola indicata
        - Campo **Estensione file**: limita i risultati ai link che terminano con l'estensione scelta (es. `pdf`, `csv`)
        - Puoi usare i filtri anche senza definire selettori quando ti servono solo i link corrispondenti
        
        #### 3. Trovare i Selettori
        1. Apri la pagina web nel browser
        2. Premi **F12** per aprire DevTools
        3. Clicca sull'icona **Ispeziona** (freccia)
        4. Clicca sull'elemento che vuoi scrapare
        5. Copia il selettore CSS
        
        #### 4. Esempi Pratici
        
        **Esempio 1: Titoli di articoli**
        ```
        Nome: titolo
        Selettore: h2.article-title
        ```
        
        **Esempio 2: Prezzi prodotti**
        ```
        Nome: prezzo
        Selettore: span.price
        ```
        
        **Esempio 3: Link**
        ```
        Nome: url
        Selettore: a.read-more
        ```
        
        #### 5. Best Practices
        - ✅ Testa i selettori nel browser prima
        - ✅ Usa selettori specifici
        - ✅ Rispetta i robots.txt
        - ✅ Non sovraccaricare i server
        - ✅ Verifica i termini di servizio
        
        #### 6. Limitazioni Versione Base
        Questa versione supporta solo **siti HTML statici**.
        
        **Non supporta:**
        - ❌ Siti con JavaScript
        - ❌ Contenuti caricati dinamicamente
        - ❌ Scroll infinito
        - ❌ Interazioni (click, form)
        
        Per queste funzionalità, usa lo scraper avanzato localmente.
        
        ### Risoluzione Problemi
        
        **Nessun dato estratto?**
        - Verifica i selettori CSS
        - Controlla che la pagina sia accessibile
        - Alcuni siti bloccano i bot
        
        **Dati incompleti?**
        - Il selettore potrebbe non essere specifico
        - Prova selettori diversi
        - Verifica nel browser
        
        ### Supporto
        Controlla i **Log** per vedere eventuali errori!
        """)
    
    # Footer
    st.markdown("---")
    st.markdown(
        "<div style='text-align: center; color: gray;'>"
        "🕷️ Web Scraper Dashboard | Made with Streamlit"
        "</div>",
        unsafe_allow_html=True
    )


if __name__ == "__main__":
    main()