from typing import Dict, Optional, List
import logging
from urllib.parse import urlparse
import requests
from bs4 import BeautifulSoup, NavigableString

from ..utils.logging_config import setup_logging

class ArticleScraper:
    def __init__(self):
        self.session = requests.Session()
        self.session.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        }
        setup_logging()
        self.logger = logging.getLogger(__name__)

    def _get_domain(self, url: str) -> str:
        """Extract domain from URL."""
        return urlparse(url).netloc

    def _fetch_page(self, url: str) -> Optional[str]:
        """Fetch page content with error handling."""
        try:
            response = self.session.get(url)
            response.raise_for_status()
            return response.text
            
        except Exception as e:
            self.logger.error(f"Error fetching {url}: {str(e)}")
            return None

    def _process_element(self, element) -> str:
        """Process an HTML element while preserving its structure and formatting."""
        if isinstance(element, NavigableString):
            return str(element)
        
        # Handle different types of elements
        tag_name = element.name
        
        if tag_name in ['p', 'div']:
            return '\n\n' + ''.join(self._process_element(child) for child in element.children).strip()
        
        elif tag_name in ['ul', 'ol']:
            items = []
            for li in element.find_all('li', recursive=False):
                prefix = '• ' if tag_name == 'ul' else f"{len(items) + 1}. "
                items.append(prefix + ''.join(self._process_element(child) for child in li.children).strip())
            return '\n' + '\n'.join(items) + '\n'
        
        elif tag_name == 'br':
            return '\n'
        
        elif tag_name in ['strong', 'b']:
            return '**' + ''.join(self._process_element(child) for child in element.children) + '**'
        
        elif tag_name in ['em', 'i']:
            return '_' + ''.join(self._process_element(child) for child in element.children) + '_'
        
        elif tag_name == 'a':
            text = ''.join(self._process_element(child) for child in element.children)
            href = element.get('href', '')
            return f'[{text}]({href})'
        
        elif tag_name in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
            level = int(tag_name[1])
            prefix = '#' * (level + 1)  # Add one more # to match test expectations
            return f'\n\n{prefix} ' + ''.join(self._process_element(child) for child in element.children).strip() + '\n'
        
        # For other elements, just process their children
        return ''.join(self._process_element(child) for child in element.children)

    def _extract_content(self, container) -> str:
        """Extract and format content from a container element."""
        if not container:
            return ''
            
        # Remove unwanted elements
        for unwanted in container.find_all(['script', 'style', 'iframe', 'aside']):
            unwanted.decompose()
            
        # Process the container
        content = self._process_element(container)
        
        # Clean up extra whitespace and newlines
        content = '\n'.join(line.strip() for line in content.split('\n'))
        content = '\n'.join(filter(None, content.split('\n')))
        
        return content.strip()

    def _extract_article(self, soup: BeautifulSoup, domain: str) -> Dict[str, str]:
        """Extract content from any article, with special handling for known domains."""
        try:
            # Find headline - try domain-specific selectors first, then fallback to generic
            headline = None
            headline_selectors = {
                'politifact.com': ['h1.article__title'],
                'snopes.com': ['header h1', 'article h1']
            }

            # Try domain-specific headline selectors
            if domain in headline_selectors:
                for selector in headline_selectors[domain]:
                    headline = soup.select_one(selector)
                    if headline:
                        break

            # Fallback to any h1 if no domain-specific headline found
            if not headline:
                headline = soup.find('h1')

            headline_text = headline.get_text().strip() if headline else "No headline found"
            self.logger.info(f"Found headline: {headline_text}")

            # Find content - try domain-specific selectors first, then fallback to generic
            content_div = None
            content_selectors = {
                'politifact.com': ['article.article', '.article__text', '.m-textblock'],
                'snopes.com': ['article']
            }

            # Try domain-specific content selectors
            if domain in content_selectors:
                for selector in content_selectors[domain]:
                    content_div = soup.select_one(selector)
                    if content_div:
                        break

            # Fallback to generic content selectors
            if not content_div:
                for selector in ['article', 'main', '.content', '.article-content']:
                    content_div = soup.select_one(selector)
                    if content_div:
                        break

            content = self._extract_content(content_div) if content_div else "No content found"
            
            if not content:
                self.logger.warning("No content found in article")
                self.logger.debug(f"Domain: {domain}")

            return {"headline": headline_text, "content": content}
            
        except Exception as e:
            self.logger.error(f"Error extracting article content: {str(e)}")
            return {"headline": "Error", "content": f"Failed to extract content: {str(e)}"}

    def scrape_article(self, url: str) -> Optional[Dict[str, str]]:
        """
        Main function to scrape fact-checking articles.
        Returns a dictionary with headline and content.
        """
        html_content = self._fetch_page(url)
        if not html_content:
            self.logger.error("Failed to fetch page content")
            return None

        soup = BeautifulSoup(html_content, 'html.parser')
        domain = self._get_domain(url)
        
        self.logger.info(f"Scraping article from domain: {domain}")
        return self._extract_article(soup, domain)