halldyll_parser/

contact.rs

//! Contact information extraction for halldyll-parser
//!
//! This module handles extraction of:
//! - Email addresses
//! - Phone numbers
//! - Physical addresses
//! - Social media links
//! - Business information

use regex::Regex;
use scraper::{Html, Selector, ElementRef};
use serde::{Deserialize, Serialize};
use lazy_static::lazy_static;
use std::collections::HashSet;

use crate::types::ParserResult;

// ============================================================================
// TYPES
// ============================================================================

/// All contact information found on a page
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct ContactInfo {
    /// Email addresses found
    pub emails: Vec<Email>,
    /// Phone numbers found
    pub phones: Vec<Phone>,
    /// Physical addresses found
    pub addresses: Vec<Address>,
    /// Social media links found
    pub social_links: Vec<SocialLink>,
    /// Contact page URL if found
    pub contact_page: Option<String>,
    /// Business name if found
    pub business_name: Option<String>,
}

impl ContactInfo {
    pub fn new() -> Self {
        Self::default()
    }

    /// Check if any contact info was found
    pub fn has_contact_info(&self) -> bool {
        !self.emails.is_empty() ||
        !self.phones.is_empty() ||
        !self.addresses.is_empty() ||
        !self.social_links.is_empty()
    }

    /// Get primary email (first non-generic email)
    pub fn primary_email(&self) -> Option<&Email> {
        self.emails.iter().find(|e| !e.is_generic)
            .or_else(|| self.emails.first())
    }

    /// Get primary phone
    pub fn primary_phone(&self) -> Option<&Phone> {
        self.phones.first()
    }

    /// Get all unique email addresses as strings
    pub fn email_addresses(&self) -> Vec<&str> {
        self.emails.iter().map(|e| e.address.as_str()).collect()
    }
}

/// An email address with metadata
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Email {
    /// The email address
    pub address: String,
    /// Label (e.g., "support", "sales", "info")
    pub label: Option<String>,
    /// Whether this is a generic email (info@, contact@, etc.)
    pub is_generic: bool,
    /// Source of the email (href, text, structured data)
    pub source: EmailSource,
}

impl Email {
    pub fn new(address: String) -> Self {
        let is_generic = Self::check_is_generic(&address);
        Self {
            address,
            label: None,
            is_generic,
            source: EmailSource::Text,
        }
    }

    fn check_is_generic(address: &str) -> bool {
        let local = address.split('@').next().unwrap_or("").to_lowercase();
        let generic_prefixes = [
            "info", "contact", "hello", "hi", "support", "help",
            "sales", "admin", "webmaster", "noreply", "no-reply",
            "mail", "email", "enquiries", "enquiry", "general",
        ];
        generic_prefixes.iter().any(|p| local == *p || local.starts_with(&format!("{}.", p)))
    }
}

/// Source of email extraction
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
pub enum EmailSource {
    /// From mailto: link
    MailtoLink,
    /// From page text
    #[default]
    Text,
    /// From structured data
    StructuredData,
    /// From meta tag
    MetaTag,
}

/// A phone number with metadata
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Phone {
    /// Raw phone number as found
    pub raw: String,
    /// Normalized phone number (digits only)
    pub normalized: String,
    /// International format if parseable
    pub international: Option<String>,
    /// Phone type if detectable
    pub phone_type: PhoneType,
    /// Label (e.g., "main", "fax", "mobile")
    pub label: Option<String>,
}

impl Phone {
    pub fn new(raw: String) -> Self {
        let normalized = Self::normalize(&raw);
        Self {
            raw,
            normalized,
            international: None,
            phone_type: PhoneType::Unknown,
            label: None,
        }
    }

    fn normalize(raw: &str) -> String {
        raw.chars().filter(|c| c.is_ascii_digit() || *c == '+').collect()
    }
}

