//! The basic building blocks, definitions and helpers used to define an Mpd command.

//!

//! An mpd command consists of a pair of serializers and parsers for both the request

//! and the corresponding response, as well as the command name used to identify the command.

use crate::{request_tokenizer::RequestTokenizer, response_tokenizer::ResponseAttributes};

use serde::{Deserialize, Serialize};

use thiserror::Error;

mod audio_output_devices;

mod client_to_client;

mod connection_settings;

mod controlling_playback;

mod mounts_and_neighbors;

mod music_database;

mod partition_commands;

mod playback_options;

mod querying_mpd_status;

mod queue;

mod reflection;

mod stickers;

mod stored_playlists;

pub use audio_output_devices::*;

pub use client_to_client::*;

pub use connection_settings::*;

pub use controlling_playback::*;

pub use mounts_and_neighbors::*;

pub use music_database::*;

pub use partition_commands::*;

pub use playback_options::*;

pub use querying_mpd_status::*;

pub use queue::*;

pub use reflection::*;

pub use stickers::*;

pub use stored_playlists::*;

/// A trait modelling a single MPD command request.

pub trait CommandRequest

where

    Self: Sized,

{

    /// The response type produced by the server when this request is executed.

    type Response: CommandResponse;

    /// The command name used within the protocol

    const COMMAND: &'static str;

    // TODO: add these for ease of throwing parsing errors

    /// The minimum number of arguments this command takes

    const MIN_ARGS: u32;

    /// The maximum number of arguments this command takes.

    ///

    /// Note that in the case of keyworded arguments, such as

    /// `group <groupname>`, `sort <sorting>`, etc., these are

    /// counted as a single argument despite being two tokens.

    const MAX_ARGS: Option<u32>;

    /// Helper function to create a [`RequestParserError::TooManyArguments`] error

    /// Helper function to throw a [`RequestParserError::TooManyArguments`] error

    /// Helper function to create a [`RequestParserError::MissingArguments`] error

    /// Serializes the request into a String.

    fn serialize(&self) -> String;

    /// Parses the request from its tokenized parts.

    /// See also [`parse_raw`].

    fn parse(parts: RequestTokenizer<'_>) -> Result<Self, RequestParserError>;

    /// Parses the request from its raw string representation.

    ///

    /// This assumes the raw string starts with the command name, e.g.

    /// `command_name arg1 "arg2 arg3"`

        }

}

/// A trait modelling a single MPD command response.

pub trait CommandResponse

where

    Self: Sized,

{

    /// The request type that provokes this response.

    type Request: CommandRequest<Response = Self>;

    /// Parses the response from its tokenized parts.

    /// See also [`parse_raw`].

    fn parse(parts: ResponseAttributes<'_>) -> Result<Self, ResponseParserError>;

    /// Parses the response from its raw byte representation.

    /// Serializes the response to its raw byte representaion.

    ///

    /// Note that this does not include the trailing `OK\n` terminator.

    fn serialize(&self) -> Vec<u8>;

}

// Request/response implementation helpers

macro_rules! empty_command_request {

    ($name:ident, $command_name:expr) => {

        paste::paste! {

            #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]

            pub struct [<$name Request>];

        }

        impl std::default::Default for paste::paste! { [<$name Request>] } {

        }

        impl crate::commands::CommandRequest for paste::paste! { [<$name Request>] } {

            type Response = paste::paste! { [<$name Response>] };

            const COMMAND: &'static str = $command_name;

            const MIN_ARGS: u32 = 0;

            const MAX_ARGS: Option<u32> = Some(0);

        }

    };

}

macro_rules! empty_command_response {

    ($name:ident) => {

        paste::paste! {

            #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]

            pub struct [<$name Response>];

        }

        impl std::default::Default for paste::paste! { [<$name Response>] } {

        }

        impl crate::commands::CommandResponse for paste::paste! { [<$name Response>] } {

            type Request = paste::paste! { [<$name Request>] };

        }

    };

}

macro_rules! single_item_command_request {

    ($name:ident, $command_name:expr, $item_type:ty) => {

        paste::paste! {

            #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]

            pub struct [<$name Request>] (pub $item_type);

        }

        impl paste::paste! { [<$name Request>] } {

                paste::paste! {

                }

        }

        impl crate::commands::CommandRequest for paste::paste! { [<$name Request>] } {

            type Response = paste::paste! { [<$name Response>] };

            const COMMAND: &'static str = $command_name;

            const MIN_ARGS: u32 = 1;

            const MAX_ARGS: Option<u32> = Some(1);

        }

    };

}

macro_rules! single_optional_item_command_request {

    ($name:ident, $command_name:expr, $item_type:ty) => {

        paste::paste! {

            #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]

            pub struct [<$name Request>] (pub Option<$item_type>);

        }

        impl paste::paste! { [<$name Request>] } {

                paste::paste! {

                }

        }

        impl crate::commands::CommandRequest for paste::paste! { [<$name Request>] } {

            type Response = paste::paste! { [<$name Response>] };

            const COMMAND: &'static str = $command_name;

            const MIN_ARGS: u32 = 0;

            const MAX_ARGS: Option<u32> = Some(1);

                }

        }

    };

}

