use serde::{Deserialize, Serialize};

use crate::{
    Response,
    commands::{Command, CommandRequest, CommandResponse, RequestParserError, ResponseParserError},
    filter::Filter,
    request_tokenizer::RequestTokenizer,
    response_tokenizer::ResponseAttributes,
    types::{DbSongInfo, Priority, SongId, SongPosition, Sort, WindowRange},
};

pub struct PlaylistFind;

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

impl CommandRequest<'_> for PlaylistFindRequest {
    const COMMAND: &'static str = "playlistfind";

    fn into_request_enum(self) -> crate::Request {
        crate::Request::PlaylistFind(self.filter, self.sort, self.window)
    }

    fn from_request_enum(request: crate::Request) -> Option<Self> {
        match request {
            crate::Request::PlaylistFind(filter, sort, window) => Some(PlaylistFindRequest {
                filter,
                sort,
                window,
            }),
            _ => None,
        }
    }

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

    fn parse(mut parts: RequestTokenizer<'_>) -> Result<Self, RequestParserError> {
        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(PlaylistFindRequest {
            filter,
            sort,
            window,
        })
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaylistFindResponse(Vec<PlaylistFindResponseEntry>);

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaylistFindResponseEntry {
    pub position: SongPosition,
    pub id: SongId,
    pub priority: Option<Priority>,
    pub song_info: DbSongInfo,
}

impl CommandResponse<'_> for PlaylistFindResponse {
    fn into_response_enum(self) -> Response {
        todo!()
    }

    fn from_response_enum(response: Response) -> Option<Self> {
        todo!()
    }

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

impl Command<'_, '_> for PlaylistFind {
    type Request = PlaylistFindRequest;
    type Response = PlaylistFindResponse;
}