import requests
from bs4 import BeautifulSoup
import pandas as pd
from textblob import TextBlob
import tkinter as tk
from tkinter import scrolledtext
import threading
from PyPDF2 import PdfReader
from docx import Document
from newspaper import Article
import webbrowser  # Importat la începutul scriptului

class ArticleWindow:
    """Clasă pentru afișarea conținutului într-o fereastră mică."""
    def __init__(self, title, content, url):
        self.root = tk.Tk()
        # Asigurăm că titlul este un string și îl trunchiem dacă este prea lung
        self.root.title(str(title)[:50] + "..." if len(str(title)) > 50 else str(title))
        
        # Creăm un text area cu scroll
        self.text_area = scrolledtext.ScrolledText(self.root, wrap=tk.WORD, width=50, height=10)
        self.text_area.pack(padx=10, pady=10)
        self.text_area.insert(tk.END, content)
        self.text_area.config(state='disabled')
        
        # Creăm un label pentru URL care poate fi clicat
        link_label = tk.Label(self.root, text=url, fg="blue", cursor="hand2")
        link_label.pack(pady=5)
        # Legăm evenimentul de clic pentru a deschide URL-ul în browser
        link_label.bind("<Button-1>", lambda e: webbrowser.open(url))
        
        self.root.mainloop()

class InfoGatherer:
    def __init__(self, api_key, sites_file):
        self.api_key = api_key
        # Corectăm URL-ul API-ului Bing
        self.base_url = "https://api.bing.microsoft.com/v7.0/search"
        self.headers = {"Ocp-Apim-Subscription-Key": self.api_key}
        self.data = []
        self.keywords = []
        self.sites = self.load_sites_from_file(sites_file)
    
    def load_sites_from_file(self, sites_file):
        """Încarcă lista de site-uri din fișierul TXT."""
        try:
            with open(sites_file, 'r', encoding='utf-8') as f:
                sites = [line.strip() for line in f if line.strip()]
            return sites
        except FileNotFoundError:
            print(f"Eroare: Fișierul '{sites_file}' nu a fost găsit.")
            return []
        except Exception as e:
            print(f"Eroare la încărcarea fișierului de site-uri: {e}")
            return []

    def set_keywords(self, keywords):
        """Setează cuvintele cheie pentru căutare."""
        self.keywords = keywords

    def generate_query(self, keyword, site):
        """Generează interogarea de căutare pentru un cuvânt cheie și un site."""
        return f"{keyword} site:{site}"

    def fetch_results(self, keyword, site):
        """Preia rezultatele căutării pentru un cuvânt cheie și un site."""
        query = self.generate_query(keyword, site)
        params = {'q': query}
        try:
            response = requests.get(self.base_url, headers=self.headers, params=params, timeout=30)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Eroare la preluarea rezultatelor pentru '{query}': {e}")
            return None

    def parse_results(self, json_content, keyword, site):
        """Procesează rezultatele căutării și extrage informațiile relevante."""
        if json_content and 'webPages' in json_content:
            for result in json_content['webPages']['value']:
                title = result.get('name', 'Fără titlu')
                link = result.get('url', 'Fără link')
                snippet = result.get('snippet', 'Fără descriere')
                sentiment = TextBlob(snippet).sentiment
                self.data.append({
                    'Keyword': keyword,
                    'Site': site,
                    'Title': title,
                    'Link': link,
                    'Snippet': snippet,
                    'Polarity': sentiment.polarity,
                    'Subjectivity': sentiment.subjectivity
                })

    def save_to_csv(self, filename="rezultate.csv"):
        """Salvează datele colectate într-un fișier CSV."""
        if self.data:
            df = pd.DataFrame(self.data)
            df.to_csv(filename, index=False)
            print(f"Date salvate în {filename}")
        else:
            print("Nu există date de salvat.")

    def show_article(self, title, url):
        """Afișează conținutul articolului într-o fereastră mică."""
        content = self.fetch_full_article(url)
        ArticleWindow(title, content, url)

    def fetch_full_article(self, url):
        """Preia și procesează conținutul complet al articolului, inclusiv PDF și DOCX."""
        try:
            if url.lower().endswith('.pdf'):
                return self.extract_text_from_pdf(url)
            elif url.lower().endswith('.docx'):
                return self.extract_text_from_docx(url)
            else:
                article = Article(url, language='ro')
                article.download()
                article.parse()
                content = [f"Titlu: {article.title}\n" if article.title else "",
                           f"Autori: {', '.join(article.authors)}\n" if article.authors else "",
                           f"Data: {article.publish_date.strftime('%d-%m-%Y')}\n" if article.publish_date else "",
                           "\nConținut:\n" + article.text if article.text else ""]
                if not article.text:
                    response = requests.get(url, timeout=30)
                    soup = BeautifulSoup(response.text, 'html.parser')
                    text = soup.get_text(separator='\n').strip()
                    content.append(text)
                return '\n'.join(content)
        except Exception as e:
            return f"Eroare la preluarea conținutului: {str(e)}"

    def extract_text_from_pdf(self, url):
        """Extrage textul dintr-un fișier PDF."""
        response = requests.get(url)
        with open('temp.pdf', 'wb') as f:
            f.write(response.content)
        reader = PdfReader('temp.pdf')
        text = "\n".join([page.extract_text() for page in reader.pages])
        return text

    def extract_text_from_docx(self, url):
        """Extrage textul dintr-un fișier DOCX."""
        response = requests.get(url)
        with open('temp.docx', 'wb') as f:
            f.write(response.content)
        doc = Document('temp.docx')
        text = "\n".join([para.text for para in doc.paragraphs])
        return text

    def run(self):
        """Rulează procesul complet de căutare și procesare a rezultatelor."""
        for keyword in self.keywords:
            for site in self.sites:
                json_content = self.fetch_results(keyword, site)
                if json_content:
                    self.parse_results(json_content, keyword, site)
        self.save_to_csv()

# Exemplu de utilizare (decomentează pentru a testa)
# if __name__ == "__main__":
#     api_key = "your_api_key_here"
#     sites_file = "sites.txt"
#     keywords = ["tehnologie", "știri"]
#     gatherer = InfoGatherer(api_key, sites_file)
#     gatherer.set_keywords(keywords)
#     gatherer.run()
#     # Pentru a testa afișarea unui articol
#     if gatherer.data:
#         first_result = gatherer.data[0]
#         gatherer.show_article(first_result['Title'], first_result['Link'])