pub fn new(input: &'a str) -> Self {

        Self {

            inner: input,

            cursor: 0,

        }

    }

fn parse_command_name(input: &str) -> Option<&str> {

    let mut sorted_commands = COMMAND_NAMES.to_vec();

    sorted_commands.sort_by_key(|b| std::cmp::Reverse(b.len()));

    sorted_commands

        .into_iter()

        .find(|&command| input.starts_with(command))

}

    fn next(&mut self) -> Option<&'a str> {

        fn is_whitespace(byte: u8) -> bool {

            byte.is_ascii_whitespace()

        }

        let bytes = self.inner.as_bytes();

        let len = bytes.len();

        let should_parse_command = self.cursor == 0;

        while self.cursor < len && is_whitespace(bytes[self.cursor]) {

            self.cursor += 1;

        }

        if should_parse_command {

            if let Some(command) = parse_command_name(&self.inner[self.cursor..]) {

                self.cursor += command.len();

                return Some(command);

                return None;

        }

        if self.cursor >= len {

            return None;

        }

        let start = self.cursor;

        if bytes[self.cursor] == b'"' {

            self.cursor += 1; // Skip opening quote

            while self.cursor < len {

                if bytes[self.cursor] == b'\\'

                    && self.cursor + 1 < len

                    && bytes[self.cursor + 1] == b'"'

                    self.cursor += 2; // Skip escaped quote

                    continue;

                }

                if bytes[self.cursor] == b'"' {

                    let end = self.cursor;

                    self.cursor += 1; // Skip closing quote

                    return Some(&self.inner[start + 1..end]);

                }

                self.cursor += 1;

            Some(&self.inner[start + 1..])

            while self.cursor < len && !is_whitespace(bytes[self.cursor]) {

                self.cursor += 1;

            }

            Some(&self.inner[start..self.cursor])

    }

    fn test_request_tokenizer() {

        let input = r#"add arg1 "arg two" arg3 "arg four with spaces""#;

        let mut tokenizer = RequestTokenizer::new(input);

        assert_eq!(tokenizer.next(), Some("add"));

        assert_eq!(tokenizer.next(), Some("arg1"));

        assert_eq!(tokenizer.next(), Some("arg two"));

        assert_eq!(tokenizer.next(), Some("arg3"));

        assert_eq!(tokenizer.next(), Some("arg four with spaces"));

        assert_eq!(tokenizer.next(), None);

    }

    fn test_request_tokenizer_invalid_command() {

        let input = r#"invalid_command arg1 "arg two" arg3 "arg four with spaces""#;

        let mut tokenizer = RequestTokenizer::new(input);

        assert_eq!(tokenizer.next(), None);

    }

    fn test_request_tokenizer_unclosed_quote() {

        let input = r#"add arg1 "arg two arg3"#;

        let mut tokenizer = RequestTokenizer::new(input);

        assert_eq!(tokenizer.next(), Some("add"));

        assert_eq!(tokenizer.next(), Some("arg1"));

        assert_eq!(tokenizer.next(), Some("arg two arg3"));

        assert_eq!(tokenizer.next(), None);

    }

    fn test_request_tokenizer_only_whitespace() {

        let input = r#"     "#;

        let mut tokenizer = RequestTokenizer::new(input);

        assert_eq!(tokenizer.next(), None);

    }

    fn test_request_tokenizer_escape_quotes() {

        let input = r#"add "arg with a \" quote" arg2"#;

        let mut tokenizer = RequestTokenizer::new(input);

        assert_eq!(tokenizer.next(), Some("add"));

        assert_eq!(tokenizer.next(), Some(r#"arg with a \" quote"#));

        assert_eq!(tokenizer.next(), Some("arg2"));

        assert_eq!(tokenizer.next(), None);

    }

    fn test_request_tokenizer_multitoken_command() {

        let input = r#"protocol all arg"#;

        let mut tokenizer = RequestTokenizer::new(input);

        assert_eq!(tokenizer.next(), Some("protocol all"));

        assert_eq!(tokenizer.next(), Some("arg"));

        assert_eq!(tokenizer.next(), None);

        let input = r#"protocol arg"#;

        let mut tokenizer = RequestTokenizer::new(input);

        assert_eq!(tokenizer.next(), Some("protocol"));

        assert_eq!(tokenizer.next(), Some("arg"));

        assert_eq!(tokenizer.next(), None);

    }