1
use std::collections::HashMap;
2

            
3
use crate::{
4
    commands::{
5
        get_and_parse_property, Command, Request, RequestParserError, RequestParserResult,
6
        ResponseAttributes, ResponseParserError,
7
    },
8
    filter::parse_filter,
9
};
10

            
11
pub struct Count;
12

            
13
pub struct CountResponse {
14
    pub songs: usize,
15
    pub playtime: u64,
16
}
17

            
18
impl Command for Count {
19
    type Response = CountResponse;
20
    const COMMAND: &'static str = "count";
21

            
22
    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
23
        let filter = parse_filter(&mut parts)?;
24

            
25
        let group = if let Some("group") = parts.next() {
26
            let group = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
27

            
28
            Some(
29
                group
30
                    .parse()
31
                    .map_err(|_| RequestParserError::SyntaxError(1, group.to_owned()))?,
32
            )
33
        } else {
34
            None
35
        };
36

            
37
        debug_assert!(parts.next().is_none());
38

            
39
        Ok((Request::Count(filter, group), ""))
40
    }
41

            
42
    fn parse_response(
43
        parts: ResponseAttributes<'_>,
44
    ) -> Result<Self::Response, ResponseParserError> {
45
        let parts: HashMap<_, _> = parts.into();
46

            
47
        let songs = get_and_parse_property!(parts, "songs", Text);
48
        let playtime = get_and_parse_property!(parts, "playtime", Text);
49

            
50
        Ok(CountResponse { songs, playtime })
51
    }
52
}