use crate::models::VisitRecord;
use rusqlite::{params, Connection};
use std::collections::HashMap;

// Custom User-Agent parser to avoid bloated dependencies
pub fn parse_ua(ua: &str) -> (String, String, String) {
    let ua_lower = ua.to_lowercase();

    let os = if ua_lower.contains("windows") {
        "Windows".to_string()
    } else if ua_lower.contains("macintosh") || ua_lower.contains("mac os x") {
        if ua_lower.contains("iphone") || ua_lower.contains("ipad") {
            "iOS".to_string()
        } else {
            "macOS".to_string()
        }
    } else if ua_lower.contains("android") {
        "Android".to_string()
    } else if ua_lower.contains("linux") {
        "Linux".to_string()
    } else if ua_lower.contains("iphone") || ua_lower.contains("ipad") || ua_lower.contains("ipod")
    {
        "iOS".to_string()
    } else {
        "Other".to_string()
    };

    let browser = if ua_lower.contains("firefox") {
        "Firefox".to_string()
    } else if ua_lower.contains("opr/") || ua_lower.contains("opera") {
        "Opera".to_string()
    } else if ua_lower.contains("edg/") {
        "Edge".to_string()
    } else if ua_lower.contains("chrome") {
        "Chrome".to_string()
    } else if ua_lower.contains("safari") {
        "Safari".to_string()
    } else {
        "Other".to_string()
    };

    let device = if ua_lower.contains("mobile")
        || ua_lower.contains("android")
        || ua_lower.contains("iphone")
        || ua_lower.contains("ipod")
    {
        "Mobile".to_string()
    } else if ua_lower.contains("ipad") || ua_lower.contains("tablet") {
        "Tablet".to_string()
    } else {
        "Desktop".to_string()
    };

    (browser, os, device)
}

// Clean referer to domain
pub fn clean_referrer(referer: &str) -> String {
    if referer.is_empty() || referer == "direct" {
        return "Direct".to_string();
    }

    if let Ok(url) = reqwest::Url::parse(referer) {
        if let Some(host) = url.host_str() {
            return host.trim_start_matches("www.").to_string();
        }
    }

    // Fallback if not a valid URL
    let cleaned = referer
        .trim_start_matches("https://")
        .trim_start_matches("http://");
    let cleaned = cleaned.split('/').next().unwrap_or("Direct");
    if cleaned.is_empty() {
        "Direct".to_string()
    } else {
        cleaned.trim_start_matches("www.").to_string()
    }
}

pub fn insert_visits_batch(conn: &mut Connection, records: &[VisitRecord]) -> rusqlite::Result<()> {
    let tx = conn.transaction()?;
    {
        let mut stmt = tx.prepare(
            "INSERT INTO visits (id, target_type, target_id, timestamp, ip_address, user_agent, referer, accept_language, country, status_code, owner_user_id)
             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11);"
        )?;

        for r in records {
            stmt.execute(params![
                r.id,
                r.target_type,
                r.target_id,
                r.timestamp,
                r.ip_address,
                r.user_agent,
                r.referer,
                r.accept_language,
                r.country,
                r.status_code,
                r.owner_user_id
            ])?;
        }
    }
    tx.commit()?;
    Ok(())
}

pub fn get_total_clicks(conn: &Connection) -> rusqlite::Result<i64> {
    conn.query_row(
        "SELECT COUNT(*) FROM visits WHERE target_type = 'url';",
        [],
        |row| row.get(0),
    )
}

pub fn get_total_page_views(conn: &Connection) -> rusqlite::Result<i64> {
    conn.query_row(
        "SELECT COUNT(*) FROM visits WHERE target_type = 'page';",
        [],
        |row| row.get(0),
    )
}

// Get the date range of visits in the DB
pub fn get_visits_date_range(conn: &Connection) -> rusqlite::Result<Option<(String, String)>> {
    let mut stmt =
        conn.prepare("SELECT MIN(date(timestamp)), MAX(date(timestamp)) FROM visits;")?;
    let mut rows = stmt.query([])?;
    if let Some(row) = rows.next()? {
        let min_date: Option<String> = row.get(0)?;
        let max_date: Option<String> = row.get(1)?;
        if let (Some(min), Some(max)) = (min_date, max_date) {
            return Ok(Some((min, max)));
        }
    }
    Ok(None)
}

