main.py

import math
import re
from typing import Dict, List, Tuple, Union, Any
from dataclasses import dataclass
from enum import Enum

from trie import EnhancedTrie
from graph import SpreadAnalysisGraph
from hashmap import EnhancedWordFrequencyHashMap, SourceCredibilityHashMap


class ConfidenceLevel(Enum):
    VERY_LOW = "very_low"
    LOW = "low"
    MODERATE = "moderate"
    HIGH = "high"
    VERY_HIGH = "very_high"


@dataclass
class ScoringConfig:
    
    WEIGHTS = {
        "content_features": 0.40,     
        "source_credibility": 0.25,     
        "network_propagation": 0.15,    
        "medical_health": 0.20          
    }
    
    INTERACTION_EFFECTS = {
        "unreliable_source_suspicious_content": 1.4,  
        "reliable_source_suspicious_content": 0.6,     
        "viral_spread_low_quality": 1.3,              
    }
    
    STRONG_EVIDENCE_THRESHOLD = 0.75
    MODERATE_EVIDENCE_THRESHOLD = 0.60
    WEAK_EVIDENCE_THRESHOLD = 0.45
    
    DEBUNKING_PHRASES = [
        "debunk", "false claim", "myth", "not true", "fact check",
        "misinformation", "hoax", "fake news", "misleading"
    ]


