/*
 * melib - sieve module
 *
 * Copyright 2022 Manos Pitsidianakis
 *
 * This file is part of meli.
 *
 * meli is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * meli is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with meli. If not, see <http://www.gnu.org/licenses/>.
 */

use crate::utils::parsec::*;

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RuleBlock(pub Vec<Rule>);

/*
   MATCH-TYPE =/ COUNT / VALUE

  COUNT = ":count" relational-match

  VALUE = ":value" relational-match

  relational-match = DQUOTE
          ("gt" / "ge" / "lt" / "le" / "eq" / "ne") DQUOTE
          ; "gt" means "greater than", the C operator ">".
          ; "ge" means "greater than or equal", the C operator ">=".
          ; "lt" means "less than", the C operator "<".
          ; "le" means "less than or equal", the C operator "<=".
          ; "eq" means "equal to", the C operator "==".
          ; "ne" means "not equal to", the C operator "!=".
*/
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ActionCommand {
    Keep,
    Fileinto { mailbox: String },
    Redirect { address: String },
    Discard,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ControlCommand {
    Stop,
    Require(Vec<String>),
    If {
        condition: (ConditionRule, RuleBlock),
        elsif: Option<(ConditionRule, RuleBlock)>,
        else_: Option<RuleBlock>,
    },
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Rule {
    Block(RuleBlock),
    Action(ActionCommand),
    Control(ControlCommand),
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AddressOperator {
    All,
    Localpart,
    Domain,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum IntegerOperator {
    Over,
    Under,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
/// RFC 5231 Sieve Email Filtering: Relational Extension
pub enum RelationalMatch {
    /// "gt" means "greater than", the C operator ">".
    Gt,
    /// "ge" means "greater than or equal", the C operator ">=".
    Ge,
    /// "lt" means "less than", the C operator "<".
    Lt,
    /// "le" means "less than or equal", the C operator "<=".
    Le,
    /// "eq" means "equal to", the C operator "==".
    Eq,
    /// "ne" means "not equal to", the C operator "!=".
    Ne,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum MatchOperator {
    Is,
    Matches,
    Contains,
    Count(RelationalMatch),
    Value(RelationalMatch),
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CharacterOperator {
    /// i;octet,
    Octet,
    ///i;ascii-casemap
    AsciiCasemap,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ZoneRule {
    /// "year"      => the year, "0000" .. "9999".
    Year,
    /// "month"     => the month, "01" .. "12".
    Month,
    /// "day"       => the day, "01" .. "31".
    Day,
    /// "date"      => the date in "yyyy-mm-dd" format.
    Date,
    /// "julian"    => the Modified Julian Day, that is, the date
    /// expressed as an integer number of days since
    /// 00:00 UTC on November 17, 1858 (using the Gregorian
    /// calendar).  This corresponds to the regular
    /// Julian Day minus 2400000.5.  Sample routines to
    /// convert to and from modified Julian dates are
    /// given in Appendix A.
    Julian,
    /// "hour"      => the hour, "00" .. "23".
    Hour,
    /// "minute"    => the minute, "00" .. "59".
    Minute,
    /// "second"    => the second, "00" .. "60".
    Second,
    /// "time"      => the time in "hh:mm:ss" format.
    Time,
    /// "iso8601"   => the date and time in restricted ISO 8601 format.
    Iso8601,
    /// "std11"     => the date and time in a format appropriate
    /// for use in a Date: header field (`RFC2822`).
    Std11,
    /// "zone"      => the time zone in use.  If the user specified a
    ///time zone with ":zone", "zone" will
    ///contain that value.  If :originalzone is specified
    ///this value will be the original zone specified
    ///in the date-time value.  If neither argument is
    ///specified the value will be the server's default
    ///time zone in offset format "+hhmm" or "-hhmm".  An
    ///offset of 0 (Zulu) always has a positive sign.
    Zone,
    /// "weekday"   => the day of the week expressed as an integer between "0"
    /// and "6". "0" is Sunday, "1" is Monday, etc.
    Weekday,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ConditionRule {
    /// Logical OR operation.
    AnyOf(Vec<ConditionRule>),
    /// Logical AND operation.
    AllOf(Vec<ConditionRule>),
    /// Header values exist.
    Exists(Vec<String>),
    Header {
        comparator: Option<CharacterOperator>,
        match_operator: Option<MatchOperator>,
        header_names: Vec<String>,
        key_list: Vec<String>,
    },
    Date {
        comparator: Option<CharacterOperator>,
        match_type: Option<MatchOperator>,
        zone: ZoneRule,
        header_name: String,
        date_part: String,
        key_list: Vec<String>,
    },
    Address {
        comparator: Option<CharacterOperator>,
        address_part: Option<AddressOperator>,
        match_type: Option<MatchOperator>,
        header_list: Vec<String>,
        key_list: Vec<String>,
    },
    Not(Box<ConditionRule>),
    Size {
        operator: IntegerOperator,
        limit: u64,
    },
    Literal(bool),
}

pub mod parser {
    use super::*;
    macro_rules! parse_action {
        ($parser_name:ident, $lit:literal, $t:ty, $action:expr) => {
            pub fn $parser_name<'a>() -> impl Parser<'a, $t> {
                move |input| {
                    map(
                        ws(right(match_literal_anycase($lit), ws(match_literal(";")))),
                        |_| $action,
                    )
                    .parse(input)
                }
            }
        };
        ($parser_name:ident, $lit:literal, $t:ty, $action:expr, $argument:ident) => {
            pub fn $parser_name<'a>() -> impl Parser<'a, $t> {
                move |input| {
                    map(
                        ws(right(
                            parse_token($lit),
                            left(ws(string()), ws(parse_token(";"))),
                        )),
                        |$argument| $action,
                    )
                    .parse(input)
                }
            }
        };
    }

    parse_action! { parse_sieve_keep, "keep", ActionCommand, ActionCommand::Keep }
    parse_action! { parse_sieve_discard, "discard", ActionCommand, ActionCommand::Discard }
    parse_action! { parse_sieve_stop, "stop", ControlCommand, ControlCommand::Stop }
    parse_action! { parse_sieve_fileinto, "fileinto", ActionCommand, ActionCommand::Fileinto { mailbox }, mailbox }
    parse_action! { parse_sieve_redirect, "redirect", ActionCommand, ActionCommand::Redirect { address }, address }

    #[inline(always)]
    pub fn parse_token<'a>(literal: &'static str) -> impl Parser<'a, ()> {
        move |input| map(ws(match_literal_anycase(literal)), |_| ()).parse(input)
    }

    #[inline(always)]
    fn ws_inner<'a>() -> impl Parser<'a, ()> {
        move |input: &'a str| {
            let mut offset = 0;
            let input_b = input.as_bytes();
            while offset < input_b.len() {
                while offset < input_b.len()
                    && [b' ', b'\t', b'\n', b'\r'].contains(&input_b[offset])
                {
                    offset += 1;
                }
                if offset >= input_b.len() {
                    break;
                }
                if input_b[offset] == b'#' {
                    while offset < input_b.len()
                        && !input[offset..].starts_with("\r\n")
                        && !input[offset..].starts_with('\n')
                    {
                        offset += 1;
                    }
                    if offset >= input_b.len() {
                        break;
                    }
                    if input[offset..].starts_with("\r\n") {
                        offset += 2;
                    } else if input[offset..].starts_with('\n') {
                        offset += 1;
                    }
                } else if input[offset..].starts_with("/*") {
                    while offset < input_b.len() && !input[offset..].starts_with("*/") {
                        offset += 1;
                    }
                    if offset >= input_b.len() {
                        break;
                    }
                    if input[offset..].starts_with("*/") {
                        offset += 2;
                    }
                } else {
                    break;
                }
            }
            Ok((&input[offset..], ()))
        }
    }

    pub fn ws<'a, P, A>(parser: P) -> impl Parser<'a, A>
    where
        P: Parser<'a, A>,
    {
        move |input1| {
            let (input2, ()) = ws_inner().parse(input1)?;
            let (input3, res) = parser.parse(input2)?;
            let (input4, ()) = ws_inner().parse(input3)?;
            Ok((input4, res))
        }
    }

    // string       = quoted-string / multi-line
    //
    // quoted-other       = "\" octet-not-qspecial
    //                        ; represents just the octet-no-qspecial
    //                        ; character.  SHOULD NOT be used

    // quoted-safe        = CRLF / octet-not-qspecial
    //                        ; either a CRLF pair, OR a single octet other
    //                        ; than NUL, CR, LF, double-quote, or backslash

    // quoted-special     = "\" (DQUOTE / "\")
    //                        ; represents just a double-quote or backslash

    // quoted-string      = DQUOTE quoted-text DQUOTE

    // quoted-text        = *(quoted-safe / quoted-special / quoted-other)

    pub fn string<'a>() -> impl Parser<'a, String> {
        #[inline(always)]
        fn quoted_text<'a>() -> impl Parser<'a, String> {
            move |input: &'a str| {
                let mut offset = 0;
                let mut unescape_dquote: bool = false;
                let mut unescape_slash: bool = false;
                while offset < input.len() {
                    if input.len() >= offset + 2 {
                        if input.starts_with("\r\n") {
                            offset += 2;
                        } else if input.starts_with("\\\"") {
                            unescape_dquote = true;
                            offset += 2;
                        } else if input.starts_with("\\\\") {
                            unescape_slash = true;
                            offset += 2;
                        }
                    }
                    // a single octet other ; than NUL, CR, LF, double-quote, or backslash
                    if [b'\x00', b'\r', b'\n', b'"', b'\\'].contains(&input.as_bytes()[offset]) {
                        break;
                    }
                    offset += 1;
                }
                match (unescape_dquote, unescape_slash) {
                    (false, false) => Ok((&input[offset..], input[..offset].to_string())),
                    (true, false) => Ok((&input[offset..], input[..offset].replace("\\\"", "\""))),
                    (false, true) => Ok((&input[offset..], input[..offset].replace("\\\\", "\\"))),
                    (true, true) => Ok((
                        &input[offset..],
                        input[..offset].replace("\\\"", "\"").replace("\\\\", "\\"),
                    )),
                }
            }
        }

        #[inline(always)]
        fn quoted_string<'a>() -> impl Parser<'a, String> {
            delimited(parse_token("\""), quoted_text(), parse_token("\""))
        }

        //fn multiline() -> impl Parser<'a, String> {}
        //either(quoted_string(), multiline())
        quoted_string()
    }

    // number             = 1*DIGIT [ QUANTIFIER ]
    // QUANTIFIER         = "K" / "M" / "G"
    pub fn number<'a>() -> impl Parser<'a, u64> {
        map_res(
            pair(
                is_a(b"0123456789"),
                pred(any_char, |c| {
                    ['k', 'm', 'g'].contains(&c.to_ascii_lowercase())
                }),
            ),
            |(num_s, quant)| {
                Ok(match (num_s.parse::<u64>(), quant.to_ascii_lowercase()) {
                    (Ok(num), 'k') => num * 1_000,
                    (Ok(num), 'm') => num * 1_000_000,
                    (Ok(num), 'g') => num * 1_000_000_000,
                    _ => return Err(num_s),
                })
            },
        )
    }

    pub fn parse_sieve_integer_operator<'a>() -> impl Parser<'a, (IntegerOperator, u64)> {
        move |input| {
            ws(pair(
                either(
                    map(parse_token(":over"), |_| IntegerOperator::Over),
                    map(parse_token(":under"), |_| IntegerOperator::Under),
                ),
                ws(number()),
            ))
            .parse(input)
        }
    }
    // ":comparator" <comparator-name: string>
    pub fn parse_sieve_comparator<'a>() -> impl Parser<'a, CharacterOperator> {
        move |input| {
            ws(right(
                parse_token(":comparator"),
                ws(map_res(string(), |s| {
                    if s == "i;octet" {
                        Ok(CharacterOperator::Octet)
                    } else if s == "i;ascii-casemap" {
                        Ok(CharacterOperator::AsciiCasemap)
                    } else {
                        Err("invalid comparator")
                    }
                })),
            ))
            .parse(input)
        }
    }

    // MATCH-TYPE   = ":is" / ":contains" / ":matches"
    pub fn parse_sieve_match_type<'a>() -> impl Parser<'a, MatchOperator> {
        move |input| {
            either(
                map(parse_token(":is"), |_| MatchOperator::Is),
                either(
                    map(parse_token(":contains"), |_| MatchOperator::Contains),
                    map(parse_token(":matches"), |_| MatchOperator::Matches),
                ),
            )
            .parse(input)
        }
    }

    /* string-list  = "[" string *("," string) "]" / string
                    ; if there is only a single string, the brackets
                    ; are optional
    */
    pub fn parse_string_list<'a>() -> impl Parser<'a, Vec<String>> {
        move |input| {
            either(
                delimited(
                    ws(parse_token("[")),
                    separated_list0(string(), ws(parse_token(",")), false),
                    ws(parse_token("]")),
                ),
                map(string(), |s| vec![s]),
            )
            .parse(input)
        }
    }

    /* Usage:   header [COMPARATOR] [MATCH-TYPE]
     * <header-names: string-list> <key-list: string-list>
     */
    pub fn parse_sieve_header<'a>() -> impl Parser<'a, ConditionRule> {
        move |input| {
            map(
                ws(pair(
                    right(parse_token("header"), move |input| {
                        crate::permutation! {
                            input,
                            comparator, Option<CharacterOperator>, opt(parse_sieve_comparator()),
                            match_type, Option<MatchOperator>, opt(parse_sieve_match_type())
                        }
                    }),
                    pair(ws(parse_string_list()), ws(parse_string_list())),
                )),
                |((comparator, match_operator), (header_names, key_list))| ConditionRule::Header {
                    comparator,
                    match_operator,
                    header_names,
                    key_list,
                },
            )
            .parse(input)
        }
    }

    // ADDRESS-PART = ":localpart" / ":domain" / ":all"
    pub fn parse_sieve_address_type<'a>() -> impl Parser<'a, AddressOperator> {
        move |input| {
            either(
                map(parse_token(":localpart"), |_| AddressOperator::Localpart),
                either(
                    map(parse_token(":domain"), |_| AddressOperator::Domain),
                    map(parse_token(":all"), |_| AddressOperator::All),
                ),
            )
            .parse(input)
        }
    }

    // address [COMPARATOR] [ADDRESS-PART] [MATCH-TYPE] <header-list: string-list>
    // <key-list: string-list>
    pub fn parse_sieve_address<'a>() -> impl Parser<'a, ConditionRule> {
        move |input| {
            map(
                ws(pair(
                    right(parse_token("address"), move |input| {
                        crate::permutation! {
                            input,
                            match_type, Option<MatchOperator>, opt(parse_sieve_match_type()),
                            comparator, Option<CharacterOperator>, opt(parse_sieve_comparator()),
                            address_type, Option<AddressOperator>, opt(parse_sieve_address_type())
                        }
                    }),
                    pair(ws(parse_string_list()), ws(parse_string_list())),
                )),
                |((match_type, comparator, address_part), (header_list, key_list))| {
                    ConditionRule::Address {
                        comparator,
                        address_part,
                        match_type,
                        header_list,
                        key_list,
                    }
                },
            )
            .parse(input)
        }
    }

    pub fn parse_sieve_test<'a>() -> impl Parser<'a, ConditionRule> {
        move |input| {
            either(
                either(
                    map(parse_token("true"), |_| ConditionRule::Literal(true)),
                    map(parse_token("false"), |_| ConditionRule::Literal(false)),
                ),
                either(
                    either(
                        map(
                            right(ws(parse_token("exists")), ws(parse_string_list())),
                            ConditionRule::Exists,
                        ),
                        map(
                            right(ws(parse_token("size")), ws(parse_sieve_integer_operator())),
                            |(operator, limit)| ConditionRule::Size { operator, limit },
                        ),
                    ),
                    either(
                        either(
                            map(right(ws(parse_token("not")), parse_sieve_test()), |cond| {
                                ConditionRule::Not(Box::new(cond))
                            }),
                            either(parse_sieve_header(), parse_sieve_address()),
                        ),
                        either(
                            map(
                                right(ws(parse_token("allof")), parse_test_list()),
                                ConditionRule::AllOf,
                            ),
                            map(
                                right(ws(parse_token("anyof")), parse_test_list()),
                                ConditionRule::AnyOf,
                            ),
                        ),
                    ),
                ),
            )
            .parse(input)
        }
    }

    /* test-list  = "(" test *("," test) ")"
     */
    pub fn parse_test_list<'a>() -> impl Parser<'a, Vec<ConditionRule>> {
        move |input| {
            delimited(
                ws(parse_token("(")),
                separated_list0(ws(parse_sieve_test()), ws(parse_token(",")), false),
                ws(parse_token(")")),
            )
            .parse(input)
        }
    }

    pub fn parse_sieve_rule<'a>() -> impl Parser<'a, Rule> {
        either(
            map(
                either(
                    either(parse_sieve_stop(), parse_sieve_require()),
                    parse_sieve_if(),
                ),
                Rule::Control,
            ),
            map(
                either(
                    either(parse_sieve_keep(), parse_sieve_fileinto()),
                    either(parse_sieve_redirect(), parse_sieve_discard()),
                ),
                Rule::Action,
            ),
        )
    }

    pub fn parse_sieve_block<'a>() -> impl Parser<'a, RuleBlock> {
        move |input| {
            map(
                ws(delimited(
                    parse_token("{"),
                    ws(zero_or_more(parse_sieve_rule())),
                    parse_token("}"),
                )),
                RuleBlock,
            )
            .parse(input)
        }
    }

    pub fn parse_sieve_if<'a>() -> impl Parser<'a, ControlCommand> {
        either(
            map(
                pair(
                    parse_sieve_if_bare(),
                    ws(right(parse_token("else"), ws(parse_sieve_block()))),
                ),
                |(ifbare, else_)| match ifbare {
                    ControlCommand::If {
                        condition,
                        elsif,
                        else_: _,
                    } => ControlCommand::If {
                        condition,
                        elsif,
                        else_: Some(else_),
                    },
                    _ => unreachable!(),
                },
            ),
            parse_sieve_if_bare(),
        )
    }

    pub fn parse_sieve_if_bare<'a>() -> impl Parser<'a, ControlCommand> {
        either(
            map(
                pair(
                    ws(pair(
                        ws(right(parse_token("if"), ws(parse_sieve_test()))),
                        ws(parse_sieve_block()),
                    )),
                    ws(pair(
                        ws(right(parse_token("elsif"), ws(parse_sieve_test()))),
                        ws(parse_sieve_block()),
                    )),
                ),
                |(condition, elsif)| ControlCommand::If {
                    condition,
                    elsif: Some(elsif),
                    else_: None,
                },
            ),
            map(
                pair(
                    ws(right(parse_token("if"), ws(parse_sieve_test()))),
                    ws(parse_sieve_block()),
                ),
                |(cond, block)| ControlCommand::If {
                    condition: (cond, block),
                    elsif: None,
                    else_: None,
                },
            ),
        )
    }

    pub fn parse_sieve_require<'a>() -> impl Parser<'a, ControlCommand> {
        move |input| {
            right(
                ws(parse_token("require")),
                ws(left(
                    map(parse_string_list(), |string_list| {
                        ControlCommand::Require(string_list)
                    }),
                    ws(parse_token(";")),
                )),
            )
            .parse(input)
        }
    }

    pub fn parse_sieve<'a>() -> impl Parser<'a, Vec<Rule>> {
        ws(zero_or_more(ws(parse_sieve_rule())))
    }
}

#[cfg(test)]
mod test {
    use super::{
        parser::*, ActionCommand::*, AddressOperator::*, CharacterOperator::*, ConditionRule::*,
        ControlCommand::*, IntegerOperator::*, MatchOperator::*, Rule::*, RuleBlock,
    };
    use crate::utils::parsec::Parser;

    #[test]
    fn test_sieve_parse_strings() {
        assert_eq!(
            Ok(("", vec!["fileinto".to_string(), "reject".to_string()])),
            parse_string_list().parse(r#"["fileinto", "reject"]"#)
        );

        assert_eq!(
            Ok(("", vec!["fileinto".to_string()])),
            parse_string_list().parse(r#""fileinto""#)
        );
    }

    #[test]
    fn test_sieve_parse_conditionals() {
        /* Operators that start with : like :matches are unordered and optional,
         * since they have defaults. But that means we must handle any order
         * correctly, which is tricky if we use an optional parser; for an
         * optional parser both None and Some(_) are valid values.
         */

        /* Permutations of two */
        let raw_input = r#"header :contains :comparator "i;octet" "Subject"
                   "MAKE MONEY FAST""#;
        let (_, first) = parse_sieve_test().parse(raw_input).unwrap();
        assert_eq!(
            Header {
                comparator: Some(Octet),
                match_operator: Some(Contains),
                header_names: ["Subject".to_string()].to_vec(),
                key_list: ["MAKE MONEY FAST".to_string()].to_vec()
            },
            first
        );

        let raw_input = r#"header :comparator "i;octet" :contains "Subject"
                   "MAKE MONEY FAST""#;
        assert_eq!(Ok(("", first)), parse_sieve_test().parse(raw_input));

        /* Permutations of three */
        let raw_input = r#"address :DOMAIN :comparator "i;octet" :is ["From", "To"] "example.com""#;
        let (_, first) = parse_sieve_test().parse(raw_input).unwrap();

        assert_eq!(
            &Address {
                comparator: Some(Octet),
                address_part: Some(Domain),
                match_type: Some(Is),
                header_list: ["From".to_string(), "To".to_string()].to_vec(),
                key_list: ["example.com".to_string()].to_vec()
            },
            &first
        );

        let raw_input =
            r#"address :DOMAIN :is :comparator "i;octet"  ["From", "To"] "example.com""#;
        assert_eq!(Ok(("", first.clone())), parse_sieve_test().parse(raw_input));

        let raw_input =
            r#"address :is :DOMAIN :comparator "i;octet"  ["From", "To"] "example.com""#;
        assert_eq!(Ok(("", first.clone())), parse_sieve_test().parse(raw_input));

        let raw_input = r#"address :is :comparator "i;octet" :DOMAIN ["From", "To"] "example.com""#;
        assert_eq!(Ok(("", first)), parse_sieve_test().parse(raw_input));
    }

    #[test]
    fn test_sieve_parse_ifs() {
        let raw_input = "if true {\nstop ;\n}";
        assert_eq!(
            Ok((
                "",
                Control(If {
                    condition: (Literal(true), RuleBlock([Control(Stop)].to_vec())),
                    elsif: None,
                    else_: None
                })
            )),
            parse_sieve_rule().parse(raw_input)
        );

        let raw_input = r#"# Reject all messages that contain the string "ivnten"in the Subject.
if header :contains "subject" "ivnten"
{
    discard;
} else {
    keep;
}"#;

        assert_eq!(
            Ok((
                "",
                [Control(If {
                    condition: (
                        Header {
                            comparator: None,
                            match_operator: Some(Contains),
                            header_names: ["subject".to_string()].to_vec(),
                            key_list: ["ivnten".to_string()].to_vec()
                        },
                        RuleBlock([Action(Discard)].to_vec())
                    ),
                    elsif: None,
                    else_: Some(RuleBlock([Action(Keep)].to_vec()))
                })]
                .to_vec()
            )),
            parse_sieve().parse(raw_input)
        );

        let raw_input = r#"# Reject all messages that contain the string "ivnten"in the Subject.
if header :contains "subject" "ivnten"
{
    discard;
}
# Silently discard all messages sent from the tax man
elsif address :matches :domain "from" "*hmrc.gov.uk"
{
    keep;
}"#;
        assert_eq!(
            Ok((
                "",
                [Control(If {
                    condition: (
                        Header {
                            comparator: None,
                            match_operator: Some(Contains),
                            header_names: ["subject".to_string()].to_vec(),
                            key_list: ["ivnten".to_string()].to_vec()
                        },
                        RuleBlock([Action(Discard)].to_vec())
                    ),
                    elsif: Some((
                        Address {
                            comparator: None,
                            address_part: Some(Domain),
                            match_type: Some(Matches),
                            header_list: ["from".to_string()].to_vec(),
                            key_list: ["*hmrc.gov.uk".to_string()].to_vec()
                        },
                        RuleBlock([Action(Keep)].to_vec())
                    )),
                    else_: None
                })]
                .to_vec()
            )),
            parse_sieve().parse(raw_input)
        );
    }

    #[test]
    fn test_sieve_parse() {
        let raw_input = r#"# The hash character starts a one-line comment.

"#;
        assert_eq!(Ok(("", vec![])), parse_sieve().parse(raw_input));

        let raw_input = r#"# The hash character starts a one-line comment.
# Everything after a # character until the end of line is ignored.

/* this is a bracketed (C-style) comment. This type of comment can stretch
 * over many lines. A bracketed comment begins with a forward slash, followed
 * by an asterisk and ends with the inverse sequence: an asterisk followed
 * by a forward slash. */
"#;

        assert_eq!(Ok(("", vec![])), parse_sieve().parse(raw_input));
        // Test Lists (allof, anyof)

        let raw_input = r#"# This test checks against Spamassassin's header fields:
# If the spam level is 4 or more and the Subject contains too
# many illegal characters, then silently discard the mail.
if allof (header :contains "X-Spam-Level" "****",
          header :contains "X-Spam-Report" "FROM_ILLEGAL_CHARS")
{
    discard;
}
# Discard mails that do not have a Date: or From: header field
# or mails that are sent from the marketing department at example.com.
elsif anyof (not exists ["from", "date"],
        header :contains "from" "marketing@example.com") {
    discard;
}"#;

        assert_eq!(
            Ok((
                "",
                [Control(If {
                    condition: (
                        AllOf(
                            [
                                Header {
                                    comparator: None,
                                    match_operator: Some(Contains),
                                    header_names: ["X-Spam-Level".to_string()].to_vec(),
                                    key_list: ["****".to_string()].to_vec()
                                },
                                Header {
                                    comparator: None,
                                    match_operator: Some(Contains),
                                    header_names: ["X-Spam-Report".to_string()].to_vec(),
                                    key_list: ["FROM_ILLEGAL_CHARS".to_string()].to_vec()
                                }
                            ]
                            .to_vec()
                        ),
                        RuleBlock([Action(Discard)].to_vec())
                    ),
                    elsif: Some((
                        AnyOf(
                            [
                                Not(Box::new(Exists(
                                    ["from".to_string(), "date".to_string()].to_vec()
                                ))),
                                Header {
                                    comparator: None,
                                    match_operator: Some(Contains),
                                    header_names: ["from".to_string()].to_vec(),
                                    key_list: ["marketing@example.com".to_string()].to_vec()
                                }
                            ]
                            .to_vec()
                        ),
                        RuleBlock([Action(Discard)].to_vec())
                    )),
                    else_: None
                })]
                .to_vec()
            )),
            parse_sieve().parse(raw_input)
        );
        // Filter on message size
        let raw_input = r#"# Delete messages greater than half a MB
if size :over 500K
{
    discard;
}
# Also delete small mails, under 1k
if size :under 1k
{
    discard;
}"#;
        assert_eq!(
            Ok((
                "",
                [
                    Control(If {
                        condition: (
                            Size {
                                operator: Over,
                                limit: 500000
                            },
                            RuleBlock([Action(Discard)].to_vec())
                        ),
                        elsif: None,
                        else_: None
                    }),
                    Control(If {
                        condition: (
                            Size {
                                operator: Under,
                                limit: 1000
                            },
                            RuleBlock([Action(Discard)].to_vec())
                        ),
                        elsif: None,
                        else_: None
                    })
                ]
                .to_vec()
            )),
            parse_sieve().parse(raw_input)
        );

        assert_eq!(
            Ok((
                "",
                [
                    Control(Require(["fileinto".to_string()].to_vec())),
                    Control(If {
                        condition: (
                            Header {
                                comparator: None,
                                match_operator: Some(Contains),
                                header_names: ["from".to_string()].to_vec(),
                                key_list: ["coyote".to_string()].to_vec()
                            },
                            RuleBlock([Action(Discard)].to_vec())
                        ),
                        elsif: Some((
                            Header {
                                comparator: None,
                                match_operator: Some(Contains),
                                header_names: ["subject".to_string()].to_vec(),
                                key_list: ["$$$".to_string()].to_vec()
                            },
                            RuleBlock([Action(Discard)].to_vec())
                        )),
                        else_: Some(RuleBlock(
                            [Action(Fileinto {
                                mailbox: "INBOX".to_string()
                            })]
                            .to_vec()
                        ))
                    })
                ]
                .to_vec()
            )),
            parse_sieve().parse(
                r#"require "fileinto";
             if header :contains "from" "coyote" {
                discard;
             } elsif header :contains ["subject"] ["$$$"] {
                discard;
             } else {
                fileinto "INBOX";
             }"#
            )
        );
    }
}
