use std::collections::HashMap;

struct Solution {}

#[derive(Default)]
struct Term {
    count: i32,
    // p中某个字符出现的次数
    expect: i32, //在匹配的过程中某个字符出现的次数
}
#[derive(Eq, PartialEq)]
enum ExpectResult {
    Less,
    Equal,
    Greater,
}
//管理map
impl Term {
    fn new() -> Self {
        Term {
            count: 0,
            expect: 0,
        }
    }
    fn incCount(&mut self) {
        self.count += 1;
    }
    fn incExpect(&mut self) -> ExpectResult {
        self.expect += 1;
        if self.count > self.expect {
            return ExpectResult::Less;
        } else if self.count == self.expect {
            return ExpectResult::Equal;
        } else {
            return ExpectResult::Greater;
        }
    }
    fn dec_expect(&mut self) {
        self.expect -= 1;
    }
    fn reset(&mut self) {
        self.expect = 0;
    }
    fn is_match(&self) -> bool {
        return self.count == self.expect;
    }
}
use std::collections::hash_map::Entry;
impl Solution {
    pub fn find_anagrams(s: String, p: String) -> Vec<i32> {
        let s = s.as_bytes();
        let p = p.as_bytes();
        let mut m = HashMap::new();
        let mut v = Vec::new();
        let mut total_count = p.len() as i32;
        let mut last_count = 0;

        for b in p {
            m.entry(b).or_insert(Term::new()).incCount();
        }
        fn reset(m: &mut HashMap<&u8, Term>, last_count: &mut i32) {
            *last_count = 0;
            m.values_mut().for_each(|v: &mut Term| {
                v.reset();
            });
        };
        let mut i = 0;
        while i < s.len() {
            println!("i={}", i);
            let e = m.get_mut(&s[i]);
            match e {
                None => {
                    //b在p中就不存在, 直接重来就行了
                    reset(&mut m, &mut last_count);
                    i += 1;
                    continue;
                }
                Some(_) => {
                    //从b开始循环匹配,直到全部匹配位置
                    let mut cnt = last_count;
                    for j in i..s.len() {
                        println!("j={}", j);
                        let e = m.get_mut(&s[j]);
                        match e {
                            None => {
                                //找到不在p中的字符,直接从头开始
                                reset(&mut m, &mut last_count);
                                i = j + 1;
                                break;
                            }
                            Some(mut e) => {
                                cnt += 1;
                                let r = e.incExpect();
                                //总数匹配了,并且最近一次数量刚好相等,说明找到了一个完整匹配
                                if r == ExpectResult::Greater {
                                    //有一个字符多了,从下一个开始匹配
                                    i = j + 1 - cnt as usize + 1; //这里不能是i=i+1,因为可能是上一次匹配从而导致i并没有指向起始
                                    reset(&mut m, &mut last_count);
                                    break;
                                }
                                if cnt == total_count && r == ExpectResult::Equal {
                                    let start = j + 1 - p.len();
                                    v.push(start as i32);
                                    //                                    e2.dec_expect();
                                    m.get_mut(&s[start]).expect("must exist").dec_expect();
                                    i = j + 1; //从当前位置继续往下匹配,只是把i从m中移除
                                    last_count = total_count - 1;
                                    println!("break to i={}", i);
                                    break; //只能从下一个开始匹配
                                }
                                //没有匹配完整的情形,继续
                            }
                        }
                    }
                    //走到最后了
                    //                    panic!(format!("i={}", i));
                }
            }
        }
        v
    }
}
#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn test_sorted_list_to_bst() {
        let t = Solution::find_anagrams(String::from("abab"), String::from("ab"));
        assert_eq!(t, vec![0, 1, 2]);
        let t = Solution::find_anagrams(String::from("abaacbabc"), String::from("abc"));
        assert_eq!(t, vec![3, 4, 6]);
    }
}