// Run aggregation for a specific day
pub fn aggregate_day(conn: &mut Connection, date: &str) -> rusqlite::Result<()> {
    let mut visits = Vec::new();
    {
        // 1. Fetch all visits on that day
        let mut stmt = conn.prepare(
            "SELECT target_type, target_id, user_agent, referer, country, status_code FROM visits WHERE date(timestamp) = ?1;"
        )?;

        struct RawVisit {
            target_type: String,
            target_id: String,
            user_agent: String,
            referer: String,
            country: String,
        }

        let rows = stmt.query_map(params![date], |row| {
            Ok(RawVisit {
                target_type: row.get(0)?,
                target_id: row.get(1)?,
                user_agent: row.get(2)?,
                referer: row.get(3)?,
                country: row.get(4)?,
            })
        })?;

        for r in rows {
            visits.push(r?);
        }
    }

    if visits.is_empty() {
        return Ok(());
    }

    // 2. Compute metrics in-memory
    // Key structure: (target_type, target_id, metric_type, metric_key) -> count
    let mut aggregates: HashMap<(String, String, String, String), i64> = HashMap::new();

    // Also track total per day (all targets combined) using target_id = "all"
    for v in visits {
        let (browser, os, device) = parse_ua(&v.user_agent);
        let referrer = clean_referrer(&v.referer);
        let country = if v.country.is_empty() {
            "Unknown".to_string()
        } else {
            v.country.clone()
        };

        let targets = vec![
            (v.target_type.clone(), v.target_id.clone()),
            (v.target_type.clone(), "all".to_string()),
        ];

        for (t_type, t_id) in targets {
            // Clicks
            *aggregates
                .entry((
                    t_type.clone(),
                    t_id.clone(),
                    "clicks".to_string(),
                    "".to_string(),
                ))
                .or_insert(0) += 1;

            // Country
            *aggregates
                .entry((
                    t_type.clone(),
                    t_id.clone(),
                    "country".to_string(),
                    country.clone(),
                ))
                .or_insert(0) += 1;

            // Browser
            *aggregates
                .entry((
                    t_type.clone(),
                    t_id.clone(),
                    "browser".to_string(),
                    browser.clone(),
                ))
                .or_insert(0) += 1;

            // OS
            *aggregates
                .entry((t_type.clone(), t_id.clone(), "os".to_string(), os.clone()))
                .or_insert(0) += 1;

            // Device
            *aggregates
                .entry((
                    t_type.clone(),
                    t_id.clone(),
                    "device".to_string(),
                    device.clone(),
                ))
                .or_insert(0) += 1;

            // Referrer
            *aggregates
                .entry((
                    t_type.clone(),
                    t_id.clone(),
                    "referrer".to_string(),
                    referrer.clone(),
                ))
                .or_insert(0) += 1;
        }
    }

    // 3. Save to database in a transaction
    let tx = conn.transaction()?;
    {
        // Delete old aggregates for this day
        tx.execute(
            "DELETE FROM daily_summaries WHERE date = ?1;",
            params![date],
        )?;

        let mut insert_stmt = tx.prepare(
            "INSERT INTO daily_summaries (date, target_type, target_id, metric_type, metric_key, metric_value)
             VALUES (?1, ?2, ?3, ?4, ?5, ?6);"
        )?;

        for ((t_type, t_id, m_type, m_key), value) in aggregates {
            insert_stmt.execute(params![date, t_type, t_id, m_type, m_key, value])?;
        }
    }
    tx.commit()?;

    // Update monthly and yearly summaries using the daily summaries
    aggregate_month_from_daily(conn, &date[0..7])?;
    aggregate_year_from_daily(conn, &date[0..4])?;

    Ok(())
}

