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 SearchCount;
12

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

            
18
impl Command for SearchCount {
19
    type Response = SearchCountResponse;
20
    const COMMAND: &'static str = "searchcount";
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
            Some(
28
                group
29
                    .parse()
30
                    .map_err(|_| RequestParserError::SyntaxError(1, group.to_owned()))?,
31
            )
32
        } else {
33
            None
34
        };
35

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

            
38
        Ok((Request::SearchCount(filter, group), ""))
39
    }
40

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

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

            
49
        Ok(SearchCountResponse { songs, playtime })
50
    }
51
}