from dataclasses import dataclass
from typing import Optional, List, Callable
import re

@dataclass
class SiteSchema:
    """Base class for site-specific download configurations."""
    name: str
    url_pattern: str  # Regex to match URLs
    
    # PDF discovery
    include_patterns: List[str] = None
    exclude_patterns: List[str] = None
    pdf_selector: str = None  # CSS selector for PDF links
    
    # Ordering
    sort_by: str = None  # 'numeric', 'alpha', 'alpha_desc', 'none'
    sort_key: Callable = None
    
    # Output
    default_output_name: str = None  # e.g., "{title}.pdf"
    
    # Behavior
    recommended_depth: int = 1
    request_delay: float = 1.0
    
    def matches(self, url: str) -> bool:
        return bool(re.match(self.url_pattern, url))
    
    def extract_metadata(self, url: str, html: str) -> dict:
        """Override to extract title, author, etc. from page."""
        return {}

# fetcharoo/schemas/springer.py
class SpringerBook(SiteSchema):
    name = "springer_book"
    url_pattern = r"https?://link\.springer\.com/book/.*"
    
    include_patterns = ["*_*.pdf"]  # Chapter PDFs have underscore
    exclude_patterns = ["*bbm*", "*fm*"]  # Exclude front/back matter
    sort_by = "numeric"
    recommended_depth = 1
    request_delay = 1.0
    
    def sort_key(self, url):
        # Extract chapter number from 978-3-xxx_N.pdf
        match = re.search(r'_(\d+)\.pdf$', url)
        return int(match.group(1)) if match else float('inf')
    
    def extract_metadata(self, url, html):
        # Extract book title from page
        soup = BeautifulSoup(html, 'html.parser')
        title = soup.select_one('h1.c-article-title')
        return {'title': title.text if title else 'book'}

class SpringerChaptersOnly(SpringerBook):
    """Download only individual chapters, not full book PDF."""
    name = "springer_chapters"
    exclude_patterns = ["*bbm*", "*fm*", "*978-3-*-*-?.pdf"]  # Exclude full book

# fetcharoo/schemas/arxiv.py
class ArxivPaper(SiteSchema):
    name = "arxiv"
    url_pattern = r"https?://arxiv\.org/(abs|pdf)/.*"
    sort_by = "none"
    recommended_depth = 0
    
    def extract_metadata(self, url, html):
        # Extract paper ID and title
        ...

# fetcharoo/schemas/registry.py
_SCHEMAS: Dict[str, SiteSchema] = {}

def register_schema(schema: SiteSchema):
    """Register a schema in the global registry."""
    _SCHEMAS[schema.name] = schema

def get_schema(name: str) -> Optional[SiteSchema]:
    """Get schema by name."""
    return _SCHEMAS.get(name)

def detect_schema(url: str) -> Optional[SiteSchema]:
    """Auto-detect schema from URL."""
    for schema in _SCHEMAS.values():
        if schema.matches(url):
            return schema
    return None

def list_schemas() -> List[str]:
    """List all registered schema names."""
    return list(_SCHEMAS.keys())

# Decorator for easy registration
def schema(cls):
    register_schema(cls())
    return cls

from fetcharoo import download_pdfs_from_webpage

# Auto-detect schema from URL
result = download_pdfs_from_webpage(
    url='https://link.springer.com/book/10.1007/978-3-031-41026-0',
    schema='auto'  # Detects SpringerBook
)

# Explicitly use a schema
result = download_pdfs_from_webpage(
    url='https://link.springer.com/book/...',
    schema='springer_chapters'
)

# Use schema instance with overrides
from fetcharoo.schemas import SpringerBook
result = download_pdfs_from_webpage(
    url='...',
    schema=SpringerBook(request_delay=2.0)
)

# Schema parameters are defaults; explicit params override
result = download_pdfs_from_webpage(
    url='...',
    schema='springer_book',
    sort_by='alpha'  # Overrides schema's 'numeric'
)

from fetcharoo.schemas import SiteSchema, register_schema

@register_schema
class MyUniversityLibrary(SiteSchema):
    name = "myuni"
    url_pattern = r"https://library\.myuni\.edu/.*"
    sort_by = "alpha"