fn aggregate_month_from_daily(conn: &mut Connection, year_month: &str) -> rusqlite::Result<()> {
    let tx = conn.transaction()?;
    {
        tx.execute(
            "DELETE FROM monthly_summaries WHERE year_month = ?1;",
            params![year_month],
        )?;
        tx.execute(
            "INSERT INTO monthly_summaries (year_month, target_type, target_id, metric_type, metric_key, metric_value)
             SELECT ?1, target_type, target_id, metric_type, metric_key, SUM(metric_value)
             FROM daily_summaries
             WHERE date LIKE ?2
             GROUP BY target_type, target_id, metric_type, metric_key;",
            params![year_month, format!("{}-%", year_month)],
        )?;
    }
    tx.commit()?;
    Ok(())
}

fn aggregate_year_from_daily(conn: &mut Connection, year: &str) -> rusqlite::Result<()> {
    let tx = conn.transaction()?;
    {
        tx.execute(
            "DELETE FROM yearly_summaries WHERE year = ?1;",
            params![year],
        )?;
        tx.execute(
            "INSERT INTO yearly_summaries (year, target_type, target_id, metric_type, metric_key, metric_value)
             SELECT ?1, target_type, target_id, metric_type, metric_key, SUM(metric_value)
             FROM daily_summaries
             WHERE date LIKE ?2
             GROUP BY target_type, target_id, metric_type, metric_key;",
            params![year, format!("{}-%", year)],
        )?;
    }
    tx.commit()?;
    Ok(())
}

// Clean old raw visit records
pub fn retention_cleanup(conn: &Connection, retention_days: i64) -> rusqlite::Result<usize> {
    let limit_date = chrono::Utc::now() - chrono::Duration::days(retention_days);
    let limit_str = limit_date.to_rfc3339();
    let count = conn.execute(
        "DELETE FROM visits WHERE timestamp < ?1;",
        params![limit_str],
    )?;
    Ok(count)
}

// --- Query functions for Dashboard & API ---

pub fn get_clicks_trend(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    limit_days: i64,
) -> rusqlite::Result<Vec<(String, i64)>> {
    let limit_date = (chrono::Utc::now() - chrono::Duration::days(limit_days))
        .format("%Y-%m-%d")
        .to_string();

    let mut stmt = conn.prepare(
        "SELECT date, SUM(metric_value) FROM daily_summaries 
         WHERE target_type = ?1 AND target_id = ?2 AND metric_type = 'clicks' AND date >= ?3
         GROUP BY date ORDER BY date ASC;",
    )?;

    let rows = stmt.query_map(params![target_type, target_id, limit_date], |row| {
        Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
    })?;

    let mut res = Vec::new();
    for r in rows {
        res.push(r?);
    }
    Ok(res)
}

// Fallback to query raw visits table if daily summaries are not aggregated yet
pub fn get_clicks_trend_raw(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    limit_days: i64,
) -> rusqlite::Result<Vec<(String, i64)>> {
    let limit_date = (chrono::Utc::now() - chrono::Duration::days(limit_days)).to_rfc3339();

    let mut stmt = conn.prepare(
        "SELECT date(timestamp) as d, COUNT(*) FROM visits 
         WHERE target_type = ?1 AND target_id = ?2 AND timestamp >= ?3
         GROUP BY d ORDER BY d ASC;",
    )?;

    let rows = stmt.query_map(params![target_type, target_id, limit_date], |row| {
        Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
    })?;

    let mut res = Vec::new();
    for r in rows {
        res.push(r?);
    }
    Ok(res)
}

pub fn get_hourly_trend_raw(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    limit_days: i64,
) -> rusqlite::Result<Vec<(String, i64)>> {
    let limit_date = (chrono::Utc::now() - chrono::Duration::days(limit_days)).to_rfc3339();

    // SQLite strftime('%H', timestamp) extracts the hour
    let mut stmt = conn.prepare(
        "SELECT strftime('%H', timestamp) as h, COUNT(*) FROM visits 
         WHERE target_type = ?1 AND target_id = ?2 AND timestamp >= ?3
         GROUP BY h ORDER BY h ASC;",
    )?;

    let rows = stmt.query_map(params![target_type, target_id, limit_date], |row| {
        Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
    })?;

    let mut res = Vec::new();
    for r in rows {
        res.push(r?);
    }
    Ok(res)
}

