use super::decoder::{Rule, Rules};

pub fn get_rules() -> Rules {
    vec![
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "S".to_string(),
            phoneme_out: "0".to_string(),
            not_before: vec!["I".to_string(), "Z".to_string()],
            only_before: vec![],
        },
        Rule {
            not_after: vec![
                "C".to_string(),
                "D".to_string(),
                "R".to_string(),
                "S".to_string(),
            ],
            only_after: vec![],
            phoneme_in: "Z".to_string(),
            phoneme_out: "0".to_string(),
            not_before: vec!["I".to_string()],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "T".to_string(),
            phoneme_out: "1".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            only_after: vec![],
            not_after: vec![],
            phoneme_in: "D".to_string(),
            phoneme_out: "1".to_string(),
            not_before: vec!["Z".to_string(), "Ź".to_string(), "Ż".to_string()],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "N".to_string(),
            phoneme_out: "2".to_string(),
            not_before: vec!["I".to_string()],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "M".to_string(),
            phoneme_out: "3".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "R".to_string(),
            phoneme_out: "4".to_string(),
            not_before: vec!["Z".to_string()],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "L".to_string(),
            phoneme_out: "5".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "J".to_string(),
            phoneme_out: "6".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "K".to_string(),
            phoneme_out: "7".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "G".to_string(),
            phoneme_out: "7".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "F".to_string(),
            phoneme_out: "8".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "W".to_string(),
            phoneme_out: "8".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "P".to_string(),
            phoneme_out: "9".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
        Rule {
            not_after: vec![],
            only_after: vec![],
            phoneme_in: "B".to_string(),
            phoneme_out: "9".to_string(),
            not_before: vec![],
            only_before: vec![],
        },
    ]
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::SystemDecoder;
    use crate::sys_major::Decoder;

    #[test]
    fn test_major_dict_pl_decode_0_1() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("SZSCZ").unwrap();
        assert_eq!(output, "0")
    }

    #[test]
    fn test_major_dict_pl_decode_0_2() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("SZSICZ").unwrap();
        assert_eq!(output, "")
    }

    #[test]
    fn test_major_dict_pl_decode_0_3() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("SZCZRZZCZDZSZ").unwrap();
        assert_eq!(output, "0")
    }

    #[test]
    fn test_major_dict_pl_decode_0_4() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("SZCZRZZICZDZSZ").unwrap();
        assert_eq!(output, "")
    }

    #[test]
    fn test_major_dict_pl_decode_1_1() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("SZTCZ").unwrap();
        assert_eq!(output, "1")
    }

    #[test]
    fn test_major_dict_pl_decode_1_2() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("DZDŻDŹDDZDŻDŹ").unwrap();
        assert_eq!(output, "1")
    }

    #[test]
    fn test_major_dict_pl_decode_1_3() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("DZDŻDŹDZDZDŻDŹ").unwrap();
        assert_eq!(output, "")
    }

    #[test]
    fn test_major_dict_pl_decode_2_1() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("NINNI").unwrap();
        assert_eq!(output, "2")
    }

    #[test]
    fn test_major_dict_pl_decode_2_2() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("NININI").unwrap();
        assert_eq!(output, "")
    }

    #[test]
    fn test_major_dict_pl_decode_4_1() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("RZRRZ").unwrap();
        assert_eq!(output, "4")
    }

    #[test]
    fn test_major_dict_pl_decode_4_2() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("RZRZRZ").unwrap();
        assert_eq!(output, "")
    }

    #[test]
    fn test_major_dict_pl_decode_full_1() {
        let decoder = Decoder::new(get_rules());
        let output = decoder.decode("ATADANAMARALAJAKAGAFAWAPABA").unwrap();
        assert_eq!(output, "1123456778899")
    }
}