/// Type of phone number
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
pub enum PhoneType {
    /// Main business line
    Main,
    /// Mobile/cell phone
    Mobile,
    /// Fax number
    Fax,
    /// Toll-free number
    TollFree,
    /// Unknown type
    #[default]
    Unknown,
}

/// A physical address
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct Address {
    /// Full address as text
    pub full_text: String,
    /// Street address
    pub street: Option<String>,
    /// City
    pub city: Option<String>,
    /// State/Province
    pub state: Option<String>,
    /// Postal/ZIP code
    pub postal_code: Option<String>,
    /// Country
    pub country: Option<String>,
    /// Coordinates if available
    pub coordinates: Option<Coordinates>,
}

/// Geographic coordinates
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
pub struct Coordinates {
    pub latitude: f64,
    pub longitude: f64,
}

/// A social media link
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct SocialLink {
    /// Platform name
    pub platform: SocialPlatform,
    /// Full URL
    pub url: String,
    /// Username/handle if extractable
    pub username: Option<String>,
}

/// Social media platforms
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum SocialPlatform {
    Facebook,
    Twitter,
    Instagram,
    LinkedIn,
    YouTube,
    TikTok,
    Pinterest,
    GitHub,
    Reddit,
    Discord,
    Telegram,
    WhatsApp,
    Snapchat,
    Tumblr,
    Medium,
    Twitch,
    Vimeo,
    Flickr,
    Other,
}

// ============================================================================
// LAZY STATIC PATTERNS
// ============================================================================

lazy_static! {
    /// Email regex pattern
    static ref EMAIL_PATTERN: Regex = Regex::new(
        r"(?i)[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}"
    ).unwrap();

    /// Phone number patterns (various formats)
    static ref PHONE_PATTERN: Regex = Regex::new(
        r"(?x)
        (?:\+?1[-.\s]?)?          # Optional country code
        (?:\(?\d{3}\)?[-.\s]?)    # Area code
        \d{3}[-.\s]?              # Exchange
        \d{4}                     # Subscriber
        |
        \+\d{1,3}[-.\s]?\d{1,4}[-.\s]?\d{1,4}[-.\s]?\d{1,9}  # International
        "
    ).unwrap();

    /// US/CA toll-free pattern
    static ref TOLL_FREE_PATTERN: Regex = Regex::new(
        r"(?i)1?[-.\s]?(?:800|888|877|866|855|844|833)[-.\s]?\d{3}[-.\s]?\d{4}"
    ).unwrap();

    /// Postal code patterns
    static ref US_ZIP_PATTERN: Regex = Regex::new(r"\b\d{5}(?:-\d{4})?\b").unwrap();
    static ref UK_POSTAL_PATTERN: Regex = Regex::new(
        r"(?i)\b[A-Z]{1,2}\d[A-Z\d]?\s*\d[A-Z]{2}\b"
    ).unwrap();
    static ref CA_POSTAL_PATTERN: Regex = Regex::new(
        r"(?i)\b[A-Z]\d[A-Z]\s*\d[A-Z]\d\b"
    ).unwrap();
}

// ============================================================================
// EXTRACTION FUNCTIONS
// ============================================================================

/// Extract all contact information from HTML document
pub fn extract_contact_info(document: &Html) -> ParserResult<ContactInfo> {
    let mut info = ContactInfo::new();

    // Extract emails
    info.emails = extract_emails(document);

    // Extract phones
    info.phones = extract_phones(document);

    // Extract addresses
    info.addresses = extract_addresses(document);

    // Extract social links
    info.social_links = extract_social_links(document);

    // Find contact page link
    info.contact_page = find_contact_page(document);

    // Try to find business name
    info.business_name = extract_business_name(document);

    Ok(info)
}

