domain-check-lib 1.2.0

//! Main domain checker implementation.
//!
//! This module provides the primary `DomainChecker` struct that orchestrates
//! domain availability checking using RDAP, WHOIS, and bootstrap protocols.

use crate::error::DomainCheckError;
use crate::forsale::{ForSaleFailures, ForSaleLookup};
use crate::protocols::{RdapClient, WhoisClient};
use crate::types::{CheckConfig, CheckMethod, DomainResult};
use crate::utils::validate_domain;
use futures_util::stream::{Stream, StreamExt};
use std::net::IpAddr;
use std::pin::Pin;
use std::sync::Arc;
use tokio::sync::Semaphore;

/// Check a single domain using the provided clients (for concurrent processing).
///
/// This is a helper function that implements the same logic as `check_domain`
/// but works with cloned client instances for concurrent execution.
async fn check_availability_concurrent(
    domain: &str,
    rdap_client: &RdapClient,
    whois_client: &WhoisClient,
    config: &CheckConfig,
) -> Result<DomainResult, DomainCheckError> {
    // Validate domain format first
    validate_domain(domain)?;

    // Try RDAP first
    match rdap_client.check_domain(domain).await {
        Ok(result) => Ok(filter_result_info(config, result)),
        Err(rdap_error) => {
            // RDAP failed, try WHOIS fallback if enabled
            if config.enable_whois_fallback {
                // The client finds the registry's WHOIS server via IANA
                let whois_result = whois_client.check_domain(domain).await;

                match whois_result {
                    Ok(whois_result) => Ok(filter_result_info(config, whois_result)),
                    Err(whois_error) => {
                        // Both RDAP and WHOIS failed, determine best response

                        // Only trust RDAP 404 when WHOIS agrees, or when the
                        // registry has no WHOIS to ask (e.g. .dev, .app).
                        // RDAP 404 alone is not reliable — some registries
                        // (e.g. .moe) return 404 for registered domains.
                        if rdap_404_is_final(&rdap_error, &whois_error)
                            || (rdap_error.indicates_available()
                                && whois_error.indicates_available())
                        {
                            Ok(DomainResult {
                                domain: domain.to_string(),
                                available: Some(true),
                                info: None,
                                check_duration: None,
                                method_used: CheckMethod::Rdap,
                                error_message: None,
                                for_sale: None,
                            })
                        }
                        // WHOIS alone indicates available (RDAP failed for
                        // a different reason like timeout or 5xx)
                        else if whois_error.indicates_available() {
                            Ok(DomainResult {
                                domain: domain.to_string(),
                                available: Some(true),
                                info: None,
                                check_duration: None,
                                method_used: CheckMethod::Whois,
                                error_message: None,
                                for_sale: None,
                            })
                        }
                        // Check if it's an unknown TLD or truly ambiguous case
                        else if matches!(rdap_error, DomainCheckError::BootstrapError { .. })
                            || matches!(
                                whois_error,
                                DomainCheckError::BootstrapError { .. }
                                    | DomainCheckError::WhoisError { .. }
                            )
                            || rdap_error.indicates_available()
                        {
                            // RDAP 404 without WHOIS corroboration, unknown TLD,
                            // or a WHOIS reply that could not be read → unknown,
                            // keeping WHOIS's reason (refused, rate limited, …)
                            let reason = whois_failure_reason(&whois_error);
                            Ok(DomainResult {
                                domain: domain.to_string(),
                                available: None, // Unknown status
                                info: None,
                                check_duration: None,
                                method_used: CheckMethod::Unknown,
                                error_message: Some(format!(
                                    "Unable to verify — RDAP inconclusive; WHOIS: {reason}"
                                )),
                                for_sale: None,
                            })
                        } else {
                            // Return the RDAP error as it's usually more informative
                            Err(rdap_error)
                        }
                    }
                }
            } else {
                // No fallback enabled — if RDAP 404 indicates availability,
                // return it as available with a warning rather than a raw error.
                if rdap_error.indicates_available() {
                    Ok(DomainResult {
                        domain: domain.to_string(),
                        available: Some(true),
                        info: None,
                        check_duration: None,
                        method_used: CheckMethod::Rdap,
                        error_message: Some(
                            "RDAP 404 (unverified — WHOIS fallback disabled)".to_string(),
                        ),
                        for_sale: None,
                    })
                } else {
                    Err(rdap_error)
                }
            }
        }
    }
}

