fn find_end(s: &str, start: usize) -> Option<usize> {
    if s.len() <= start {
        return None;
    }

    let mut index = start + 1;

    while !s.is_char_boundary(index) {
        index += 1;
    }

    Some(index)
}

fn resolve_indexes(s: &str, delims: &[char]) -> Option<Vec<(usize, usize)>> {
    let mut indexi = Vec::new();
    for (index, c) in s.char_indices() {
        if !delims.contains(&c) {
            continue;
        }

        let end = find_end(s, index)?;

        indexi.push((index, end));
    }

    indexi.sort();
    Some(indexi)
}

struct Args<'a> {
    message: &'a str,
    delims: &'a [char],
    offset: usize,
    offsets: Vec<(usize, usize)>,
    // Used for rewinding
    prev: Option<(usize, (usize, usize))>,
}

impl<'a> Args<'a> {
    fn new(msg: &'a str, delims: &'a [char]) -> Self {
        Args {
            message: msg,
            delims: delims,
            offset: 0,
            offsets: resolve_indexes(msg, delims).unwrap(),
            prev: None,
        }
    }

    fn until_internal(&mut self, change: bool) -> Option<&'a str> {
        if self.offset >= self.message.len() {
            return None;
        }

        if self.offsets.is_empty() {
            let s = &self.message[self.offset..];

            // We've reached the end; invalidate the offset.
            self.offset = self.message.len();
            return Some(s);
        }

        let (start, end) = if change {
            self.offsets.remove(0)
        } else {
            self.offsets[0]
        };

        let string = &self.message[self.offset..start];

        if change {
            self.prev = Some((self.offset, (start, end)));
            self.offset = end;
        }

        if string.is_empty() {
            return self.until_internal(true);
        } else {
            for delim in self.delims {
                if string.chars().all(|c| c == *delim) {
                    return self.until_internal(true);
                }
            }
        }

        Some(string)
    }

    #[inline]
    fn single(&mut self) -> Option<&'a str> {
        self.until_internal(true)
    }

    #[inline]
    fn single_s(&mut self) -> Option<&'a str> {
        self.until_internal(false)
    }

    fn rewind(&mut self) {
        match self.prev {
            Some((off, offsets)) => {
                self.offset = off;
                self.offsets.insert(0, offsets);
            },
            None => {
                self.offset = 0;
            },
        }
    }
}

fn main() {
    const MESSAGE: &str = "42 fd88 😂!🛑     a !  s ! 同共同共同 どうしゃ 漢字 조선글조선 글조선글조선글조선글ㅁㄴ런애ㅗ ㅕㅑㅑㅛㅐㅂ 제베ㅔㅔㅑㅏ에네에에!ㅔ???ㅔㅓ레체[ㄹ ㄴ에렌야ㅐㅔ다ㅡ추타펕치ㅓㅍㄴ안ㅇㄹ 99";
    let mut args = Args::new(MESSAGE, &[' ', '!']);

    // `single_s` should not alter the internal offset whatsoever.
    assert_eq!(args.single_s(), Some("42"));
    assert_eq!(args.single(), Some("42"));
    args.rewind();
    while let Some(s) = args.single() {
        println!("{:?}", s);
    }
}