/// Extract email addresses from document
pub fn extract_emails(document: &Html) -> Vec<Email> {
    let mut emails = Vec::new();
    let mut seen = HashSet::new();

    // From mailto: links
    if let Ok(sel) = Selector::parse("a[href^='mailto:']") {
        for el in document.select(&sel) {
            if let Some(href) = el.value().attr("href") {
                let addr = href.trim_start_matches("mailto:")
                    .split('?').next()
                    .unwrap_or("")
                    .to_lowercase();
                
                if EMAIL_PATTERN.is_match(&addr) && !seen.contains(&addr) {
                    seen.insert(addr.clone());
                    let mut email = Email::new(addr);
                    email.source = EmailSource::MailtoLink;
                    email.label = extract_email_label(&el);
                    emails.push(email);
                }
            }
        }
    }

    // From text content
    let text = document.root_element().text().collect::<String>();
    for caps in EMAIL_PATTERN.find_iter(&text) {
        let addr = caps.as_str().to_lowercase();
        if !seen.contains(&addr) && is_valid_email(&addr) {
            seen.insert(addr.clone());
            emails.push(Email::new(addr));
        }
    }

    // From structured data
    if let Ok(sel) = Selector::parse("[itemprop='email'], [property='email']") {
        for el in document.select(&sel) {
            let content = el.value().attr("content")
                .or_else(|| el.value().attr("href"))
                .map(|s| s.trim_start_matches("mailto:").to_lowercase())
                .or_else(|| Some(el.text().collect::<String>().trim().to_lowercase()));
            
            if let Some(addr) = content {
                if EMAIL_PATTERN.is_match(&addr) && !seen.contains(&addr) {
                    seen.insert(addr.clone());
                    let mut email = Email::new(addr);
                    email.source = EmailSource::StructuredData;
                    emails.push(email);
                }
            }
        }
    }

    emails
}

/// Validate email address
fn is_valid_email(email: &str) -> bool {
    // Reject image file extensions often caught by regex
    let invalid_endings = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
    !invalid_endings.iter().any(|e| email.ends_with(e))
}

/// Extract label for email from surrounding context
fn extract_email_label(element: &ElementRef) -> Option<String> {
    let text = element.text().collect::<String>().trim().to_lowercase();
    
    let labels = ["support", "sales", "info", "contact", "help", "billing", "press", "careers", "jobs"];
    for label in labels {
        if text.contains(label) {
            return Some(label.to_string());
        }
    }
    
    None
}

/// Extract phone numbers from document
pub fn extract_phones(document: &Html) -> Vec<Phone> {
    let mut phones = Vec::new();
    let mut seen = HashSet::new();

    // From tel: links
    if let Ok(sel) = Selector::parse("a[href^='tel:']") {
        for el in document.select(&sel) {
            if let Some(href) = el.value().attr("href") {
                let raw = href.trim_start_matches("tel:").to_string();
                let normalized = Phone::new(raw.clone()).normalized.clone();
                
                if normalized.len() >= 10 && !seen.contains(&normalized) {
                    seen.insert(normalized);
                    let mut phone = Phone::new(raw);
                    phone.label = extract_phone_label(&el);
                    phone.phone_type = detect_phone_type(&phone);
                    phones.push(phone);
                }
            }
        }
    }

    // From text content
    let text = document.root_element().text().collect::<String>();
    for caps in PHONE_PATTERN.find_iter(&text) {
        let raw = caps.as_str().to_string();
        let normalized = Phone::new(raw.clone()).normalized.clone();
        
        if normalized.len() >= 10 && !seen.contains(&normalized) {
            seen.insert(normalized);
            let mut phone = Phone::new(raw);
            phone.phone_type = detect_phone_type(&phone);
            phones.push(phone);
        }
    }

    // From structured data
    if let Ok(sel) = Selector::parse("[itemprop='telephone'], [property='telephone']") {
        for el in document.select(&sel) {
            let content = el.value().attr("content")
                .map(|s| s.to_string())
                .or_else(|| Some(el.text().collect::<String>().trim().to_string()));
            
            if let Some(raw) = content {
                let normalized = Phone::new(raw.clone()).normalized.clone();
                if normalized.len() >= 10 && !seen.contains(&normalized) {
                    seen.insert(normalized);
                    phones.push(Phone::new(raw));
                }
            }
        }
    }

    phones
}

