use serde::{Deserialize, Serialize};

use crate::{
    Request,
    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
    common::types::{Sort, WindowRange},
    filter::Filter,
    request_tokenizer::RequestTokenizer,
    response_tokenizer::ResponseAttributes,
};

pub struct PlaylistSearch;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaylistSearchRequest {
    filter: Filter,
    sort: Option<Sort>,
    window: Option<WindowRange>,
}

impl Command for PlaylistSearch {
    type Request = PlaylistSearchRequest;
    type Response = ();
    const COMMAND: &'static str = "playlistsearch";

    fn serialize_request(&self, request: Self::Request) -> String {
        let mut cmd = format!("{} {}", Self::COMMAND, request.filter);
        if let Some(sort) = request.sort {
            cmd.push_str(&format!(" sort {}", sort));
        }
        if let Some(window) = request.window {
            cmd.push_str(&format!(" window {}", window));
        }
        cmd
    }

    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
        let filter = match parts.next() {
            Some(f) => {
                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
            }
            None => return Err(RequestParserError::UnexpectedEOF),
        };

        let mut sort_or_window = parts.next();
        let mut sort = None;
        if let Some("sort") = sort_or_window {
            let s = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
            sort = Some(
                s.parse()
                    .map_err(|_| RequestParserError::SyntaxError(0, s.to_string()))?,
            );
            sort_or_window = parts.next();
        }

        let mut window = None;
        if let Some("window") = sort_or_window {
            let w = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
            window = Some(
                w.parse()
                    .map_err(|_| RequestParserError::SyntaxError(0, w.to_string()))?,
            );
        }

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

        Ok((Request::PlaylistSearch(filter, sort, window), ""))
    }

    fn parse_response(
        _parts: ResponseAttributes<'_>,
    ) -> Result<Self::Response, ResponseParserError<'_>> {
        unimplemented!()
    }
}