pub fn get_metric_rankings(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    metric_type: &str,
    limit: i64,
) -> rusqlite::Result<Vec<(String, i64)>> {
    let mut stmt = conn.prepare(
        "SELECT metric_key, SUM(metric_value) as val FROM daily_summaries 
         WHERE target_type = ?1 AND target_id = ?2 AND metric_type = ?3
         GROUP BY metric_key ORDER BY val DESC LIMIT ?4;",
    )?;

    let rows = stmt.query_map(params![target_type, target_id, metric_type, limit], |row| {
        Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
    })?;

    let mut res = Vec::new();
    for r in rows {
        res.push(r?);
    }
    Ok(res)
}

pub fn get_metric_rankings_raw(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    metric_type: &str,
    limit: i64,
) -> rusqlite::Result<Vec<(String, i64)>> {
    // Falls back to direct query on visits
    let mut res = Vec::new();

    match metric_type {
        "country" => {
            let mut stmt = conn.prepare(
                "SELECT country, COUNT(*) as c FROM visits 
                 WHERE target_type = ?1 AND target_id = ?2 
                 GROUP BY country ORDER BY c DESC LIMIT ?3;",
            )?;
            let rows = stmt.query_map(params![target_type, target_id, limit], |row| {
                Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
            })?;
            for r in rows {
                res.push(r?);
            }
        }
        "referrer" => {
            let mut stmt = conn.prepare(
                "SELECT referer, COUNT(*) as c FROM visits 
                 WHERE target_type = ?1 AND target_id = ?2 
                 GROUP BY referer ORDER BY c DESC LIMIT ?3;",
            )?;
            let rows = stmt.query_map(params![target_type, target_id, limit], |row| {
                let raw_ref: String = row.get(0)?;
                Ok((clean_referrer(&raw_ref), row.get::<_, i64>(1)?))
            })?;

            // Re-aggregate because clean_referrer might group different referrers
            let mut grouped: HashMap<String, i64> = HashMap::new();
            for r in rows {
                let (k, v) = r?;
                *grouped.entry(k).or_insert(0) += v;
            }
            res = grouped.into_iter().collect();
            res.sort_by_key(|b| std::cmp::Reverse(b.1));
            res.truncate(limit as usize);
        }
        "browser" | "os" | "device" => {
            let mut stmt = conn.prepare(
                "SELECT user_agent, COUNT(*) as c FROM visits 
                 WHERE target_type = ?1 AND target_id = ?2 
                 GROUP BY user_agent;",
            )?;
            let rows = stmt.query_map(params![target_type, target_id], |row| {
                Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
            })?;

            let mut grouped: HashMap<String, i64> = HashMap::new();
            for r in rows {
                let (ua, count) = r?;
                let (b, o, d) = parse_ua(&ua);
                let key = match metric_type {
                    "browser" => b,
                    "os" => o,
                    _ => d,
                };
                *grouped.entry(key).or_insert(0) += count;
            }
            res = grouped.into_iter().collect();
            res.sort_by_key(|b| std::cmp::Reverse(b.1));
            res.truncate(limit as usize);
        }
        _ => {}
    }

    Ok(res)
}

/// Returns the raw visit counts for a specific target ID.
pub fn get_target_visit_count(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
) -> rusqlite::Result<i64> {
    conn.query_row(
        "SELECT COUNT(*) FROM visits WHERE target_type = ?1 AND target_id = ?2;",
        params![target_type, target_id],
        |row| row.get(0),
    )
}

/// Returns the distinct IP count (Unique Visitors) for a specific target ID.
pub fn get_target_unique_visitors(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
) -> rusqlite::Result<i64> {
    conn.query_row(
        "SELECT COUNT(DISTINCT ip_address) FROM visits WHERE target_type = ?1 AND target_id = ?2;",
        params![target_type, target_id],
        |row| row.get(0),
    )
}

