app.py

import streamlit as st
import requests
from transformers import pipeline
from deepface import DeepFace
from PIL import Image
import io
import re
import base64

# Load Fake News Detection Model from Hugging Face
fake_news_pipeline = pipeline("text-classification", model="mrm8488/bert-tiny-finetuned-fake-news-detection")

def classify_text(news_text):
    """Classifies text as Fake or Real with accuracy."""
    result = fake_news_pipeline(news_text)[0]
    label = result['label'].lower()
    score = result['score'] * 100  # Convert to percentage
    return ("Fake" if label == "fake" else "Real"), round(score, 2)

def analyze_image(image):
    """Analyzes image using DeepFace and Google Reverse Image Search."""
    try:
        analysis = DeepFace.analyze(image, actions=['emotion'])
        dominant_emotion = analysis[0]['dominant_emotion']
        reverse_search_url = reverse_image_search(image)
        return f"Analysis: {dominant_emotion}", 90.0, reverse_search_url  # Dummy Accuracy
    except Exception as e:
        return f"Error: {str(e)}", 0.0, None

def reverse_image_search(image):
    """Creates a Google Reverse Image Search link for verification."""
    buffered = io.BytesIO()
    image.save(buffered, format="PNG")
    encoded_img = base64.b64encode(buffered.getvalue()).decode()
    return f"https://www.google.com/searchbyimage?image_url=data:image/png;base64,{encoded_img}"

def verify_news(news_text):
    """Searches trusted fact-checking websites for news verification."""
    sources = [
        ("BBC News", "https://www.bbc.com/news"),
        ("CNN", "https://www.cnn.com"),
        ("Reuters", "https://www.reuters.com"),
        ("FactCheck.org", "https://www.factcheck.org"),
        ("Snopes", "https://www.snopes.com"),
        ("PolitiFact", "https://www.politifact.com"),
        ("Google Search", f"https://www.google.com/search?q={'+'.join(news_text.split())}")
    ]
    return sources

def extract_video_id(video_url):
    """Extracts the video ID from a YouTube URL."""
    pattern = r"(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})"
    match = re.search(pattern, video_url)
    return match.group(1) if match else None

def fetch_video_metadata(video_url):
    """Fetches video metadata and runs Fake News detection on it."""
    video_id = extract_video_id(video_url)
    if not video_id:
        return "Invalid Video URL", 0.0, None

    api_key = "YOUR_YOUTUBE_API_KEY"  # Replace with a valid YouTube API Key
    metadata_url = f"https://www.googleapis.com/youtube/v3/videos?id={video_id}&part=snippet&key={api_key}"
    
    response = requests.get(metadata_url)
    if response.status_code == 200:
        data = response.json()
        if "items" in data and len(data["items"]) > 0:
            video_details = data["items"][0]["snippet"]
            video_title = video_details["title"]
            video_description = video_details["description"]
            combined_text = video_title + " " + video_description

            # Classify the video metadata text
            result, accuracy = classify_text(combined_text)
            verification_links = verify_news(video_title)
            return result, accuracy, verification_links
    return "Unknown", 0.0, None

# Streamlit UI
st.set_page_config(page_title="Fake News Detector", layout="wide")
st.title("📰 Fake News Detector")

# 🔹 Three Separate Sections for Input
st.subheader("🔍 Choose an Input Type")

col1, col2, col3 = st.columns(3)

# 🔹 Text Input Section
with col1:
    st.markdown("### 📄 Text Input")
    news_text = st.text_area("Enter the news content to check:", height=150)
    analyze_text_clicked = st.button("Analyze News")
    
    if analyze_text_clicked:
        if not news_text.strip():
            st.warning("Please enter some text.")
        else:
            result, accuracy = classify_text(news_text)
            verification_links = verify_news(news_text)
            st.session_state["text_result"] = result
            st.session_state["text_accuracy"] = accuracy
            st.session_state["text_verification"] = verification_links

# 🔹 Image Upload Section
with col2:
    st.markdown("### 🖼️ Image Upload")
    uploaded_image = st.file_uploader("Upload a news image", type=["jpg", "png", "jpeg"])
    analyze_image_clicked = st.button("Analyze Image")
    
    if uploaded_image and analyze_image_clicked:
        image = Image.open(uploaded_image)
        result, accuracy, reverse_search_url = analyze_image(image)
        st.session_state["image_result"] = result
        st.session_state["image_accuracy"] = accuracy
        st.session_state["image_search_url"] = reverse_search_url
        st.session_state["news_image"] = image  # Store Image for Display

# 🔹 Video Link Section
with col3:
    st.markdown("### 🎥 Video Link")
    video_url = st.text_input("Enter the video link:")
    analyze_video_clicked = st.button("Analyze Video")
    
    if analyze_video_clicked:
        if not video_url.strip():
            st.warning("Please enter a valid video link.")
        else:
            result, accuracy, verification_links = fetch_video_metadata(video_url)
            st.session_state["video_result"] = result
            st.session_state["video_accuracy"] = accuracy
            st.session_state["video_verification"] = verification_links
            st.session_state["video_url"] = video_url  # Store Video URL for Display

# 🔹 Results Section
st.subheader("📊 Analysis Results")

# 🔹 Text Result
if "text_result" in st.session_state:
    result = st.session_state["text_result"]
    accuracy = st.session_state["text_accuracy"]
    
    if result == "Fake":
        st.error(f"❌ This news is **Fake**! (Accuracy: {accuracy}%)", icon="⚠️")
    else:
        st.success(f"✅ This news is **Real**! (Accuracy: {accuracy}%)", icon="✅")
    
    st.subheader("🔎 Trusted Fact-Checking Sources")
    for name, link in st.session_state["text_verification"]:
        st.markdown(f"[🔗 {name}]({link})")

# 🔹 Image Analysis Result Section
if "image_result" in st.session_state:
    st.image(st.session_state["news_image"], caption="Uploaded Image", use_column_width=True)

    if st.session_state["image_result"] == "Fake":
        st.error(f"❌ **This image is likely Fake!** (Accuracy: {st.session_state['image_accuracy']}%)")
    elif st.session_state["image_result"] == "Real":
        st.success(f"✅ **This image is likely Real!** (Accuracy: {st.session_state['image_accuracy']}%)")
    else:
        st.warning("⚠️ Unable to verify the authenticity of this image.")

    # ✅ Add verification links
    if st.session_state["image_verification"]:
        st.subheader("🔎 Trusted Fact-Checking Sources")
        for name, link in st.session_state["image_verification"]:
            st.markdown(f"[🔗 {name}]({link})")
    else:
        st.warning("No verification sources available for this image.")

# 🔹 Video Result
if "video_result" in st.session_state:
    st.video(st.session_state["video_url"])
    
    if st.session_state["video_result"] == "Fake":
        st.error(f"❌ **This video is Fake!** (Accuracy: {st.session_state['video_accuracy']}%)")
    elif st.session_state["video_result"] == "Real":
        st.success(f"✅ **This video is Real!** (Accuracy: {st.session_state['video_accuracy']}%)")
    else:
        st.warning("⚠️ Unable to verify the authenticity of this video.")

    # ✅ Check if verification links exist before iterating
    if st.session_state["video_verification"]:
        st.subheader("🔎 Trusted Fact-Checking Sources")
        for name, link in st.session_state["video_verification"]:
            st.markdown(f"[🔗 {name}]({link})")
    else:
        st.warning("No verification sources available for this video.")