kapiti 0.0.3

use anyhow::{bail, Context, Result};
use std::collections::HashMap;
use std::fs::File;
use std::io::{BufRead, BufReader, Read};
use std::net::{Ipv4Addr, Ipv6Addr};
use std::path::Path;
use std::str::{FromStr, SplitAsciiWhitespace};

use tracing::{trace, warn};

use crate::filter::path;

pub struct FilterFile {
    // Info about the source file/URL, if any
    pub info: Option<FileInfo>,
    // The filter content/logic itself
    pub content: FilterContent,
}

#[derive(Clone, Debug)]
pub struct FileInfo {
    /// The path or URL for this filter as provided in the config
    pub source_path: String,
    /// For remote files, this is where the cached copy is found locally.
    /// For local files, this is the same as source_path.
    pub local_path: String,
}

/// Block filters:
///   If this entry is found for a host, then return NXDOMAIN for all record types
/// Override filters:
///   If this is entry is found for a host, then return the specified values for A records and/or AAAA records.
///   For all other record types return no record.
#[derive(Clone, Debug, PartialEq)]
pub struct FilterEntry {
    /// The line number from the original filter file where this entry was found
    pub line_num: Option<usize>,

    /// An override value for returning the upstream result (for 'allow' entries)
    pub dest_upstream: bool,
    /// An override value for A records
    pub dest_ipv4: Option<Ipv4Addr>,
    /// An override value for AAAA records
    pub dest_ipv6: Option<Ipv6Addr>,
}

pub struct FilterContent {
    /// Mapping of hostnames to filters.
    /// Depending on the context, the filters can either be blocks or overrides.
    entries: HashMap<String, FilterEntry>,
}

impl FilterContent {
    fn new() -> FilterContent {
        FilterContent {
            entries: HashMap::new(),
        }
    }

    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    pub fn get(&self, host: &str) -> Option<&FilterEntry> {
        self.entries.get(host)
    }

    fn add_allow_line(
        &mut self,
        source_info: &FileInfo,
        line_num: usize,
        host: &str,
    ) -> Result<()> {
        let host = validate_host(host)?;
        self.entries.insert(
            host,
            FilterEntry {
                line_num: Some(line_num),
                dest_upstream: true,
                dest_ipv4: None,
                dest_ipv6: None,
            },
        );
        Ok(())
    }

    fn add_block_line(
        &mut self,
        source_info: &FileInfo,
        line_num: usize,
        host: &str,
    ) -> Result<()> {
        let host = validate_host(host)?;
        self.entries.insert(
            host,
            FilterEntry {
                line_num: Some(line_num),
                dest_upstream: false,
                dest_ipv4: None,
                dest_ipv6: None,
            },
        );
        Ok(())
    }

    fn add_block_hardcoded(&mut self, host: &str) {
        // Skip validation, assume it's fine...
        self.entries.insert(
            host.to_string(),
            FilterEntry {
                line_num: None,
                dest_upstream: false,
                dest_ipv4: None,
                dest_ipv6: None,
            },
        );
    }

    fn add_override_ipv4_line(
        &mut self,
        source_info: &FileInfo,
        line_num: usize,
        host: &str,
        dest: Ipv4Addr,
    ) -> Result<()> {
        let host = validate_host(host)?;
        // If the entry is already present, keep it and just update the ipv4 value.
        // This is mainly for the case of both ipv4+ipv6 entries in the same file.
        let initial_val = FilterEntry {
            line_num: Some(line_num),
            dest_upstream: false,
            dest_ipv4: Some(dest),
            dest_ipv6: None,
        };
        let map_val = self.entries.entry(host).or_insert(initial_val);
        // Update line_num: just go with whatever line is last, since that's what we're using for the dest.
        // This may be inaccurate if the file has both IPv4 and IPv6 entries for a given hostname on different
        // lines in the same file, for example with "localhost" in /etc/hosts. But this is a big corner case
        // and isn't worth the complexity to deal with multiple per-protocol line numbers.
        map_val.line_num = Some(line_num);
        map_val.dest_ipv4 = Some(dest);
        Ok(())
    }

