use serde::{Deserialize, Serialize};

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

pub struct PlChanges;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlChangesRequest {
    pub version: PlaylistVersion,
    pub window: Option<WindowRange>,
}

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

    fn into_request_enum(self) -> crate::Request {
        crate::Request::PlChanges(self.version, self.window)
    }

    fn from_request_enum(request: crate::Request) -> Option<Self> {
        match request {
            crate::Request::PlChanges(version, window) => {
                Some(PlChangesRequest { version, window })
            }
            _ => None,
        }
    }

    fn serialize(&self) -> String {
        match self.window.as_ref() {
            Some(window) => format!("{} {} {}", Self::COMMAND, self.version, window),
            None => format!("{} {}", Self::COMMAND, self.version),
        }
    }

    fn parse(mut parts: RequestTokenizer<'_>) -> Result<Self, RequestParserError> {
        let version = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
        let version = version
            .parse()
            .map_err(|_| RequestParserError::SyntaxError(0, version.to_string()))?;

        let window = parts
            .next()
            .map(|w| {
                w.parse()
                    .map_err(|_| RequestParserError::SyntaxError(0, w.to_string()))
            })
            .transpose()?;

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

        Ok(PlChangesRequest { version, window })
    }
}

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

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

impl CommandResponse<'_> for PlChangesResponse {
    fn from_response_enum(response: crate::Response) -> Option<Self> {
        todo!()
    }

    fn into_response_enum(self) -> crate::Response {
        todo!()
    }

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

impl Command<'_, '_> for PlChanges {
    type Request = PlChangesRequest;
    type Response = PlChangesResponse;
}