use core::fmt;
use std::fmt::{Display, Formatter};
use std::io::{self, BufReader, prelude::*, Write};
use std::net::TcpStream;
use std::ops::Deref;
use std::str;



fn main() {

    handle("localhost:9999").expect("--------------");
}

struct WordCount {
    word: String,
    count: i32,
}

impl WordCount{
    fn acc(&mut self, o1:&WordCount, o2:&WordCount) -> &WordCount {
        self.count =o1.count +o2.count;
        self.word=o1.word.clone();
        self
    }
}

impl Display for WordCount {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "WordCount{{ word:{},count:{} }}", self.word, self.count)
    }
}

fn handle<'a>(ip: &str) -> io::Result<()> {
    let mut stream = TcpStream::connect(ip)?;
    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Failed to read from stdin");
        stream.write(input.as_bytes()).expect("Failed to write to stream");

        let mut reader = BufReader::new(&stream);
        let mut buffer: Vec<u8> = Vec::new();
        reader.read_until(b'\n', &mut buffer).expect("Could not read into buffer");
        stream.flush();
        let x = str::from_utf8(&buffer).expect("Could not write buffer as string");
        let mut vec = Vec::new();
        vec.push(x);
        let mut t = vec.into_iter()
            .flat_map(|e| e.split(" "))
            .map(|e| WordCount { word: e.to_string(), count: 1 });

        let mut vec1 = Vec::new();
        while let Some(w) =&t.next() {
            let mut vec2 = Vec::new();

            vec2.push(w);
            while let Some(w1) =&t.next() {
                if w.word==w1.word {
                   vec2.push(w1) ;
                }
            }


            let reduce = Reduce { iterator: vec2.into_iter() };
            let  wc:&'a mut WordCount =&mut WordCount{ word:String::new(),count:0 };
            let option = reduce.count(|e, e1| wc.acc(e,e1));

            if  let Some(word_count) = option{
                vec1.push(word_count);
            }
        }

        println!("{:?}", t);
    }
}

struct Reduce<'a ,T>{
    iterator: std::vec::IntoIter<&'a T>
}

impl<'a,T> Reduce<'a,T> {
    fn count<F>(self, f : F) -> Option<&'a T> where F:FnMut(&'a T,&'a T)-> &'a T +'static {
        self.iterator.reduce(f)
    }
}

##错误

 --> src\bin\kvs.rs:68:33
   |
68 |             let option = reduce.count(|e, e1| wc.acc(e,e1));
   |                                 ^^^^^
   |
   = note: type must satisfy the static lifetime