/// Extract phone label from context
fn extract_phone_label(element: &ElementRef) -> Option<String> {
    let text = element.text().collect::<String>().to_lowercase();
    
    if text.contains("fax") {
        Some("fax".to_string())
    } else if text.contains("mobile") || text.contains("cell") {
        Some("mobile".to_string())
    } else if text.contains("main") || text.contains("office") {
        Some("main".to_string())
    } else {
        None
    }
}

/// Detect phone type
fn detect_phone_type(phone: &Phone) -> PhoneType {
    if TOLL_FREE_PATTERN.is_match(&phone.raw) {
        PhoneType::TollFree
    } else if phone.label.as_ref().map(|l| l.contains("fax")).unwrap_or(false) {
        PhoneType::Fax
    } else if phone.label.as_ref().map(|l| l.contains("mobile") || l.contains("cell")).unwrap_or(false) {
        PhoneType::Mobile
    } else {
        PhoneType::Unknown
    }
}

/// Extract physical addresses from document
pub fn extract_addresses(document: &Html) -> Vec<Address> {
    let mut addresses = Vec::new();

    // From structured data (Schema.org)
    if let Ok(sel) = Selector::parse("[itemtype*='PostalAddress'], [itemprop='address']") {
        for el in document.select(&sel) {
            if let Some(addr) = extract_structured_address(&el) {
                addresses.push(addr);
            }
        }
    }

    // From address elements
    if let Ok(sel) = Selector::parse("address") {
        for el in document.select(&sel) {
            let text = el.text().collect::<String>().trim().to_string();
            if !text.is_empty() && text.len() > 10 {
                let mut addr = Address {
                    full_text: text,
                    ..Default::default()
                };
                extract_address_components(&mut addr);
                addresses.push(addr);
            }
        }
    }

    // Deduplicate
    addresses.dedup_by(|a, b| a.full_text == b.full_text);

    addresses
}

/// Extract address from structured data element
fn extract_structured_address(element: &ElementRef) -> Option<Address> {
    let mut addr = Address::default();

    let selectors = [
        ("streetAddress", "street"),
        ("addressLocality", "city"),
        ("addressRegion", "state"),
        ("postalCode", "postal_code"),
        ("addressCountry", "country"),
    ];

    for (itemprop, field) in selectors {
        if let Ok(sel) = Selector::parse(&format!("[itemprop='{}']", itemprop)) {
            if let Some(el) = element.select(&sel).next() {
                let value = el.value().attr("content")
                    .map(|s| s.to_string())
                    .or_else(|| Some(el.text().collect::<String>().trim().to_string()));
                
                match field {
                    "street" => addr.street = value,
                    "city" => addr.city = value,
                    "state" => addr.state = value,
                    "postal_code" => addr.postal_code = value,
                    "country" => addr.country = value,
                    _ => {}
                }
            }
        }
    }

    // Build full text
    let parts: Vec<&str> = [
        addr.street.as_deref(),
        addr.city.as_deref(),
        addr.state.as_deref(),
        addr.postal_code.as_deref(),
        addr.country.as_deref(),
    ].into_iter().flatten().collect();

    if parts.is_empty() {
        return None;
    }

    addr.full_text = parts.join(", ");
    Some(addr)
}

/// Extract address components from full text
fn extract_address_components(addr: &mut Address) {
    // Try to extract postal code
    if let Some(caps) = US_ZIP_PATTERN.find(&addr.full_text) {
        addr.postal_code = Some(caps.as_str().to_string());
    } else if let Some(caps) = UK_POSTAL_PATTERN.find(&addr.full_text) {
        addr.postal_code = Some(caps.as_str().to_string());
    } else if let Some(caps) = CA_POSTAL_PATTERN.find(&addr.full_text) {
        addr.postal_code = Some(caps.as_str().to_string());
    }
}