macro_rules! single_item_command_response {

    ($name:ident, $item_name:expr, $item_type:ty) => {

        paste::paste! {

            #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]

            pub struct [<$name Response>] (pub $item_type);

        }

        impl paste::paste! { [<$name Response>] } {

                paste::paste! {

                }

        }

        impl crate::commands::CommandResponse for paste::paste! { [<$name Response>] } {

            type Request = paste::paste! { [<$name Request>] };

                    $item_name,

                    Text

                );

                paste::paste! {

                        "response serialization is not yet implemented for ",

                        stringify!([<$name Response>])

                    ))

                }

            }

        }

    };

}

macro_rules! multi_item_command_response {

    ($name:ident, $item_name:expr, $item_type:ty) => {

        paste::paste! {

            #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]

            pub struct [<$name Response>] (pub Vec<$item_type>);

        }

        impl paste::paste! { [<$name Response>] } {

                paste::paste! {

                }

        }

        impl crate::commands::CommandResponse for paste::paste! { [<$name Response>] } {

            type Request = paste::paste! { [<$name Request>] };

                // TODO: use lazy vec

                }

                paste::paste! {

                        "response serialization is not yet implemented for ",

                        stringify!([<$name Response>])

                    ))

                }

            }

        }

    };

}

pub(crate) use empty_command_request;

pub(crate) use empty_command_response;

pub(crate) use multi_item_command_response;

pub(crate) use single_item_command_request;

pub(crate) use single_item_command_response;

pub(crate) use single_optional_item_command_request;

#[derive(Error, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]

pub enum RequestParserError {

    #[error("Found empty line while parsing request")]

    EmptyLine,

    // TODO: remove this, replaced by various other errors

    #[error("Could not parse the request due to a syntax error at position {0}: {1}")]

    SyntaxError(u64, String),

    // TODO: can we store the parser error as well?

    #[error(

        "Could not parse argument {argument_index} of the request (expected type: {expected_type}, raw input: '{raw_input}')"

    )]

    SubtypeParserError {

        /// The index of the argument that failed to parse

        ///

        /// Note that in the case of keyworded arguments, such as

        /// `group <groupname>`, `sort <sorting>`, etc., these are

        /// counted as a single argument despite being two tokens.

        argument_index: u32,

        /// The expected type of the argument

        expected_type: &'static str,

        /// The raw input that failed to parse

        raw_input: String,

    },

    #[error(

        "Too many arguments were provided in the request (expected between {expected_min} and {expected_max:?}, found {found})"

    )]

    TooManyArguments {

        /// The minimum number of arguments that were expected

        expected_min: u32,

        /// The maximum number of arguments that were expected

        ///

        /// This is `None` if the amount of arguments is unbounded.

        expected_max: Option<u32>,

        /// The number of arguments that were found

        ///

        /// Note that in the case of keyworded arguments, such as

        /// `group <groupname>`, `sort <sorting>`, etc., these are

        /// counted as a single argument despite being two tokens.

        found: u32,

    },

    #[error(

        "Not enough arguments were provided in the request (expected between {expected_min} and {expected_max:?}, found {found})"

    )]

    MissingArguments {

        /// The minimum number of arguments that were expected

        expected_min: u32,

        /// The maximum number of arguments that were expected.

        ///

        /// This is `None` if the amount of arguments is unbounded.

        expected_max: Option<u32>,

        /// The number of arguments that were found

        ///

        /// Note that in the case of keyworded arguments, such as

        /// `group <groupname>`, `sort <sorting>`, etc., these are

        /// counted as a single argument despite being two tokens.

        found: u32,

    },

    #[error("Keyword argument {keyword} at position {argument_index} is missing its value")]

    MissingKeywordValue {

        /// The unexpected keyword that was found

        keyword: &'static str,

        /// The index of the argument that was missing it's value

        ///

        /// Note that in the case of keyworded arguments, such as

        /// `group <groupname>`, `sort <sorting>`, etc., these are

        /// counted as a single argument despite being two tokens.

        argument_index: u32,

    },

    #[error("A command list was expected to be closed, but the end was not found")]

    MissingCommandListEnd,

    #[error("A command list was found inside another command list at line {line}")]

    NestedCommandList {

        /// The line where the nested command list was found

        line: u32,

    },

    #[error("An unexpected command list end was found")]

    UnexpectedCommandListEnd,

    // TODO: remove this, replaced by EmptyLine + MissingArguments

    #[error("Request ended early, while more arguments were expected")]

    UnexpectedEOF,

    #[error("Request is missing terminating newline")]

    MissingNewline,

}