    fn add_override_ipv6_line(
        &mut self,
        source_info: &FileInfo,
        line_num: usize,
        host: &str,
        dest: Ipv6Addr,
    ) -> Result<()> {
        let host = validate_host(host)?;
        // If the entry is already present, keep it and just update the ipv6 value.
        // This is mainly for the case of both ipv4+ipv6 entries in the same file.
        let initial_val = FilterEntry {
            line_num: Some(line_num),
            dest_upstream: false,
            dest_ipv4: None,
            dest_ipv6: Some(dest),
        };
        let map_val = self.entries.entry(host).or_insert(initial_val);
        // Update line_num: just go with whatever line is last, since that's what we're using for the dest.
        // This may be inaccurate if the file has both IPv4 and IPv6 entries for a given hostname on different
        // lines in the same file, for example with "localhost" in /etc/hosts. But this is a big corner case
        // and isn't worth the complexity to deal with multiple per-protocol line numbers.
        map_val.line_num = Some(line_num);
        map_val.dest_ipv6 = Some(dest);
        Ok(())
    }
}

/// Creates a list of entries from the provided hardcoded hostnames to block
pub fn block_hardcoded(block_names: &[&str]) -> Result<FilterFile> {
    let mut content = FilterContent::new();
    for name in block_names {
        content.add_block_hardcoded(name);
    }
    Ok(FilterFile {
        info: None,
        content,
    })
}

/// Reads an override file from disk, returning a parsed list of entries
pub fn read_override(info: &FileInfo) -> Result<FilterFile> {
    let path_str = info.local_path.clone();
    let path = Path::new(&path_str);
    let file = File::open(path).with_context(|| format!("Failed to open file {:?}", info))?;
    if path::is_zstd_extension(path) {
        read_override_imp(info, zstd::stream::Decoder::new(file)?)
    } else {
        read_override_imp(info, file)
    }
}

fn read_override_imp<T: Read>(info: &FileInfo, file: T) -> Result<FilterFile> {
    let mut reader = BufReader::new(file);
    let mut buf = String::new();
    let mut line_num = 0;
    let mut content = FilterContent::new();
    loop {
        line_num += 1;
        let len = reader
            .read_line(&mut buf)
            .with_context(|| format!("Failed to read file {:?}", info))?;
        if len == 0 {
            // EOF
            return Ok(FilterFile {
                info: Some(info.clone()),
                content,
            });
        } else {
            match handle_override_line(&buf, line_num, &mut content, &info) {
                Ok(()) => {}
                Err(e) => warn!("Failed to parse {:?} line {}: {}", info, line_num, e),
            };
            buf.clear();
        }
    }
}

fn handle_override_line(
    line: &str,
    line_num: usize,
    out: &mut FilterContent,
    info: &FileInfo,
) -> Result<()> {
    let mut words = tokenize(line);

    // Support these formats:
    // - /etc/hosts-style rule: '<ip> <host1> [host2 ... hostN]'
    // - Adblock domain rule:   '||<host>^' (see https://adblockplus.org/filter-cheatsheet)
    // - Hostname block:        '<host>'
    if let Some(first) = words.next() {
        if let Some(second) = words.next() {
            // Second word present: a hostname for hosts-style (and more hostnames may follow)
            if let Some(_) = first.find(':') {
                // Looks like the IP is IPv6
                let ipv6_dest = Ipv6Addr::from_str(first)
                    .with_context(|| format!("Failed to parse IPv6 address: {}", first))?;
                out.add_override_ipv6_line(&info, line_num, second, ipv6_dest)?;
                for word in words {
                    out.add_override_ipv6_line(&info, line_num, word, ipv6_dest)?;
                }
                Ok(())
            } else {
                // Assume the IP is IPv4
                let ipv4_dest = Ipv4Addr::from_str(first)
                    .with_context(|| format!("Failed to parse IPv4 address: {}", first))?;
                out.add_override_ipv4_line(&info, line_num, second, ipv4_dest)?;
                for word in words {
                    out.add_override_ipv4_line(&info, line_num, word, ipv4_dest)?;
                }
                Ok(())
            }
        } else {
            // This is an override file but there's nowhere for the override IP to go
            bail!("Unexpected block-style entry in override rule: {}", first);
        }
    } else {
        // Blank line (possibly after stripping any comments)
        Ok(())
    }
}