/// Extract social media links from document
pub fn extract_social_links(document: &Html) -> Vec<SocialLink> {
    let mut links = Vec::new();
    let mut seen = HashSet::new();

    if let Ok(sel) = Selector::parse("a[href]") {
        for el in document.select(&sel) {
            if let Some(href) = el.value().attr("href") {
                if let Some(platform) = detect_social_platform(href) {
                    let url = href.to_string();
                    if !seen.contains(&url) {
                        seen.insert(url.clone());
                        links.push(SocialLink {
                            platform,
                            url: url.clone(),
                            username: extract_social_username(&url, platform),
                        });
                    }
                }
            }
        }
    }

    links
}

/// Detect social platform from URL
fn detect_social_platform(url: &str) -> Option<SocialPlatform> {
    let url_lower = url.to_lowercase();
    
    let platforms = [
        ("facebook.com", SocialPlatform::Facebook),
        ("fb.com", SocialPlatform::Facebook),
        ("twitter.com", SocialPlatform::Twitter),
        ("x.com", SocialPlatform::Twitter),
        ("instagram.com", SocialPlatform::Instagram),
        ("linkedin.com", SocialPlatform::LinkedIn),
        ("youtube.com", SocialPlatform::YouTube),
        ("youtu.be", SocialPlatform::YouTube),
        ("tiktok.com", SocialPlatform::TikTok),
        ("pinterest.com", SocialPlatform::Pinterest),
        ("github.com", SocialPlatform::GitHub),
        ("reddit.com", SocialPlatform::Reddit),
        ("discord.gg", SocialPlatform::Discord),
        ("discord.com", SocialPlatform::Discord),
        ("t.me", SocialPlatform::Telegram),
        ("telegram.me", SocialPlatform::Telegram),
        ("wa.me", SocialPlatform::WhatsApp),
        ("whatsapp.com", SocialPlatform::WhatsApp),
        ("snapchat.com", SocialPlatform::Snapchat),
        ("tumblr.com", SocialPlatform::Tumblr),
        ("medium.com", SocialPlatform::Medium),
        ("twitch.tv", SocialPlatform::Twitch),
        ("vimeo.com", SocialPlatform::Vimeo),
        ("flickr.com", SocialPlatform::Flickr),
    ];

    for (domain, platform) in platforms {
        if url_lower.contains(domain) {
            return Some(platform);
        }
    }

    None
}

/// Extract username from social URL
fn extract_social_username(url: &str, platform: SocialPlatform) -> Option<String> {
    let url_lower = url.to_lowercase();
    
    // Remove protocol and www
    let cleaned = url_lower
        .trim_start_matches("https://")
        .trim_start_matches("http://")
        .trim_start_matches("www.");

    // Split by /
    let parts: Vec<&str> = cleaned.split('/').collect();
    
    match platform {
        SocialPlatform::Twitter | SocialPlatform::Instagram | 
        SocialPlatform::GitHub | SocialPlatform::TikTok => {
            // Format: platform.com/username
            parts.get(1).filter(|s| !s.is_empty() && !s.starts_with('?')).map(|s| s.to_string())
        }
        SocialPlatform::Facebook => {
            // Format: facebook.com/username or facebook.com/pages/name/id
            parts.get(1).filter(|s| !s.is_empty() && **s != "pages" && !s.starts_with('?')).map(|s| s.to_string())
        }
        SocialPlatform::YouTube => {
            // Format: youtube.com/c/channel or youtube.com/@handle
            if let Some(p) = parts.get(1) {
                if *p == "c" || *p == "channel" || *p == "user" {
                    return parts.get(2).map(|s| s.to_string());
                }
                if p.starts_with('@') {
                    return Some(p.to_string());
                }
            }
            None
        }
        _ => None,
    }
}