/// RDAP 404 normally needs WHOIS to confirm it (some RDAP servers have
/// answered 404 for registered names). When IANA lists no WHOIS server for
/// the TLD there is nothing to confirm with, and RDAP is the registry's only
/// official source, so the 404 stands.
fn rdap_404_is_final(rdap_error: &DomainCheckError, whois_error: &DomainCheckError) -> bool {
    rdap_error.indicates_available() && crate::protocols::whois::is_no_whois_service(whois_error)
}

/// Short reason WHOIS could not answer, for UNKNOWN results.
fn whois_failure_reason(error: &DomainCheckError) -> String {
    match error {
        DomainCheckError::WhoisError { message, .. } => message.clone(),
        DomainCheckError::Timeout { duration, .. } => {
            format!("timed out after {}s", duration.as_secs())
        }
        _ => "unavailable".to_string(),
    }
}

/// Drop registration details unless `detailed_info` was requested.
fn filter_result_info(config: &CheckConfig, mut result: DomainResult) -> DomainResult {
    if !config.detailed_info {
        result.info = None;
    }
    result
}

/// Availability check followed by the optional for-sale lookup.
async fn check_single_domain_concurrent(
    domain: &str,
    rdap_client: &RdapClient,
    whois_client: &WhoisClient,
    config: &CheckConfig,
    for_sale: &ForSaleLookup,
) -> Result<DomainResult, DomainCheckError> {
    match check_availability_concurrent(domain, rdap_client, whois_client, config).await {
        Ok(mut result) => {
            for_sale.annotate(&mut result).await;
            Ok(result)
        }
        Err(error) => for_sale.annotate_error(domain, error).await,
    }
}

/// Main domain checker that coordinates availability checking operations.
///
/// The `DomainChecker` handles all aspects of domain checking including:
/// - Protocol selection (RDAP vs WHOIS)
/// - Concurrent processing
/// - Error handling and retries
/// - Result formatting
///
/// # Example
///
/// ```rust,no_run
/// use domain_check_lib::{DomainChecker, CheckConfig};
///
/// #[tokio::main]
/// async fn main() -> Result<(), Box<dyn std::error::Error>> {
///     let checker = DomainChecker::new();
///     let result = checker.check_domain("example.com").await?;
///     println!("Available: {:?}", result.available);
///     Ok(())
/// }
/// ```
#[derive(Clone)]
pub struct DomainChecker {
    /// Configuration settings for this checker instance
    config: CheckConfig,
    /// RDAP client for modern domain checking
    rdap_client: RdapClient,
    /// WHOIS client for fallback domain checking
    whois_client: WhoisClient,
    /// RFC 10023 for-sale lookups (inactive unless enabled)
    for_sale: ForSaleLookup,
    /// DNS server for for-sale lookups (None: the operating system's)
    dns_server: Option<IpAddr>,
}

impl DomainChecker {
    /// Create a new domain checker with default configuration.
    ///
    /// Default settings:
    /// - Concurrency: 20
    /// - Timeout: 5 seconds
    /// - WHOIS fallback: enabled
    /// - Bootstrap: enabled
    /// - Detailed info: disabled
    pub fn new() -> Self {
        let config = CheckConfig::default();
        let rdap_client = RdapClient::with_config(config.rdap_timeout, config.enable_bootstrap)
            .expect("Failed to create RDAP client");
        let whois_client = WhoisClient::with_timeout(config.whois_timeout);
        let for_sale = ForSaleLookup::new(&config, None);

        Self {
            config,
            rdap_client,
            whois_client,
            for_sale,
            dns_server: None,
        }
    }