/// Reads a block file from disk, returning a parsed list of entries
pub fn read_block(info: &FileInfo) -> Result<FilterFile> {
    let path_str = info.local_path.clone();
    let path = Path::new(&path_str);
    let file = File::open(path).with_context(|| format!("Failed to open file {:?}", info))?;
    if path::is_zstd_extension(path) {
        read_block_imp(info, zstd::stream::Decoder::new(file)?)
    } else {
        read_block_imp(info, file)
    }
}

fn read_block_imp<T: Read>(info: &FileInfo, file: T) -> Result<FilterFile> {
    let mut reader = BufReader::new(file);
    let mut buf = String::new();
    let mut line_num = 0;
    let mut content = FilterContent::new();
    loop {
        line_num += 1;
        let len = reader
            .read_line(&mut buf)
            .with_context(|| format!("Failed to read file {:?}", info))?;
        if len == 0 {
            // EOF
            return Ok(FilterFile {
                info: Some(info.clone()),
                content,
            });
        } else {
            match handle_block_line(&buf, line_num, &mut content, &info) {
                Ok(()) => {}
                Err(e) => warn!("Failed to parse {:?} line {}: {}", info, line_num, e),
            };
            buf.clear();
        }
    }
}

fn handle_block_line(
    line: &str,
    line_num: usize,
    out: &mut FilterContent,
    info: &FileInfo,
) -> Result<()> {
    let mut words = tokenize(line);

    // Support these formats:
    // - /etc/hosts-style rule: '<ip> <host1> [host2 ... hostN]'
    // - Adblock domain rule:   '||<host>^' and similar (see https://adblockplus.org/filter-cheatsheet)
    // - Hostname block:        '<host>'
    if let Some(first) = words.next() {
        if let Some(second) = words.next() {
            // Second word present: a hostname for hosts-style (and more hostnames may follow)
            // Skip parsing the destination IP and just block the host(s).
            //trace!("{} block1:  {}", line_num, first);
            out.add_block_line(&info, line_num, second)?;
            for word in words {
                //trace!("{} blockN:  {}", line_num, first);
                out.add_block_line(&info, line_num, word)?;
            }
            Ok(())
        } else {
            // No second word, assume it's an adblock or blocklist style for a hostname, no destination
            // TODO: add explicit test cases for the below listed cases
            if first.starts_with("@@") {
                // Looks like an adblock 'allow' rule (frequently malformed):
                // - '@@||<host>^|'
                // - '@@||<host>^'
                // - '@@|<host>^|'
                // - '@@|<host>^'
                // - '@@-<host>^'
                // (Check this first since the following case is 'looser')
                let first_trim = first
                    .trim_start_matches(|c| char::is_ascii_punctuation(&c))
                    .trim_end_matches(|c| char::is_ascii_punctuation(&c));
                //trace!("{} allow:   {} -> {}", line_num, first, first_trim);
                out.add_allow_line(&info, line_num, first_trim)?;
            } else if first.starts_with("||") || first.starts_with("://") || first.ends_with("^") {
                // Looks like an adblock 'block' rule (frequently malformed):
                // - '||<host>^'
                // - '||<host>.'
                // - '||<host>'
                // - '://<host>^'
                // - '://<host>'
                // - '://*.<host>' (wildcard automatically trimmed, does what we want)
                // - '.<host>^'
                // - '||<host>^$important'
                // - '||<host>$important'
                let mut first_trim = first;
                if first_trim.ends_with("$important") {
                    // remove any '$important' from end before trimming any punctuation
                    first_trim = &first_trim[0..first.len() - 10];
                }
                first_trim = first_trim
                    .trim_start_matches(|c| char::is_ascii_punctuation(&c))
                    .trim_end_matches(|c| char::is_ascii_punctuation(&c));
                //trace!("{} adblock: {} -> {}", line_num, first, first_trim);
                out.add_block_line(&info, line_num, &first_trim)?;
            } else {
                // Give up and assume that it's just a standalone hostname: '<host>'
                trace!("{} UNKNOWN: {}", line_num, first);
                out.add_block_line(&info, line_num, first)?;
            }
            Ok(())
        }
    } else {
        // Blank line (possibly after stripping any comments)
        Ok(())
    }
}