/// Fetches the monthly clicks trend for a specific target ID, falling back to a raw visits query if monthly_summaries are empty.
pub fn get_monthly_clicks_trend(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    limit_months: i64,
) -> rusqlite::Result<Vec<(String, i64)>> {
    let mut stmt = conn.prepare(
        "SELECT year_month, SUM(metric_value) FROM monthly_summaries
         WHERE target_type = ?1 AND target_id = ?2 AND metric_type = 'clicks'
         GROUP BY year_month ORDER BY year_month ASC LIMIT ?3;",
    )?;
    let rows = stmt.query_map(params![target_type, target_id, limit_months], |row| {
        Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
    })?;
    let mut res = Vec::new();
    for r in rows {
        res.push(r?);
    }

    if res.is_empty() {
        // Fallback to raw visits
        let mut stmt = conn.prepare(
            "SELECT strftime('%Y-%m', timestamp) as m, COUNT(*) FROM visits
             WHERE target_type = ?1 AND target_id = ?2
             GROUP BY m ORDER BY m ASC LIMIT ?3;",
        )?;
        let rows = stmt.query_map(params![target_type, target_id, limit_months], |row| {
            Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
        })?;
        for r in rows {
            res.push(r?);
        }
    }

    Ok(res)
}

pub fn get_visits_schema_columns(
    conn: &Connection,
) -> rusqlite::Result<std::collections::HashSet<String>> {
    let mut columns = std::collections::HashSet::new();
    let mut stmt = conn.prepare("PRAGMA table_info(visits);")?;
    let mut rows = stmt.query([])?;
    while let Some(row) = rows.next()? {
        let name: String = row.get("name")?;
        columns.insert(name);
    }
    Ok(columns)
}

pub fn get_target_visits_paginated(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    limit: i64,
    offset: i64,
    date_from: Option<&str>,
    date_to: Option<&str>,
) -> rusqlite::Result<Vec<VisitRecord>> {
    let mut sql = "SELECT id, target_type, target_id, timestamp, ip_address, user_agent, referer, accept_language, country, status_code, owner_user_id FROM visits WHERE target_type = ?1 AND target_id = ?2".to_string();
    let mut params: Vec<Box<dyn rusqlite::ToSql>> = vec![
        Box::new(target_type.to_string()),
        Box::new(target_id.to_string()),
    ];

    if let Some(df) = date_from {
        sql.push_str(&format!(" AND timestamp >= ?{}", params.len() + 1));
        params.push(Box::new(format!("{}T00:00:00Z", df)));
    }

    if let Some(dt) = date_to {
        if let Ok(parsed_date) = chrono::NaiveDate::parse_from_str(dt, "%Y-%m-%d") {
            let next_day = parsed_date + chrono::Duration::days(1);
            sql.push_str(&format!(" AND timestamp < ?{}", params.len() + 1));
            params.push(Box::new(format!(
                "{}T00:00:00Z",
                next_day.format("%Y-%m-%d")
            )));
        }
    }

    sql.push_str(" ORDER BY timestamp DESC, id DESC LIMIT ?");
    sql.push_str(&(params.len() + 1).to_string());
    params.push(Box::new(limit));

    sql.push_str(" OFFSET ?");
    sql.push_str(&(params.len() + 1).to_string());
    params.push(Box::new(offset));

    let mut stmt = conn.prepare(&sql)?;
    let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
    let rows = stmt.query_map(rusqlite::params_from_iter(param_refs), |row| {
        Ok(VisitRecord {
            id: row.get("id")?,
            target_type: row.get("target_type")?,
            target_id: row.get("target_id")?,
            timestamp: row.get("timestamp")?,
            ip_address: row.get("ip_address")?,
            user_agent: row.get("user_agent")?,
            referer: row.get("referer")?,
            accept_language: row.get("accept_language")?,
            country: row.get("country")?,
            status_code: row.get("status_code")?,
            owner_user_id: row.get("owner_user_id")?,
        })
    })?;

    let mut visits = Vec::new();
    for r in rows {
        visits.push(r?);
    }
    Ok(visits)
}