// TODO: should these be renamed to fit the mpd docs?

//       "Attribute" instead of "Property"?

#[derive(Error, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]

pub enum ResponseParserError {

    #[error("A property was expected to be present in the response, but was not found: {0}")]

    MissingProperty(String),

    // TODO: change name to UnexpectedPropertyEncoding

    #[error(

        "An expected property was found in the response, but its encoding was not as expected: {0}: {1}"

    )]

    UnexpectedPropertyType(String, String),

    #[error("A property was found in the response that was not expected: {0}")]

    UnexpectedProperty(String),

    #[error("A property was found multiple times in the response, but was only expected once: {0}")]

    DuplicateProperty(String),

    #[error("The property value is parsable, but the value is invalid or nonsensical: {0}: {1}")]

    InvalidProperty(String, String),

    #[error("Could not parse the response due to a syntax error at position {0}: {1}")]

    SyntaxError(u64, String),

    #[error("Response ended early, while more properties were expected")]

    UnexpectedEOF,

    // #[error("Response is missing terminating newline")]

    // MissingNewline,

}

/*******************/

pub const COMMAND_NAMES: &[&str] = &[

    // Audio output devices

    DisableOutputRequest::COMMAND,

    EnableOutputRequest::COMMAND,

    OutputsRequest::COMMAND,

    OutputSetRequest::COMMAND,

    ToggleOutputRequest::COMMAND,

    // Client to client

    ChannelsRequest::COMMAND,

    ReadMessagesRequest::COMMAND,

    SendMessageRequest::COMMAND,

    SubscribeRequest::COMMAND,

    UnsubscribeRequest::COMMAND,

    // Connection settings

    BinaryLimitRequest::COMMAND,

    CloseRequest::COMMAND,

    KillRequest::COMMAND,

    PasswordRequest::COMMAND,

    PingRequest::COMMAND,

    ProtocolRequest::COMMAND,

    ProtocolAllRequest::COMMAND,

    ProtocolAvailableRequest::COMMAND,

    ProtocolClearRequest::COMMAND,

    ProtocolDisableRequest::COMMAND,

    ProtocolEnableRequest::COMMAND,

    TagTypesRequest::COMMAND,

    TagTypesAllRequest::COMMAND,

    TagTypesAvailableRequest::COMMAND,

    TagTypesClearRequest::COMMAND,

    TagTypesDisableRequest::COMMAND,

    TagTypesEnableRequest::COMMAND,

    TagTypesResetRequest::COMMAND,

    // Controlling playback

    NextRequest::COMMAND,

    PauseRequest::COMMAND,

    PlayRequest::COMMAND,

    PlayIdRequest::COMMAND,

    PreviousRequest::COMMAND,

    SeekRequest::COMMAND,

    SeekCurRequest::COMMAND,

    SeekIdRequest::COMMAND,

    StopRequest::COMMAND,

    // Mounts and neighbors

    ListMountsRequest::COMMAND,

    ListNeighborsRequest::COMMAND,

    MountRequest::COMMAND,

    UnmountRequest::COMMAND,

    // Music database

    AlbumArtRequest::COMMAND,

    CountRequest::COMMAND,

    FindRequest::COMMAND,

    FindAddRequest::COMMAND,

    GetFingerprintRequest::COMMAND,

    ListRequest::COMMAND,

    ListAllRequest::COMMAND,

    ListAllInfoRequest::COMMAND,

    ListFilesRequest::COMMAND,

    LsInfoRequest::COMMAND,

    ReadCommentsRequest::COMMAND,

    ReadPictureRequest::COMMAND,

    RescanRequest::COMMAND,

    SearchRequest::COMMAND,

    SearchAddRequest::COMMAND,

    SearchAddPlRequest::COMMAND,

    SearchCountRequest::COMMAND,

    UpdateRequest::COMMAND,

    // Partition commands

    DelPartitionRequest::COMMAND,

    ListPartitionsRequest::COMMAND,

    MoveOutputRequest::COMMAND,

    NewPartitionRequest::COMMAND,

    PartitionRequest::COMMAND,

    // Playback options

    ConsumeRequest::COMMAND,

    CrossfadeRequest::COMMAND,

    GetVolRequest::COMMAND,

    MixRampDbRequest::COMMAND,

    MixRampDelayRequest::COMMAND,

    RandomRequest::COMMAND,

    RepeatRequest::COMMAND,

    ReplayGainModeRequest::COMMAND,

    ReplayGainStatusRequest::COMMAND,

    SetVolRequest::COMMAND,

    SingleRequest::COMMAND,

    VolumeRequest::COMMAND,

    // Querying mpd status

    ClearErrorRequest::COMMAND,

    CurrentSongRequest::COMMAND,

    IdleRequest::COMMAND,

    StatsRequest::COMMAND,

    StatusRequest::COMMAND,

    // Queue

    AddRequest::COMMAND,

    AddIdRequest::COMMAND,

    AddTagIdRequest::COMMAND,

    ClearRequest::COMMAND,

    ClearTagIdRequest::COMMAND,

    DeleteRequest::COMMAND,

    DeleteIdRequest::COMMAND,

    MoveRequest::COMMAND,

    MoveIdRequest::COMMAND,

    PlaylistRequest::COMMAND,

    PlaylistFindRequest::COMMAND,

    PlaylistIdRequest::COMMAND,

    PlaylistInfoRequest::COMMAND,

    PlaylistSearchRequest::COMMAND,

    PlChangesRequest::COMMAND,

    PlChangesPosIdRequest::COMMAND,

    PrioRequest::COMMAND,

    PrioIdRequest::COMMAND,

    RangeIdRequest::COMMAND,

    ShuffleRequest::COMMAND,

    SwapRequest::COMMAND,

    SwapIdRequest::COMMAND,

    // Reflection

    CommandsRequest::COMMAND,

    ConfigRequest::COMMAND,

    DecodersRequest::COMMAND,

    NotCommandsRequest::COMMAND,

    UrlHandlersRequest::COMMAND,

    // Stickers

    StickerDecRequest::COMMAND,

    StickerDeleteRequest::COMMAND,

    StickerFindRequest::COMMAND,

    StickerGetRequest::COMMAND,

    StickerIncRequest::COMMAND,

    StickerListRequest::COMMAND,

    StickerSetRequest::COMMAND,

    StickerNamesRequest::COMMAND,

    StickerNamesTypesRequest::COMMAND,

    StickerTypesRequest::COMMAND,

    // Stored playlists

    ListPlaylistRequest::COMMAND,

    ListPlaylistInfoRequest::COMMAND,

    ListPlaylistsRequest::COMMAND,

    LoadRequest::COMMAND,

    PlaylistAddRequest::COMMAND,

    PlaylistClearRequest::COMMAND,

    PlaylistDeleteRequest::COMMAND,

    PlaylistLengthRequest::COMMAND,

    PlaylistMoveRequest::COMMAND,

    RenameRequest::COMMAND,

    RmRequest::COMMAND,

    SaveRequest::COMMAND,

    SearchPlaylistRequest::COMMAND,

];