/// Find contact page link
fn find_contact_page(document: &Html) -> Option<String> {
    let contact_patterns = ["contact", "kontakt", "contacto", "contato"];
    
    if let Ok(sel) = Selector::parse("a[href]") {
        for el in document.select(&sel) {
            if let Some(href) = el.value().attr("href") {
                let href_lower = href.to_lowercase();
                let text_lower = el.text().collect::<String>().to_lowercase();
                
                for pattern in contact_patterns {
                    if href_lower.contains(pattern) || text_lower.contains(pattern) {
                        return Some(href.to_string());
                    }
                }
            }
        }
    }

    None
}

/// Extract business name from document
fn extract_business_name(document: &Html) -> Option<String> {
    // From structured data
    if let Ok(sel) = Selector::parse("[itemprop='name'], [property='og:site_name']") {
        if let Some(el) = document.select(&sel).next() {
            let text_content = el.text().collect::<String>();
            let name = el.value().attr("content")
                .or(Some(text_content.as_str()))
                .map(|s| s.trim().to_string());
            
            if let Some(ref n) = name {
                if !n.is_empty() && n.len() < 100 {
                    return name;
                }
            }
        }
    }

    None
}

// ============================================================================
// CONVENIENCE FUNCTIONS
// ============================================================================

/// Check if page has contact information
pub fn has_contact_info(document: &Html) -> bool {
    extract_contact_info(document)
        .map(|c| c.has_contact_info())
        .unwrap_or(false)
}

/// Get all emails from page
pub fn get_emails(document: &Html) -> Vec<String> {
    extract_emails(document)
        .into_iter()
        .map(|e| e.address)
        .collect()
}

/// Get all phone numbers from page
pub fn get_phones(document: &Html) -> Vec<String> {
    extract_phones(document)
        .into_iter()
        .map(|p| p.raw)
        .collect()
}

/// Get all social links from page
pub fn get_social_links(document: &Html) -> Vec<String> {
    extract_social_links(document)
        .into_iter()
        .map(|s| s.url)
        .collect()
}

