import numpy as np
from typing import List, Tuple
from dataclasses import dataclass
import math
from collections import Counter

@dataclass
class Document:
    doc_id: str
    text: str
    title: str
    url: str
    source_authority: float
    publish_date: str

class BM25Retriever:
    """BM25 inverted index retriever for precise term matching"""
    def __init__(self, k1: float = 1.5, b: float = 0.75):
        self.k1, self.b = k1, b
        self.doc_freq, self.doc_lengths = {}, []
        self.avg_doc_length, self.total_docs = 0, 0
        self.inverted_index = {}
        self.documents = []
    
    def fit(self, documents: List[Document]):
        self.documents = documents
        self.total_docs = len(documents)
        for doc in documents:
            self.doc_lengths.append(len(doc.text.split()))
            terms = self._tokenize(doc.text)
            term_freq = Counter(terms)
            for term, freq in term_freq.items():
                if term not in self.inverted_index:
                    self.inverted_index[term] = {}
                    self.doc_freq[term] = 0
                self.inverted_index[term][doc.doc_id] = freq
                self.doc_freq[term] += 1
        self.avg_doc_length = np.mean(self.doc_lengths)
    
    def _tokenize(self, text: str) -> List[str]:
        import re
        return re.findall(r'\w+', text.lower())
    
    def search(self, query: str, top_k: int = 100) -> List[Tuple[Document, float]]:
        query_terms = self._tokenize(query)
        scores = np.zeros(self.total_docs)
        for term in query_terms:
            if term not in self.inverted_index:
                continue
            idf = math.log((self.total_docs - self.doc_freq[term] + 0.5) / 
                          (self.doc_freq[term] + 0.5) + 1.0)
            for doc_idx, doc in enumerate(self.documents):
                if doc.doc_id in self.inverted_index[term]:
                    tf = self.inverted_index[term][doc.doc_id]
                    score = idf * ((tf * (self.k1 + 1)) / 
                                  (tf + self.k1 * (1 - self.b + self.b * self.doc_lengths[doc_idx] / self.avg_doc_length)))
                    scores[doc_idx] += score
        top_indices = np.argsort(scores)[::-1][:top_k]
        return [(self.documents[i], scores[i]) for i in top_indices]

class HybridRetriever:
    """Combines BM25 and dense vector retrieval"""
    def __init__(self, bm25_weight: float = 0.3, dense_weight: float = 0.7):
        self.bm25_weight, self.dense_weight = bm25_weight, dense_weight
        self.bm25 = BM25Retriever()
    
    def fit(self, documents: List[Document]):
        self.bm25.fit(documents)
    
    def search(self, query: str, top_k: int = 200) -> List[Tuple[Document, float]]:
        bm25_results = self.bm25.search(query, top_k=500)
        bm25_docs = {doc.doc_id: score for doc, score in bm25_results}
        bm25_max = max(bm25_docs.values()) if bm25_docs else 1.0
        
        combined_scores = {}
        for doc in self.bm25.documents:
            bm25_score = bm25_docs.get(doc.doc_id, 0) / bm25_max
            dense_score = 0.5  # Simplified
            combined_scores[doc.doc_id] = self.bm25_weight * bm25_score + self.dense_weight * dense_score
        
        sorted_docs = sorted(combined_scores.items(), key=lambda x: x[1], reverse=True)
        doc_map = {doc.doc_id: doc for doc in self.bm25.documents}
        return [(doc_map[doc_id], score) for doc_id, score in sorted_docs[:top_k]]

class SourceAuthorityClassifier:
    """Google AI Overviews source authority classification system"""
    
    SOURCE_LEVELS = {
        'S': {'weight': 10.0, 'domains': ['.gov', '.edu', 'nature.com', 'science.org']},
        'A': {'weight': 5.0, 'domains': ['reuters.com', 'bbc.com', 'nytimes.com', 'github.com']},
        'B': {'weight': 2.0, 'domains': ['medium.com', 'arxiv.org', 'wikipedia.org']},
        'C': {'weight': 0.5, 'domains': []},
        'D': {'weight': 0.0, 'domains': []},
    }
    
    @classmethod
    def classify(cls, url: str) -> Tuple[str, float]:
        from urllib.parse import urlparse
        domain = urlparse(url).netloc.lower()
        for level, info in cls.SOURCE_LEVELS.items():
            for s_domain in info['domains']:
                if domain.endswith(s_domain) or s_domain in domain:
                    return (level, info['weight'])
        return ('C', 0.5)
    
    @classmethod
    def compute_authority_score(cls, url: str, page_rank: float = 0.5) -> float:
        _, weight = cls.classify(url)
        return min(weight / 10.0 * 0.7 + page_rank * 0.3, 1.0)

class SourceFilter:
    """Filters and scores documents based on authority, relevance, and timeliness"""
    def filter_and_score(self, candidates: List[Tuple[Document, float]], 
                        max_results: int = 5) -> List[Tuple[Document, float]]:
        scored_docs = []
        for doc, relevance_score in candidates:
            authority_score = SourceAuthorityClassifier.compute_authority_score(doc.url)
            combined = authority_score * 0.5 + relevance_score * 0.3 + 0.2  # timeliness placeholder
            level, _ = SourceAuthorityClassifier.classify(doc.url)
            if level != 'D':
                scored_docs.append((doc, combined))
        scored_docs.sort(key=lambda x: x[1], reverse=True)
        return scored_docs[:max_results]

class FactDensityAnalyzer:
    """Analyzes fact density in content"""
    def analyze(self, content: str) -> Dict[str, Any]:
        import re
        paragraphs = [p for p in content.split('\n') if p.strip()]
        total = max(len(paragraphs), 1)
        
        stats_pattern = r'\d+[\.\d]*\s*(%|percent|billion|million|GB|TB|TOPS)'
        stats_count = sum(1 for p in paragraphs if re.search(stats_pattern, p))
        
        citation_pattern = r'\[(\d+)\]|据.*(?:报道|表明|显示)'
        citation_count = sum(1 for p in paragraphs if re.search(citation_pattern, p))
        
        code_count = len(re.findall(r'```', content))
        table_count = sum(1 for p in paragraphs if re.match(r'\|.*\|.*\|', p))
        
        return {
            "density_score": min((stats_count + citation_count + code_count + table_count) / total, 1.0),
            "stats_count": stats_count,
            "citation_count": citation_count,
            "code_block_count": code_count,
            "table_count": table_count
        }

class SchemaMarkupGenerator:
    """Generates JSON-LD Schema markup for better AI search understanding"""
    def generate(self, title: str, content: str, keywords: List[str]) -> str:
        import json
        from datetime import datetime
        
        schema = {
            "@context": "https://schema.org",
            "@type": "TechArticle",
            "headline": title,
            "description": content[:200].replace('\n', ' ').strip(),
            "keywords": ", ".join(keywords),
            "datePublished": datetime.now().isoformat(),
            "author": {"@type": "Organization", "name": "AI Tech Blog"},
            "about": {"@type": "Thing", "name": keywords[0] if keywords else "AI Technology"},
            "mentions": [{"@type": "Thing", "name": kw} for kw in keywords[:5]]
        }
        return json.dumps(schema, ensure_ascii=False, indent=2)