    /// Create a new domain checker with custom configuration.
    ///
    /// # Example
    ///
    /// ```rust
    /// use domain_check_lib::{DomainChecker, CheckConfig};
    /// use std::time::Duration;
    ///
    /// let config = CheckConfig::default()
    ///     .with_concurrency(20)
    ///     .with_timeout(Duration::from_secs(10))
    ///     .with_detailed_info(true);
    ///     
    /// let checker = DomainChecker::with_config(config);
    /// ```
    pub fn with_config(config: CheckConfig) -> Self {
        let rdap_client = RdapClient::with_config(config.rdap_timeout, config.enable_bootstrap)
            .expect("Failed to create RDAP client");
        let whois_client = WhoisClient::with_timeout(config.whois_timeout);
        let for_sale = ForSaleLookup::new(&config, None);

        Self {
            config,
            rdap_client,
            whois_client,
            for_sale,
            dns_server: None,
        }
    }

    /// Check availability of a single domain.
    ///
    /// This is the most basic operation - check one domain and return the result.
    /// The domain should be a fully qualified domain name (e.g., "example.com").
    ///
    /// The checking process:
    /// 1. Validates the domain format
    /// 2. Attempts RDAP check first (modern protocol)
    /// 3. Falls back to WHOIS if RDAP fails and fallback is enabled
    /// 4. Returns comprehensive result with timing and method information
    /// 5. If enabled, looks up the RFC 10023 `_for-sale` record for taken domains
    ///
    /// # Arguments
    ///
    /// * `domain` - The domain name to check (e.g., "example.com")
    ///
    /// # Returns
    ///
    /// A `DomainResult` containing availability status and optional details.
    ///
    /// # Errors
    ///
    /// Returns `DomainCheckError` if:
    /// - The domain name is invalid
    /// - Network errors occur
    /// - All checking methods fail
    pub async fn check_domain(&self, domain: &str) -> Result<DomainResult, DomainCheckError> {
        check_single_domain_concurrent(
            domain,
            &self.rdap_client,
            &self.whois_client,
            &self.config,
            &self.for_sale,
        )
        .await
    }