class ImprovedFakeNewsScorer:
    
    
    def __init__(self):
        self.config = ScoringConfig()
        self.prior_fake_probability = 0.30  
        
   
        self.trie = EnhancedTrie()
        self.word_freq_analyzer = EnhancedWordFrequencyHashMap()
        self.source_checker = SourceCredibilityHashMap()
        self.spread_graph = SpreadAnalysisGraph()
    
    def calculate_realistic_score(self, 
                                  keyword_analysis: Dict,
                                  frequency_analysis: Dict,
                                  source_analysis: Dict,
                                  spread_analysis: Dict,
                                  comprehensive_analysis: Dict,
                                  original_text: str) -> Tuple[float, float, ConfidenceLevel, Dict]:
        
        content_likelihood, content_uncertainty = self._calculate_content_likelihood(
            keyword_analysis, frequency_analysis, comprehensive_analysis, original_text
        )
        
        source_likelihood, source_uncertainty = self._calculate_source_likelihood(
            source_analysis
        )
        
        propagation_likelihood, propagation_uncertainty = self._calculate_propagation_likelihood(
            spread_analysis, original_text
        )
        
        medical_likelihood, medical_uncertainty = self._calculate_medical_likelihood(
            comprehensive_analysis
        )
        
        interaction_multiplier = self._calculate_interaction_effects(
            content_likelihood, source_likelihood, propagation_likelihood,
            source_analysis, comprehensive_analysis
        )
        
        posterior_probability = self._bayesian_combination(
            content_likelihood, source_likelihood, propagation_likelihood, medical_likelihood,
            interaction_multiplier
        )
        
        confidence_score, confidence_level = self._calculate_realistic_confidence(
            content_uncertainty, source_uncertainty, propagation_uncertainty, medical_uncertainty,
            posterior_probability, comprehensive_analysis
        )
        
        evidence = {
            "content_score": content_likelihood,
            "source_score": source_likelihood,
            "propagation_score": propagation_likelihood,
            "medical_score": medical_likelihood,
            "interaction_multiplier": interaction_multiplier,
            "evidence_strength": self._assess_evidence_strength(posterior_probability, confidence_score),
            "uncertainties": {
                "content": content_uncertainty,
                "source": source_uncertainty,
                "propagation": propagation_uncertainty,
                "medical": medical_uncertainty
            }
        }
        
        return posterior_probability, confidence_score, confidence_level, evidence
    
    def _calculate_content_likelihood(self, keyword_analysis: Dict,
                                     frequency_analysis: Dict,
                                     comprehensive_analysis: Dict,
                                     original_text: str) -> Tuple[float, float]:
        
        is_debunking = self._is_debunking_content(original_text)
        
        trie_suspicion = keyword_analysis.get("suspicion_score", 0.5)
        
        freq_bias = frequency_analysis.get("overall_bias", 0.0)
        freq_suspicion = (freq_bias + 1.0) / 2.0
        
        base_suspicion = 0.5 * trie_suspicion + 0.5 * freq_suspicion
        
        if is_debunking:
            base_suspicion *= 0.2  
            uncertainty = 0.15 
        else:
            uncertainty = 0.20  
        
        if comprehensive_analysis:
            absurd_score = comprehensive_analysis.get('absurd_analysis', {}).get('impossibility_score', 0.0)
            medical_score = frequency_analysis.get('medical_misinformation_score', 0.0)
            
            if medical_score > 1.0:
                medical_score = min(medical_score / 10.0, 1.0)
            
            content_score = 0.5 * base_suspicion + 0.3 * absurd_score + 0.2 * medical_score
            
            if absurd_score > 0.7 or medical_score > 0.5:
                uncertainty *= 0.7
        else:
            content_score = base_suspicion
        
        return min(content_score, 1.0), uncertainty
    
    def _calculate_source_likelihood(self, source_analysis: Dict) -> Tuple[float, float]:
        
        credibility = source_analysis.get("credibility", "unknown")
        
        url = source_analysis.get("url", "")
        if url:
            credibility = self.source_checker.check_source(url)
        
        if credibility == "reliable":
            return 0.15, 0.10  
        elif credibility == "unreliable":
            return 0.85, 0.15  
        else:
            return 0.50, 0.35  
    
    def _calculate_propagation_likelihood(self, spread_analysis: Dict, text: str) -> Tuple[float, float]:
        
        if spread_analysis and spread_analysis.get("total_sharers"):
            spread_velocity = spread_analysis.get("spread_velocity", 0.5)
            bot_likelihood = spread_analysis.get("bot_likelihood", 0.0)
            echo_chamber = spread_analysis.get("echo_chamber_score", 0.0)
            
            propagation_score = 0.4 * min(spread_velocity / 10.0, 1.0) + \
                               0.3 * bot_likelihood + \
                               0.3 * echo_chamber
            
            uncertainty = 0.15 
            return min(propagation_score, 1.0), uncertainty
        
        text_lower = text.lower()
        score = 0.5
        uncertainty = 0.25
        
        hype_indicators = ["!", "!!!", "share this", "must see", "breaking", "viral", "shocking"]
        hype_hits = sum(1 for h in hype_indicators if h in text_lower)
        
        emotional_words = ["amazing", "terrible", "shocking", "unbelievable", "incredible"]
        emotional_hits = sum(1 for e in emotional_words if e in text_lower)
        
        if hype_hits > 0 or emotional_hits > 1:
            score += 0.2
            uncertainty -= 0.1
        
        score = min(1.0, max(0.0, score))
        uncertainty = min(1.0, max(0.0, uncertainty))
        
        return score, uncertainty
    
    def _calculate_medical_likelihood(self, comprehensive_analysis: Dict) -> Tuple[float, float]:
        
        if not comprehensive_analysis:
            return 0.50, 0.40
        
        medical_analysis = comprehensive_analysis.get('medical_analysis', {})
        danger_analysis = comprehensive_analysis.get('danger_analysis', {})
        
        is_medical_misinfo = medical_analysis.get('is_medical_misinformation', False)
        is_dangerous = danger_analysis.get('is_dangerous', False)
        
        if is_medical_misinfo or is_dangerous:
            severity_score = medical_analysis.get('severity_score', 0.0)
            danger_score = danger_analysis.get('danger_score', 0.0)
            
            medical_score = max(severity_score, danger_score)
            uncertainty = 0.12  
            
            return medical_score, uncertainty
        
        return 0.20, 0.30  
    
    def _calculate_interaction_effects(self, content_likelihood: float,
                                       source_likelihood: float,
                                       propagation_likelihood: float,
                                       source_analysis: Dict,
                                       comprehensive_analysis: Dict) -> float:
        
        multiplier = 1.0
        credibility = source_analysis.get("credibility", "unknown")
        
        if credibility == "unreliable" and content_likelihood > 0.6:
            multiplier *= self.config.INTERACTION_EFFECTS["unreliable_source_suspicious_content"]
        
        elif credibility == "reliable" and content_likelihood > 0.5:
            multiplier *= self.config.INTERACTION_EFFECTS["reliable_source_suspicious_content"]
        
        if propagation_likelihood > 0.6 and content_likelihood > 0.6:
            multiplier *= self.config.INTERACTION_EFFECTS["viral_spread_low_quality"]
        
        return multiplier
    
    def _bayesian_combination(self, content_likelihood: float,
                             source_likelihood: float,
                             propagation_likelihood: float,
                             medical_likelihood: float,
                             interaction_multiplier: float) -> float:
        
        def likelihood_ratio(prob: float) -> float:
            if prob < 0.01:
                prob = 0.01
            if prob > 0.99:
                prob = 0.99
            return prob / (1 - prob)
        
        lr_content = likelihood_ratio(content_likelihood) ** self.config.WEIGHTS["content_features"]
        lr_source = likelihood_ratio(source_likelihood) ** self.config.WEIGHTS["source_credibility"]
        lr_propagation = likelihood_ratio(propagation_likelihood) ** self.config.WEIGHTS["network_propagation"]
        lr_medical = likelihood_ratio(medical_likelihood) ** self.config.WEIGHTS["medical_health"]
        
        combined_lr = lr_content * lr_source * lr_propagation * lr_medical * interaction_multiplier
        
        prior_odds = self.prior_fake_probability / (1 - self.prior_fake_probability)
        posterior_odds = prior_odds * combined_lr
        
        posterior_probability = posterior_odds / (1 + posterior_odds)
        
        return min(max(posterior_probability, 0.0), 1.0)
    
    def _calculate_realistic_confidence(self, content_uncertainty: float,
                                        source_uncertainty: float,
                                        propagation_uncertainty: float,
                                        medical_uncertainty: float,
                                        posterior_probability: float,
                                        comprehensive_analysis: Dict) -> Tuple[float, ConfidenceLevel]:
        
        combined_uncertainty = math.sqrt(
            (content_uncertainty * self.config.WEIGHTS["content_features"]) ** 2 +
            (source_uncertainty * self.config.WEIGHTS["source_credibility"]) ** 2 +
            (propagation_uncertainty * self.config.WEIGHTS["network_propagation"]) ** 2 +
            (medical_uncertainty * self.config.WEIGHTS["medical_health"]) ** 2
        )
        
        risk_factors = comprehensive_analysis.get('risk_factors', []) if comprehensive_analysis else []
        legit_factors = comprehensive_analysis.get('legit_factors', []) if comprehensive_analysis else []
        
        if len(risk_factors) > 0 and len(legit_factors) > 0:
            combined_uncertainty *= 1.3
        
        confidence_score = 1.0 - combined_uncertainty
        
        extremeness = abs(posterior_probability - 0.5) * 2
        confidence_score = 0.6 * confidence_score + 0.4 * extremeness
        
        if confidence_score >= 0.80:
            level = ConfidenceLevel.VERY_HIGH
        elif confidence_score >= 0.65:
            level = ConfidenceLevel.HIGH
        elif confidence_score >= 0.50:
            level = ConfidenceLevel.MODERATE
        elif confidence_score >= 0.35:
            level = ConfidenceLevel.LOW
        else:
            level = ConfidenceLevel.VERY_LOW
        
        return min(max(confidence_score, 0.0), 1.0), level
    
    def _is_debunking_content(self, text: str) -> bool:
        text_lower = text.lower()
        first_part = text_lower[:200]
        
        for phrase in self.config.DEBUNKING_PHRASES:
            if phrase in first_part:
                return True
        
        return False
    
    def _assess_evidence_strength(self, posterior_probability: float, 
                                  confidence_score: float) -> str:
        
        if confidence_score >= 0.70:
            if posterior_probability >= 0.75 or posterior_probability <= 0.25:
                return "strong"
            else:
                return "moderate"
        elif confidence_score >= 0.50:
            return "moderate"
        else:
            return "weak"
    
    def classify_with_thresholds(self, posterior_probability: float,
                                confidence_level: ConfidenceLevel,
                                evidence_strength: str) -> str:
        
        if confidence_level in [ConfidenceLevel.VERY_HIGH, ConfidenceLevel.HIGH]:
            if posterior_probability >= 0.65: 
                return "Likely Fake"
            elif posterior_probability <= 0.35: 
                return "Likely Real"
            else:
                return "Uncertain - Needs Human Review"
        
        elif confidence_level == ConfidenceLevel.MODERATE:
            if posterior_probability >= 0.70:  
                return "Possibly Fake"
            elif posterior_probability <= 0.30:  
                return "Possibly Real"
            else:
                return "Inconclusive - Insufficient Evidence"
        
        else:
            if posterior_probability >= 0.80:  
                return "Possibly Fake (Low Confidence)"
            elif posterior_probability <= 0.20: 
                return "Possibly Real (Low Confidence)"
            else:
                return "Inconclusive - Insufficient Evidence"
    
    def generate_realistic_explanations(self, evidence: Dict, 
                                       comprehensive_analysis: Dict,
                                       frequency_analysis: Dict) -> List[str]:
        
        explanations = []
        
        evidence_strength = evidence.get("evidence_strength", "weak")
        explanations.append(f"Evidence strength: {evidence_strength}")
        
        content_score = evidence.get("content_score", 0.5)
        content_uncertainty = evidence.get("uncertainties", {}).get("content", 0.3)
        
        if content_score > 0.6:
            conf_descriptor = "high confidence" if content_uncertainty < 0.20 else "moderate confidence"
            explanations.append(f"Suspicious content patterns detected ({conf_descriptor})")
        
        if frequency_analysis:
            freq_bias = frequency_analysis.get("overall_bias", 0.0)
            if freq_bias > 0.3:
                explanations.append(f"Word frequency analysis indicates fake news bias ({freq_bias:.2f})")
            
            patterns = frequency_analysis.get("problematic_patterns", [])
            if patterns:
                explanations.append(f"Problematic pattern detected: {patterns[0]}")
        
        source_score = evidence.get("source_score", 0.5)
        if source_score > 0.7:
            explanations.append("Source has low credibility rating")
        elif source_score < 0.3:
            explanations.append("Source has high credibility rating")
        
        interaction = evidence.get("interaction_multiplier", 1.0)
        if interaction > 1.2:
            explanations.append("Multiple risk factors compound the likelihood")
        elif interaction < 0.8:
            explanations.append("Credible source context reduces concerns")
        
        if comprehensive_analysis:
            if comprehensive_analysis.get('medical_analysis', {}).get('is_medical_misinformation'):
                explanations.append("Contains medical misinformation patterns")
        
        return explanations
    
    def classify(self,
                 keyword_analysis: Dict = None,
                 frequency_analysis: Dict = None,
                 source_analysis: Dict = None,
                 spread_analysis: Dict = None,
                 comprehensive_analysis: Dict = None,
                 original_text: str = "") -> Dict[str, Union[str, float, Dict[str, Any]]]:
       

        keyword_analysis = keyword_analysis or {}
        frequency_analysis = frequency_analysis or {}
        source_analysis = source_analysis or {}
        spread_analysis = spread_analysis or {}
        comprehensive_analysis = comprehensive_analysis or {}

        if not keyword_analysis and original_text:
            keyword_analysis = {
                "suspicion_score": self.trie.calculate_suspicion_score(original_text),
                "found_keywords": self.trie.find_suspicious_keywords(original_text)
            }
        
        if not frequency_analysis and original_text:
            frequency_analysis = self.word_freq_analyzer.analyze_text_bias(original_text)

        posterior_prob, confidence_score, conf_level, evidence = self.calculate_realistic_score(
            keyword_analysis, frequency_analysis, source_analysis,
            spread_analysis, comprehensive_analysis, original_text
        )

        label = self.classify_with_thresholds(
            posterior_prob,
            conf_level,
            evidence.get("evidence_strength", "moderate")
        )

        explanations = self.generate_realistic_explanations(evidence, comprehensive_analysis, frequency_analysis)

        return {
            "label": label,
            "probability": posterior_prob,
            "confidence_score": confidence_score,
            "confidence_level": conf_level.value,
            "explanations": explanations,
            "evidence": evidence,
            "debug": {
                "content_score": evidence.get("content_score"),
                "source_score": evidence.get("source_score"),
                "frequency_bias": frequency_analysis.get("overall_bias", 0.0) if frequency_analysis else 0.0,
                "trie_suspicion": keyword_analysis.get("suspicion_score", 0.0),
                "found_keywords": (list(keyword_analysis.get("found_keywords", {}).keys())[:5] if isinstance(keyword_analysis.get("found_keywords", {}), dict) else keyword_analysis.get("found_keywords", [])[:5]),
                "fake_biased_words": frequency_analysis.get("fake_biased_words", [])[:5] if frequency_analysis else [],
                "medical_score": frequency_analysis.get("medical_misinformation_score", 0.0) if frequency_analysis else 0.0,
                "absurd_score": frequency_analysis.get("absurd_claim_score", 0.0) if frequency_analysis else 0.0,
                "problematic_patterns": frequency_analysis.get("problematic_patterns", []) if frequency_analysis else []
            }
        }