// ============================================================================
// TESTS
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    fn parse_html(html: &str) -> Html {
        Html::parse_document(html)
    }

    #[test]
    fn test_extract_mailto_email() {
        let html = r#"
            <a href="mailto:contact@example.com">Contact Us</a>
        "#;
        
        let doc = parse_html(html);
        let emails = extract_emails(&doc);
        
        assert_eq!(emails.len(), 1);
        assert_eq!(emails[0].address, "contact@example.com");
        assert_eq!(emails[0].source, EmailSource::MailtoLink);
        assert!(emails[0].is_generic);
    }

    #[test]
    fn test_extract_text_email() {
        let html = r#"
            <p>Email us at john.doe@company.org for inquiries.</p>
        "#;
        
        let doc = parse_html(html);
        let emails = extract_emails(&doc);
        
        assert_eq!(emails.len(), 1);
        assert_eq!(emails[0].address, "john.doe@company.org");
        assert!(!emails[0].is_generic);
    }

    #[test]
    fn test_extract_phone_tel() {
        let html = r#"
            <a href="tel:+1-555-123-4567">Call Us</a>
        "#;
        
        let doc = parse_html(html);
        let phones = extract_phones(&doc);
        
        assert_eq!(phones.len(), 1);
        assert_eq!(phones[0].normalized, "+15551234567");
    }

    #[test]
    fn test_extract_toll_free() {
        let html = r#"
            <p>Call us at 1-800-555-1234</p>
        "#;
        
        let doc = parse_html(html);
        let phones = extract_phones(&doc);
        
        assert!(!phones.is_empty());
        assert_eq!(phones[0].phone_type, PhoneType::TollFree);
    }

    #[test]
    fn test_extract_social_links() {
        let html = r#"
            <a href="https://twitter.com/example">Twitter</a>
            <a href="https://facebook.com/example">Facebook</a>
            <a href="https://github.com/example">GitHub</a>
        "#;
        
        let doc = parse_html(html);
        let links = extract_social_links(&doc);
        
        assert_eq!(links.len(), 3);
        assert!(links.iter().any(|l| l.platform == SocialPlatform::Twitter));
        assert!(links.iter().any(|l| l.platform == SocialPlatform::Facebook));
        assert!(links.iter().any(|l| l.platform == SocialPlatform::GitHub));
    }

    #[test]
    fn test_extract_social_username() {
        assert_eq!(
            extract_social_username("https://twitter.com/johndoe", SocialPlatform::Twitter),
            Some("johndoe".to_string())
        );
        assert_eq!(
            extract_social_username("https://github.com/rust-lang", SocialPlatform::GitHub),
            Some("rust-lang".to_string())
        );
    }

    #[test]
    fn test_extract_structured_address() {
        let html = r#"
            <div itemscope itemtype="https://schema.org/PostalAddress">
                <span itemprop="streetAddress">123 Main St</span>
                <span itemprop="addressLocality">Springfield</span>
                <span itemprop="addressRegion">IL</span>
                <span itemprop="postalCode">62701</span>
                <span itemprop="addressCountry">USA</span>
            </div>
        "#;
        
        let doc = parse_html(html);
        let addresses = extract_addresses(&doc);
        
        assert_eq!(addresses.len(), 1);
        assert_eq!(addresses[0].street, Some("123 Main St".to_string()));
        assert_eq!(addresses[0].city, Some("Springfield".to_string()));
        assert_eq!(addresses[0].postal_code, Some("62701".to_string()));
    }

    #[test]
    fn test_find_contact_page() {
        let html = r#"
            <nav>
                <a href="/about">About</a>
                <a href="/contact">Contact Us</a>
            </nav>
        "#;
        
        let doc = parse_html(html);
        let contact = find_contact_page(&doc);
        
        assert_eq!(contact, Some("/contact".to_string()));
    }

    #[test]
    fn test_email_is_generic() {
        assert!(Email::new("info@example.com".to_string()).is_generic);
        assert!(Email::new("contact@example.com".to_string()).is_generic);
        assert!(Email::new("support@example.com".to_string()).is_generic);
        assert!(!Email::new("john.doe@example.com".to_string()).is_generic);
    }

    #[test]
    fn test_primary_email() {
        let mut info = ContactInfo::new();
        info.emails = vec![
            Email::new("info@example.com".to_string()),
            Email::new("john@example.com".to_string()),
        ];
        
        let primary = info.primary_email().unwrap();
        assert_eq!(primary.address, "john@example.com");
    }

    #[test]
    fn test_has_contact_info() {
        let html = r#"
            <a href="mailto:test@example.com">Email</a>
        "#;
        
        let doc = parse_html(html);
        assert!(has_contact_info(&doc));

        let html_empty = "<html><body><p>No contact info</p></body></html>";
        let doc_empty = parse_html(html_empty);
        assert!(!has_contact_info(&doc_empty));
    }

    #[test]
    fn test_x_twitter_detection() {
        let html = r#"
            <a href="https://x.com/example">X (Twitter)</a>
        "#;
        
        let doc = parse_html(html);
        let links = extract_social_links(&doc);
        
        assert_eq!(links.len(), 1);
        assert_eq!(links[0].platform, SocialPlatform::Twitter);
    }

    #[test]
    fn test_youtube_username_extraction() {
        assert_eq!(
            extract_social_username("https://youtube.com/@handle", SocialPlatform::YouTube),
            Some("@handle".to_string())
        );
        assert_eq!(
            extract_social_username("https://youtube.com/c/channelname", SocialPlatform::YouTube),
            Some("channelname".to_string())
        );
    }
}