    /// Check availability of multiple domains concurrently.
    ///
    /// This method processes all domains in parallel according to the
    /// concurrency setting, then returns all results at once.
    ///
    /// # Arguments
    ///
    /// * `domains` - Slice of domain names to check
    ///
    /// # Returns
    ///
    /// Vector of `DomainResult` in the same order as input domains.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use domain_check_lib::DomainChecker;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let checker = DomainChecker::new();
    ///     let domains = vec!["example.com".to_string(), "google.com".to_string(), "test.org".to_string()];
    ///     let results = checker.check_domains(&domains).await?;
    ///     
    ///     for result in results {
    ///         println!("{}: {:?}", result.domain, result.available);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub async fn check_domains(
        &self,
        domains: &[String],
    ) -> Result<Vec<DomainResult>, DomainCheckError> {
        if domains.is_empty() {
            return Ok(Vec::new());
        }

        // Create semaphore to limit concurrent operations
        let semaphore = Arc::new(Semaphore::new(self.config.concurrency));
        let mut handles = Vec::new();

        // Spawn concurrent tasks for each domain
        for (index, domain) in domains.iter().enumerate() {
            let domain = domain.clone();
            let semaphore = Arc::clone(&semaphore);

            // Clone the checker components we need
            let rdap_client = self.rdap_client.clone();
            let whois_client = self.whois_client.clone();
            let config = self.config.clone();
            let for_sale = self.for_sale.clone();

            let handle = tokio::spawn(async move {
                // Acquire semaphore permit
                let _permit = semaphore.acquire().await.unwrap();

                // Check this domain
                let result = check_single_domain_concurrent(
                    &domain,
                    &rdap_client,
                    &whois_client,
                    &config,
                    &for_sale,
                )
                .await;

                // Return with original index to maintain order
                (index, result)
            });

            handles.push(handle);
        }

        // Wait for all tasks to complete and collect results
        let mut indexed_results = Vec::new();
        for handle in handles {
            match handle.await {
                Ok((index, result)) => indexed_results.push((index, result)),
                Err(e) => {
                    return Err(DomainCheckError::internal(format!(
                        "Concurrent task failed: {}",
                        e
                    )));
                }
            }
        }

        // Sort by original index to maintain input order
        indexed_results.sort_by_key(|(index, _)| *index);

        // Extract results, converting errors to DomainResult with error info
        let results = indexed_results
            .into_iter()
            .map(|(index, result)| match result {
                Ok(domain_result) => domain_result,
                Err(e) => DomainResult {
                    domain: domains[index].clone(),
                    available: None,
                    info: None,
                    check_duration: None,
                    method_used: CheckMethod::Unknown,
                    error_message: Some(e.to_string()),
                    for_sale: None,
                },
            })
            .collect();

        Ok(results)
    }

    /// Check domains and return results as a stream.
    ///
    /// This method yields results as they become available, which is useful
    /// for real-time updates or when processing large numbers of domains.
    /// Results are returned in the order they complete, not input order.
    ///
    /// # Arguments
    ///
    /// * `domains` - Slice of domain names to check
    ///
    /// # Returns
    ///
    /// A stream that yields `DomainResult` items as they complete.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use domain_check_lib::DomainChecker;
    /// use futures_util::StreamExt;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let checker = DomainChecker::new();
    ///     let domains = vec!["example.com".to_string(), "google.com".to_string()];
    ///     
    ///     let mut stream = checker.check_domains_stream(&domains);
    ///     while let Some(result) = stream.next().await {
    ///         match result {
    ///             Ok(domain_result) => println!("✓ {}: {:?}", domain_result.domain, domain_result.available),
    ///             Err(e) => println!("✗ Error: {}", e),
    ///         }
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn check_domains_stream(
        &self,
        domains: &[String],
    ) -> Pin<Box<dyn Stream<Item = Result<DomainResult, DomainCheckError>> + Send + '_>> {
        let domains = domains.to_vec();
        let semaphore = Arc::new(Semaphore::new(self.config.concurrency));

        // Create stream of futures
        let stream = futures_util::stream::iter(domains)
            .map(move |domain| {
                let semaphore = Arc::clone(&semaphore);
                let rdap_client = self.rdap_client.clone();
                let whois_client = self.whois_client.clone();
                let config = self.config.clone();
                let for_sale = self.for_sale.clone();

                async move {
                    // Acquire semaphore permit
                    let _permit = semaphore.acquire().await.unwrap();

                    // Check domain
                    check_single_domain_concurrent(
                        &domain,
                        &rdap_client,
                        &whois_client,
                        &config,
                        &for_sale,
                    )
                    .await
                }
            })
            // Buffer unordered allows concurrent execution while maintaining the stream interface
            .buffer_unordered(self.config.concurrency);

        Box::pin(stream)
    }

    /// Read domain names from a file and check their availability.
    ///
    /// The file should contain one domain name per line. Empty lines and
    /// lines starting with '#' are ignored as comments.
    ///
    /// # Arguments
    ///
    /// * `file_path` - Path to the file containing domain names
    ///
    /// # Returns
    ///
    /// Vector of `DomainResult` for all valid domains in the file.
    ///
    /// # Errors
    ///
    /// Returns `DomainCheckError` if:
    /// - The file cannot be read
    /// - The file contains too many domains (over limit)
    /// - No valid domains are found in the file
    pub async fn check_domains_from_file(
        &self,
        file_path: &str,
    ) -> Result<Vec<DomainResult>, DomainCheckError> {
        use std::fs::File;
        use std::io::{BufRead, BufReader};
        use std::path::Path;

        // Check if file exists
        let path = Path::new(file_path);
        if !path.exists() {
            return Err(DomainCheckError::file_error(file_path, "File not found"));
        }

        // Read domains from file
        let file = File::open(path).map_err(|e| {
            DomainCheckError::file_error(file_path, format!("Cannot open file: {}", e))
        })?;

        let reader = BufReader::new(file);
        let mut domains = Vec::new();
        let mut line_num = 0;

        for line in reader.lines() {
            line_num += 1;
            match line {
                Ok(line) => {
                    let trimmed = line.trim();

                    // Skip empty lines and comments
                    if trimmed.is_empty() || trimmed.starts_with('#') {
                        continue;
                    }

                    // Handle inline comments
                    let domain_part = trimmed.split('#').next().unwrap_or("").trim();
                    if !domain_part.is_empty() && domain_part.len() >= 2 {
                        domains.push(domain_part.to_string());
                    }
                }
                Err(e) => {
                    return Err(DomainCheckError::file_error(
                        file_path,
                        format!("Error reading line {}: {}", line_num, e),
                    ));
                }
            }
        }

        if domains.is_empty() {
            return Err(DomainCheckError::file_error(
                file_path,
                "No valid domains found in file",
            ));
        }

        // Check domains using existing concurrent logic
        self.check_domains(&domains).await
    }

    /// Get the current configuration for this checker.
    pub fn config(&self) -> &CheckConfig {
        &self.config
    }

    /// Whether RFC 10023 for-sale lookups will run: requested in the config,
    /// built with the `forsale` feature, and a system resolver is available.
    pub fn for_sale_enabled(&self) -> bool {
        self.for_sale.is_active()
    }

    /// Use `server` for `_for-sale` lookups instead of the operating
    /// system's DNS settings. Nothing falls back to a public resolver on
    /// its own: that would send the looked-up names to a third party.
    ///
    /// ```rust
    /// use domain_check_lib::{CheckConfig, DomainChecker};
    ///
    /// let checker = DomainChecker::with_config(CheckConfig::default().with_for_sale(true))
    ///     .with_dns_server("1.1.1.1".parse().unwrap());
    /// ```
    pub fn with_dns_server(mut self, server: IpAddr) -> Self {
        self.dns_server = Some(server);
        self.for_sale = ForSaleLookup::new(&self.config, self.dns_server);
        self
    }

    /// `_for-sale` lookups that failed (timeout, unreachable DNS server, …)
    /// since this checker was created. A failed lookup is indistinguishable
    /// from "not for sale" in the results, so report this to the user.
    pub fn for_sale_failures(&self) -> Option<ForSaleFailures> {
        self.for_sale.failures()
    }

    /// Update the configuration for this checker.
    ///
    /// This allows modifying settings like concurrency or timeout
    /// after the checker has been created. Note that this will recreate
    /// the internal protocol clients with the new settings.
    pub fn set_config(&mut self, config: CheckConfig) {
        // Recreate clients with new configuration
        self.rdap_client = RdapClient::with_config(config.rdap_timeout, config.enable_bootstrap)
            .expect("Failed to recreate RDAP client");
        self.whois_client = WhoisClient::with_timeout(config.whois_timeout);
        self.for_sale = ForSaleLookup::new(&config, self.dns_server);
        self.config = config;
    }
}

