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";
    const MIN_ARGS: u32 = 1;
    const MAX_ARGS: Option<u32> = Some(2);

    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!("{} {} {}\n", Self::COMMAND, self.version, window),
            None => format!("{} {}\n", Self::COMMAND, self.version),
        }
    }

    fn parse(mut parts: RequestTokenizer<'_>) -> Result<Self, RequestParserError> {
        let version = parts.next().ok_or(Self::missing_arguments_error(0))?;
        let version = version
            .parse()
            .map_err(|_| RequestParserError::SubtypeParserError {
                argument_index: 0,
                expected_type: "PlaylistVersion".to_string(),
                raw_input: version.to_string(),
            })?;

        let window = parts
            .next()
            .map(|w| {
                w.parse()
                    .map_err(|_| RequestParserError::SubtypeParserError {
                        argument_index: 1,
                        expected_type: "WindowRange".to_string(),
                        raw_input: w.to_string(),
                    })
            })
            .transpose()?;

        Self::throw_if_too_many_arguments(parts)?;

        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;
}