def integrate_improved_scoring(detector_instance):
    
    
    scorer = ImprovedFakeNewsScorer()
    
    def calculate_improved_score(self, keyword_analysis: Dict, frequency_analysis: Dict,
                                source_analysis: Dict, spread_analysis: Dict = None,
                                comprehensive_analysis: Dict = None) -> float:
        
        original_text = getattr(self, '_current_text', "")
        
        posterior_prob, confidence, conf_level, evidence = scorer.calculate_realistic_score(
            keyword_analysis, frequency_analysis, source_analysis,
            spread_analysis or {}, comprehensive_analysis or {}, original_text
        )
        
        self._last_confidence_level = conf_level
        self._last_evidence = evidence
        
        return posterior_prob
    
    def improved_classify(self, score: float, comprehensive_analysis: Dict = None) -> str:
        
        conf_level = getattr(self, '_last_confidence_level', ConfidenceLevel.MODERATE)
        evidence = getattr(self, '_last_evidence', {})
        evidence_strength = evidence.get('evidence_strength', 'moderate')
        
        return scorer.classify_with_thresholds(score, conf_level, evidence_strength)
    
    return calculate_improved_score, improved_classify


if __name__ == "__main__":
    scorer = ImprovedFakeNewsScorer()
    
    def analyze_file(filename, scorer, kw=None, src=None):
        try:
            with open(filename, "r", encoding="utf-8") as f:
                text = f.read()
            return scorer.classify(
                keyword_analysis=kw or {},
                source_analysis=src or {},
                original_text=text
            )
        except FileNotFoundError:
            return {"error": f"File {filename} not found"}
    
    sample_text = "BREAKING: Scientists confirm chocolate cures all cancer! Doctors hate this one weird trick. Studies show eating 10 chocolate bars daily will make you live forever. Big Pharma doesn't want you to know this secret ancient remedy!"
    result = scorer.classify(original_text=sample_text)
    
    print("Analysis Result:")
    print(f"Label: {result['label']}")
    print(f"Probability: {result['probability']:.3f}")
    print(f"Confidence: {result['confidence_score']:.3f} ({result['confidence_level']})")
    print(f"\nDebug Info:")
    print(f"  Content Score: {result['debug']['content_score']:.3f}")
    print(f"  Source Score: {result['debug']['source_score']:.3f}")
    print(f"  Frequency Bias: {result['debug']['frequency_bias']:.3f}")
    print(f"  Trie Suspicion: {result['debug']['trie_suspicion']:.3f}")
    print(f"  Medical Score: {result['debug']['medical_score']:.3f}")
    print(f"  Absurd Score: {result['debug']['absurd_score']:.3f}")
    print(f"  Found Keywords: {result['debug']['found_keywords']}")
    print(f"  Fake-Biased Words: {result['debug']['fake_biased_words']}")
    print(f"  Problematic Patterns: {result['debug']['problematic_patterns']}")
    print("\nExplanations:")
    for exp in result['explanations']:
        print(f"  - {exp}")