impl Default for DomainChecker {
    fn default() -> Self {
        Self::new()
    }
}

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

    // ── WHOIS failure reasons ───────────────────────────────────────────

    #[test]
    fn whois_timeout_reason_is_kept() {
        // Was "WHOIS: unavailable", shown as a vague "(error)" (#39).
        let timeout = DomainCheckError::timeout("WHOIS query", std::time::Duration::from_secs(5));
        assert!(whois_failure_reason(&timeout).contains("timed out"));
        let refused = DomainCheckError::whois("x.ch", "WHOIS server refused the query");
        assert_eq!(
            whois_failure_reason(&refused),
            "WHOIS server refused the query"
        );
    }

    // ── RDAP 404 without any WHOIS service ──────────────────────────────

    #[test]
    fn rdap_404_is_final_only_when_registry_has_no_whois() {
        let not_found = DomainCheckError::rdap_with_status("x.dev", "not found", 404);
        let no_whois = crate::protocols::whois::no_whois_service_error("x.dev");
        assert!(rdap_404_is_final(&not_found, &no_whois));

        // WHOIS exists but could not answer: keep requiring confirmation.
        let refused = DomainCheckError::whois("x.moe", "WHOIS server refused the query");
        assert!(!rdap_404_is_final(&not_found, &refused));
        let timeout = DomainCheckError::timeout("WHOIS query", std::time::Duration::from_secs(5));
        assert!(!rdap_404_is_final(&not_found, &timeout));

        // Not a 404: nothing to trust.
        let server_error = DomainCheckError::rdap_with_status("x.dev", "boom", 500);
        assert!(!rdap_404_is_final(&server_error, &no_whois));
    }
    use crate::types::DomainInfo;
    use std::time::Duration;

    // ── DomainChecker creation ──────────────────────────────────────────

    #[test]
    fn test_domain_checker_new() {
        let checker = DomainChecker::new();
        assert_eq!(checker.config().concurrency, 20);
        assert!(checker.config().enable_whois_fallback);
        assert!(checker.config().enable_bootstrap);
        assert!(!checker.config().detailed_info);
    }

    #[test]
    fn test_domain_checker_default() {
        let checker = DomainChecker::default();
        assert_eq!(checker.config().concurrency, 20);
    }

    #[test]
    fn test_domain_checker_with_config() {
        let config = CheckConfig::default()
            .with_concurrency(50)
            .with_timeout(Duration::from_secs(10))
            .with_detailed_info(true)
            .with_whois_fallback(false);

        let checker = DomainChecker::with_config(config);
        assert_eq!(checker.config().concurrency, 50);
        assert_eq!(checker.config().timeout, Duration::from_secs(10));
        assert!(checker.config().detailed_info);
        assert!(!checker.config().enable_whois_fallback);
    }

    #[test]
    fn for_sale_enabled_false_when_not_requested() {
        assert!(!DomainChecker::new().for_sale_enabled());
    }

    // ── config() and set_config() ───────────────────────────────────────

    #[test]
    fn test_config_accessor() {
        let checker = DomainChecker::new();
        let config = checker.config();
        assert_eq!(config.concurrency, 20);
    }

    #[test]
    fn test_set_config() {
        let mut checker = DomainChecker::new();
        assert_eq!(checker.config().concurrency, 20);

        let new_config = CheckConfig::default().with_concurrency(75);
        checker.set_config(new_config);
        assert_eq!(checker.config().concurrency, 75);
    }

    // ── filter_result_info ──────────────────────────────────────────────

    #[test]
    fn test_filter_result_info_removes_when_disabled() {
        let checker = DomainChecker::new(); // detailed_info = false by default
        let result = DomainResult {
            domain: "test.com".to_string(),
            available: Some(false),
            info: Some(DomainInfo {
                registrar: Some("Test Registrar".to_string()),
                ..Default::default()
            }),
            check_duration: None,
            method_used: CheckMethod::Rdap,
            error_message: None,
            for_sale: None,
        };

        let filtered = filter_result_info(&checker.config, result);
        assert!(filtered.info.is_none());
    }

    #[test]
    fn test_filter_result_info_preserves_when_enabled() {
        let config = CheckConfig::default().with_detailed_info(true);
        let checker = DomainChecker::with_config(config);

        let result = DomainResult {
            domain: "test.com".to_string(),
            available: Some(false),
            info: Some(DomainInfo {
                registrar: Some("Test Registrar".to_string()),
                ..Default::default()
            }),
            check_duration: None,
            method_used: CheckMethod::Rdap,
            error_message: None,
            for_sale: None,
        };

        let filtered = filter_result_info(&checker.config, result);
        assert!(filtered.info.is_some());
        assert_eq!(
            filtered.info.unwrap().registrar,
            Some("Test Registrar".to_string())
        );
    }

    #[test]
    fn test_filter_result_info_no_info_noop() {
        let checker = DomainChecker::new();
        let result = DomainResult {
            domain: "test.com".to_string(),
            available: Some(true),
            info: None,
            check_duration: None,
            method_used: CheckMethod::Rdap,
            error_message: None,
            for_sale: None,
        };

        let filtered = filter_result_info(&checker.config, result);
        assert!(filtered.info.is_none());
        assert_eq!(filtered.available, Some(true));
    }

    // ── check_domains with empty list ───────────────────────────────────

    #[tokio::test]
    async fn test_check_domains_empty_list() {
        let checker = DomainChecker::new();
        let results = checker.check_domains(&[]).await.unwrap();
        assert!(results.is_empty());
    }

    // ── check_domains_from_file errors ──────────────────────────────────

    #[tokio::test]
    async fn test_check_domains_from_nonexistent_file() {
        let checker = DomainChecker::new();
        let result = checker
            .check_domains_from_file("/tmp/nonexistent_file_xyz_987.txt")
            .await;
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("not found"));
    }

    #[tokio::test]
    async fn test_check_domains_from_empty_file() {
        use std::io::Write;
        let mut f = tempfile::NamedTempFile::new().unwrap();
        writeln!(f, "# just a comment").unwrap();
        writeln!(f).unwrap();
        f.flush().unwrap();

        let checker = DomainChecker::new();
        let result = checker
            .check_domains_from_file(f.path().to_str().unwrap())
            .await;
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("No valid domains"));
    }

    #[tokio::test]
    async fn test_check_domains_from_file_parses_correctly() {
        use std::io::Write;
        let mut f = tempfile::NamedTempFile::new().unwrap();
        writeln!(f, "# Header comment").unwrap();
        writeln!(f, "example.com").unwrap();
        writeln!(f).unwrap();
        writeln!(f, "test.org  # inline comment").unwrap();
        writeln!(f, "   ").unwrap();
        writeln!(f, "short").unwrap(); // only 5 chars but >= 2 so it's valid
        f.flush().unwrap();

        // We can't actually check domains in tests (network), but we can
        // verify the file parsing by checking that it doesn't error on
        // "no valid domains" — meaning it found at least one valid domain.
        // The actual network check will fail, but that's expected.
        let checker = DomainChecker::new();
        let result = checker
            .check_domains_from_file(f.path().to_str().unwrap())
            .await;
        // It won't error with "No valid domains" — it will either succeed or
        // fail on network. The file parsing itself worked.
        if let Err(e) = &result {
            assert!(
                !e.to_string().contains("No valid domains"),
                "File should have valid domains"
            );
        }
    }

    // ── RDAP 404 fallback behavior ────────────────────────────────────

    #[tokio::test]
    async fn test_no_whois_fallback_with_indicates_available_error() {
        // When WHOIS fallback is disabled, an RDAP 404 should still return
        // Ok(available=true) with a warning — not a raw error.
        let config = CheckConfig::default().with_whois_fallback(false);
        let checker = DomainChecker::with_config(config);

        // Use a domain that will likely get RDAP 404 or any RDAP error.
        // The key assertion: if RDAP fails with indicates_available()=true
        // and WHOIS is disabled, we get Ok with a warning, not Err.
        let rdap_error =
            DomainCheckError::rdap_with_status("test.example", "RDAP returned 404", 404);
        assert!(
            rdap_error.indicates_available(),
            "RDAP 404 should indicate available"
        );

        // Verify the checker config has WHOIS disabled
        assert!(
            !checker.config().enable_whois_fallback,
            "WHOIS fallback should be disabled for this test"
        );
    }
}