pub fn get_target_visits_all_in_memory(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    date_from: Option<&str>,
    date_to: Option<&str>,
) -> rusqlite::Result<Vec<VisitRecord>> {
    let mut sql = "SELECT id, target_type, target_id, timestamp, ip_address, user_agent, referer, accept_language, country, status_code, owner_user_id FROM visits WHERE target_type = ?1 AND target_id = ?2".to_string();
    let mut params: Vec<Box<dyn rusqlite::ToSql>> = vec![
        Box::new(target_type.to_string()),
        Box::new(target_id.to_string()),
    ];

    if let Some(df) = date_from {
        sql.push_str(&format!(" AND timestamp >= ?{}", params.len() + 1));
        params.push(Box::new(format!("{}T00:00:00Z", df)));
    }

    if let Some(dt) = date_to {
        if let Ok(parsed_date) = chrono::NaiveDate::parse_from_str(dt, "%Y-%m-%d") {
            let next_day = parsed_date + chrono::Duration::days(1);
            sql.push_str(&format!(" AND timestamp < ?{}", params.len() + 1));
            params.push(Box::new(format!(
                "{}T00:00:00Z",
                next_day.format("%Y-%m-%d")
            )));
        }
    }

    sql.push_str(" ORDER BY timestamp DESC, id DESC");

    let mut stmt = conn.prepare(&sql)?;
    let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
    let rows = stmt.query_map(rusqlite::params_from_iter(param_refs), |row| {
        Ok(VisitRecord {
            id: row.get("id")?,
            target_type: row.get("target_type")?,
            target_id: row.get("target_id")?,
            timestamp: row.get("timestamp")?,
            ip_address: row.get("ip_address")?,
            user_agent: row.get("user_agent")?,
            referer: row.get("referer")?,
            accept_language: row.get("accept_language")?,
            country: row.get("country")?,
            status_code: row.get("status_code")?,
            owner_user_id: row.get("owner_user_id")?,
        })
    })?;

    let mut visits = Vec::new();
    for r in rows {
        visits.push(r?);
    }
    Ok(visits)
}

pub fn get_target_visit_total_filtered(
    conn: &Connection,
    target_type: &str,
    target_id: &str,
    date_from: Option<&str>,
    date_to: Option<&str>,
) -> rusqlite::Result<i64> {
    if date_from.is_none() && date_to.is_none() {
        return get_target_visit_count(conn, target_type, target_id);
    }

    let mut sql =
        "SELECT COUNT(*) FROM visits WHERE target_type = ?1 AND target_id = ?2".to_string();
    let mut params: Vec<Box<dyn rusqlite::ToSql>> = vec![
        Box::new(target_type.to_string()),
        Box::new(target_id.to_string()),
    ];

    if let Some(df) = date_from {
        sql.push_str(&format!(" AND timestamp >= ?{}", params.len() + 1));
        params.push(Box::new(format!("{}T00:00:00Z", df)));
    }

    if let Some(dt) = date_to {
        if let Ok(parsed_date) = chrono::NaiveDate::parse_from_str(dt, "%Y-%m-%d") {
            let next_day = parsed_date + chrono::Duration::days(1);
            sql.push_str(&format!(" AND timestamp < ?{}", params.len() + 1));
            params.push(Box::new(format!(
                "{}T00:00:00Z",
                next_day.format("%Y-%m-%d")
            )));
        }
    }

    let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
    conn.query_row(&sql, rusqlite::params_from_iter(param_refs), |row| {
        row.get(0)
    })
}

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

    #[test]
    fn test_parse_ua_browsers() {
        let firefox_linux =
            "Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0";
        let chrome_win = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
        let safari_mac = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15";
        let android_phone = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36";

        assert_eq!(
            parse_ua(firefox_linux),
            (
                "Firefox".to_string(),
                "Linux".to_string(),
                "Desktop".to_string()
            )
        );
        assert_eq!(
            parse_ua(chrome_win),
            (
                "Chrome".to_string(),
                "Windows".to_string(),
                "Desktop".to_string()
            )
        );
        assert_eq!(
            parse_ua(safari_mac),
            (
                "Safari".to_string(),
                "macOS".to_string(),
                "Desktop".to_string()
            )
        );
        assert_eq!(
            parse_ua(android_phone),
            (
                "Chrome".to_string(),
                "Android".to_string(),
                "Mobile".to_string()
            )
        );
    }

    #[test]
    fn test_clean_referrer() {
        assert_eq!(clean_referrer("direct"), "Direct");
        assert_eq!(clean_referrer(""), "Direct");
        assert_eq!(
            clean_referrer("https://github.com/rust-lang/rust"),
            "github.com"
        );
        assert_eq!(
            clean_referrer("http://www.google.com/search?q=rust"),
            "google.com"
        );
        assert_eq!(clean_referrer("reddit.com/r/rust"), "reddit.com");
    }
}