fn tokenize(line: &str) -> SplitAsciiWhitespace {
    // Cut out any comment from the line before tokenizing words
    match (line.find('!'), line.find('#')) {
        (Some(comment_start_excl), Some(comment_start_hash)) => {
            // Whichever one comes first is the start of the comment
            if comment_start_excl < comment_start_hash {
                line[..comment_start_excl].split_ascii_whitespace()
            } else {
                line[..comment_start_hash].split_ascii_whitespace()
            }
        }
        (None, Some(comment_start)) => line[..comment_start].split_ascii_whitespace(),
        (Some(comment_start), None) => line[..comment_start].split_ascii_whitespace(),
        (None, None) => line.split_ascii_whitespace(),
    }
}

/// From "man 5 hosts":
/// Host names may contain only alphanumeric characters, minus signs ("-"), and periods (".").
/// They must begin with an alphabetic character and end with an alphanumeric character.
/// HOWEVER, in reality both of these seem to be valid:
/// - hostnames that start with a number (in the subdomain)
/// - hostnames that contain '_'
fn validate_host(host: &str) -> Result<String> {
    if host.len() < 2 {
        bail!("Invalid host of length {}: {}", host.len(), host);
    }
    if host.len() > 253 {
        // Don't log the host, in case it's REALLY long
        bail!("Invalid host of length {}", host.len());
    }

    for (idx, c) in host.char_indices() {
        if idx == host.len() - 1 {
            // Last char
            if !c.is_ascii_alphanumeric() {
                bail!("Invalid host, last char must be alphanumeric: {}", host);
            }
        } else {
            // First and middle char(s)
            if !c.is_ascii_alphanumeric() && c != '-' && c != '_' && c != '.' {
                bail!(
                    "Invalid host, middle chars must be alphanumeric, '-', or '.': {}",
                    host
                );
            }
        }
    }
    Ok(host.to_string())
}

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

    /*
    #[test]
    fn actual_file() {
        // Put sample file named 'filter.txt' in repo root:
        let path = "filter.txt";
        let file_info = FileInfo {
            source_path: path.to_string(),
            local_path: path.to_string(),
        };
        let filter_file = read_block(file_info).unwrap();
        assert_eq!(5, filter_file.content.entries.len());
    }
    */

    #[test]
    fn comments_hash() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        assert_eq!(
            true,
            handle_block_line("# ignored comment", 4, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("foo.com # ignored comment", 5, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("foo.biz# ignored comment", 6, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line(
                "1.2.3.4 foo.nz foo.co.nz   # ignored comment",
                7,
                &mut content,
                &file_info
            )
            .is_ok()
        );
        assert_eq!(
            true,
            handle_block_line(
                "||foo.geek.nz^   # ignored comment",
                8,
                &mut content,
                &file_info
            )
            .is_ok()
        );

        let entry = content.get("foo.com").unwrap();
        assert_eq!(Some(5), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.biz").unwrap();
        assert_eq!(Some(6), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.nz").unwrap();
        assert_eq!(Some(7), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.co.nz").unwrap();
        assert_eq!(Some(7), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.geek.nz").unwrap();
        assert_eq!(Some(8), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        assert_eq!(None, content.get("www.foo.com"));
        assert_eq!(None, content.get("foo2.com"));
    }

    #[test]
    fn comments_excl() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        assert_eq!(
            true,
            handle_block_line("! ignored comment", 4, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("foo.com ! ignored comment", 5, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("foo.biz! ignored comment", 6, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line(
                "1.2.3.4 foo.nz foo.co.nz   ! ignored comment",
                7,
                &mut content,
                &file_info
            )
            .is_ok()
        );
        assert_eq!(
            true,
            handle_block_line(
                "||foo.geek.nz^   ! ignored comment",
                8,
                &mut content,
                &file_info
            )
            .is_ok()
        );

        assert_eq!(5, content.entries.len());

        let entry = content.get("foo.com").unwrap();
        assert_eq!(Some(5), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.biz").unwrap();
        assert_eq!(Some(6), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.nz").unwrap();
        assert_eq!(Some(7), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.co.nz").unwrap();
        assert_eq!(Some(7), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.geek.nz").unwrap();
        assert_eq!(Some(8), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        assert_eq!(None, content.get("www.foo.com"));
        assert_eq!(None, content.get("foo2.com"));
    }

    #[test]
    fn bad_hosts() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        assert_eq!(
            false,
            handle_block_line("a", 4, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("ab", 4, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            false,
            handle_block_line("ab?", 4, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            false,
            handle_block_line("?ab", 4, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("ab0", 4, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("0ab", 4, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            false,
            handle_block_line("ab_", 4, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("_ab", 4, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            false,
            handle_block_line("ab.", 4, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line(".ab", 4, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("a.b", 4, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("a.b", 4, &mut content, &file_info).is_ok()
        );

        assert_eq!(true, handle_block_line("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 4, &mut content, &file_info).is_ok());
        assert_eq!(false, handle_block_line("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 4, &mut content, &file_info).is_ok());
    }

    #[test]
    fn block_hostname() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        assert_eq!(
            true,
            handle_block_line("foo.com", 5, &mut content, &file_info).is_ok()
        );

        assert_eq!(1, content.entries.len());

        let entry = content.get("foo.com").unwrap();
        assert_eq!(Some(5), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        assert_eq!(None, content.get("www.foo.com"));
        assert_eq!(None, content.get("foo2.com"));
    }

    #[test]
    fn override_hostname() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        // override filters need IPs
        assert_eq!(
            false,
            handle_override_line("foo.com", 5, &mut content, &file_info).is_ok()
        );
    }

    #[test]
    fn block_adblock() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        assert_eq!(
            true,
            handle_block_line("||foo.com^", 5, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("||bar.com.", 6, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("||baz.com", 7, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("://foo.net^", 8, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("://bar.net", 9, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("://*.baz.net^", 10, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line(".foo.org^", 11, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("||bar.org^$important", 12, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("||baz.org$important", 13, &mut content, &file_info).is_ok()
        );

        assert_eq!(9, content.entries.len());

        let entry = content.get("foo.com").unwrap();
        assert_eq!(Some(5), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("bar.com").unwrap();
        assert_eq!(Some(6), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("baz.com").unwrap();
        assert_eq!(Some(7), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.net").unwrap();
        assert_eq!(Some(8), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("bar.net").unwrap();
        assert_eq!(Some(9), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("baz.net").unwrap();
        assert_eq!(Some(10), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.org").unwrap();
        assert_eq!(Some(11), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("bar.org").unwrap();
        assert_eq!(Some(12), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("baz.org").unwrap();
        assert_eq!(Some(13), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        assert_eq!(None, content.get("www.foo.com"));
        assert_eq!(None, content.get("foo2.com"));
    }

    #[test]
    fn block_adblock_allow() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        assert_eq!(
            true,
            handle_block_line("@@||foo.com^|", 5, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("@@||bar.com^", 6, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("@@|baz.com^", 7, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("@@|foo.net^", 8, &mut content, &file_info).is_ok()
        );

        assert_eq!(
            true,
            handle_block_line("@@-bar.net^", 9, &mut content, &file_info).is_ok()
        );

        assert_eq!(5, content.entries.len());

        let entry = content.get("foo.com").unwrap();
        assert_eq!(Some(5), entry.line_num);
        assert_eq!(true, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("bar.com").unwrap();
        assert_eq!(Some(6), entry.line_num);
        assert_eq!(true, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("baz.com").unwrap();
        assert_eq!(Some(7), entry.line_num);
        assert_eq!(true, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.net").unwrap();
        assert_eq!(Some(8), entry.line_num);
        assert_eq!(true, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("bar.net").unwrap();
        assert_eq!(Some(9), entry.line_num);
        assert_eq!(true, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        assert_eq!(None, content.get("www.foo.com"));
        assert_eq!(None, content.get("foo2.com"));
    }

    #[test]
    fn override_adblock() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        // override filters need IPs
        assert_eq!(
            false,
            handle_override_line("||foo.com^", 5, &mut content, &file_info).is_ok()
        );
    }

    #[test]
    fn block_etchosts() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        assert_eq!(
            true,
            handle_block_line("1.2.3.4 foo.com", 5, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("::2 foo.com", 6, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("::3 foo.biz", 7, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line("1.2.3.5 foo.biz", 8, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_block_line(
                "::4 foo.nz foo.co.nz foo.geek.nz",
                9,
                &mut content,
                &file_info
            )
            .is_ok()
        );

        assert_eq!(5, content.entries.len());

        let entry = content.get("foo.com").unwrap();
        // Just go with the last line num
        assert_eq!(Some(6), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.biz").unwrap();
        // Just go with the last line num
        assert_eq!(Some(8), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.nz").unwrap();
        assert_eq!(Some(9), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.co.nz").unwrap();
        assert_eq!(Some(9), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        let entry = content.get("foo.geek.nz").unwrap();
        assert_eq!(Some(9), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(None, entry.dest_ipv6);

        assert_eq!(None, content.get("www.foo.com"));
        assert_eq!(None, content.get("foo2.com"));
    }

    #[test]
    fn override_etchosts() {
        let mut content = FilterContent::new();
        let file_info = FileInfo {
            source_path: "testsrc".to_string(),
            local_path: "testlocal".to_string(),
        };

        assert_eq!(
            true,
            handle_override_line("1.2.3.4 foo.com", 5, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_override_line("::2 foo.com", 6, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_override_line("::3 foo.biz", 7, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_override_line("1.2.3.5 foo.biz", 8, &mut content, &file_info).is_ok()
        );
        assert_eq!(
            true,
            handle_override_line(
                "::4 foo.nz foo.co.nz foo.geek.nz",
                9,
                &mut content,
                &file_info
            )
            .is_ok()
        );

        assert_eq!(5, content.entries.len());

        let entry = content.get("foo.com").unwrap();
        assert_eq!(Some(6), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(
            Some(Ipv4Addr::from_str("1.2.3.4").unwrap()),
            entry.dest_ipv4
        );
        assert_eq!(Some(Ipv6Addr::from_str("::2").unwrap()), entry.dest_ipv6);

        let entry = content.get("foo.biz").unwrap();
        assert_eq!(Some(8), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(
            Some(Ipv4Addr::from_str("1.2.3.5").unwrap()),
            entry.dest_ipv4
        );
        assert_eq!(Some(Ipv6Addr::from_str("::3").unwrap()), entry.dest_ipv6);

        let entry = content.get("foo.nz").unwrap();
        assert_eq!(Some(9), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(Some(Ipv6Addr::from_str("::4").unwrap()), entry.dest_ipv6);

        let entry = content.get("foo.co.nz").unwrap();
        assert_eq!(Some(9), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(Some(Ipv6Addr::from_str("::4").unwrap()), entry.dest_ipv6);

        let entry = content.get("foo.geek.nz").unwrap();
        assert_eq!(Some(9), entry.line_num);
        assert_eq!(false, entry.dest_upstream);
        assert_eq!(None, entry.dest_ipv4);
        assert_eq!(Some(Ipv6Addr::from_str("::4").unwrap()), entry.dest_ipv6);

        assert_eq!(None, content.get("www.foo.com"));
        assert_eq!(None, content.get("foo2.com"));
    }
}