//! The core API for interacting with [`Mpv`].

use futures::StreamExt;

use serde::{Deserialize, Serialize};

use serde_json::Value;

use std::{collections::HashMap, fmt};

use tokio::{

    net::UnixStream,

    sync::{broadcast, mpsc, oneshot},

};

use crate::{

    ipc::{MpvIpc, MpvIpcCommand, MpvIpcEvent, MpvIpcResponse},

    message_parser::TypeHandler,

    Event, MpvError,

};

/// All possible commands that can be sent to mpv.

///

/// Not all commands are guaranteed to be implemented.

/// If something is missing, please open an issue.

///

/// You can also use the `run_command_raw` function to run commands

/// that are not implemented here.

///

/// See <https://mpv.io/manual/master/#list-of-input-commands> for

/// the upstream list of commands.

#[derive(Debug, Clone, Serialize, Deserialize)]

pub enum MpvCommand {

    /// Load the given file or URL and play it.

    LoadFile {

        file: String,

        option: PlaylistAddOptions,

    },

    /// Load the given playlist file or URL.

    LoadList {

        file: String,

        option: PlaylistAddOptions,

    },

    /// Clear the playlist, except for the currently playing file.

    PlaylistClear,

    ///Move the playlist entry at `from`, so that it takes the place of the entry `to`.

    /// (Paradoxically, the moved playlist entry will not have the index value `to` after moving

    /// if `from` was lower than `to`, because `to` refers to the target entry, not the index

    /// the entry will have after moving.)

    PlaylistMove { from: usize, to: usize },

    /// Observe a property. This will start triggering [`Event::PropertyChange`] events

    /// in the event stream whenever the specific property changes.

    /// You can use [`Mpv::get_event_stream`] to get the stream.

    Observe { id: u64, property: String },

    /// Skip to the next entry in the playlist.

    PlaylistNext,

    /// Skip to the previous entry in the playlist.

    PlaylistPrev,

    /// Remove an entry from the playlist by its position in the playlist.

    PlaylistRemove(usize),

    /// Shuffle the playlist

    PlaylistShuffle,

    /// Exit the player

    Quit,

    /// Send a message to all clients, and pass it the following list of arguments.

    /// What this message means, how many arguments it takes, and what the arguments

    /// mean is fully up to the receiver and the sender.

    ScriptMessage(Vec<String>),

    /// Same as [`MpvCommand::ScriptMessage`], but send the message to a specific target.

    ScriptMessageTo { target: String, args: Vec<String> },

    /// Change the playback position.

    Seek { seconds: f64, option: SeekOptions },

    /// Stop the current playback, and clear the playlist.

    /// This esentially resets the entire player state without exiting mpv.

    Stop,

    /// Unobserve all properties registered with the given id.

    /// See [`MpvCommand::Observe`] for more context.

    Unobserve(u64),

}

/// Helper trait to keep track of the string literals that mpv expects.

pub(crate) trait IntoRawCommandPart {

    fn into_raw_command_part(self) -> String;

}

/// Generic data type representing all possible data types that mpv can return.

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

#[serde(untagged)]

pub enum MpvDataType {

    Array(Vec<MpvDataType>),

    Bool(bool),

    Double(f64),

    HashMap(HashMap<String, MpvDataType>),

    Null,

    MinusOne,

    Playlist(Playlist),

    String(String),

    Usize(usize),

}

/// A mpv playlist.

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

pub struct Playlist(pub Vec<PlaylistEntry>);

/// A single entry in the mpv playlist.

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

pub struct PlaylistEntry {

    pub id: usize,

    pub filename: String,

    pub title: Option<String>,

    pub current: bool,

}

/// Options for [`MpvCommand::LoadFile`] and [`MpvCommand::LoadList`].

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]

pub enum PlaylistAddOptions {

    Replace,

    Append,

}

impl IntoRawCommandPart for PlaylistAddOptions {

        }

}

/// Options for [`MpvCommand::Seek`].

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]

pub enum SeekOptions {

    Relative,

    Absolute,

    RelativePercent,

    AbsolutePercent,

}

impl IntoRawCommandPart for SeekOptions {

        }

}

/// A trait for specifying how to extract and parse a value returned through [`Mpv::get_property`].

pub trait GetPropertyTypeHandler: Sized {

    // TODO: fix this

    #[allow(async_fn_in_trait)]

    async fn get_property_generic(instance: &Mpv, property: &str)

        -> Result<Option<Self>, MpvError>;

}

impl<T> GetPropertyTypeHandler for T

where

    T: TypeHandler,

{

}

/// A trait for specifying how to serialize and set a value through [`Mpv::set_property`].

pub trait SetPropertyTypeHandler<T> {

    // TODO: fix this

    #[allow(async_fn_in_trait)]

    async fn set_property_generic(instance: &Mpv, property: &str, value: T)

        -> Result<(), MpvError>;

}

impl<T> SetPropertyTypeHandler<T> for T

where

    T: Serialize,

{

        }

}

/// The main struct for interacting with mpv.

///

/// This struct provides the core API for interacting with mpv.

/// These functions are the building blocks for the higher-level API provided by the `MpvExt` trait.

/// They can also be used directly to interact with mpv in a more flexible way, mostly returning JSON values.

///

/// The `Mpv` struct can be cloned freely, and shared anywhere.

/// It only contains a message passing channel to the tokio task that handles the IPC communication with mpv.

#[derive(Clone)]

pub struct Mpv {

    command_sender: mpsc::Sender<(MpvIpcCommand, oneshot::Sender<MpvIpcResponse>)>,

    broadcast_channel: broadcast::Sender<MpvIpcEvent>,

}

// TODO: Can we somehow provide a more useful Debug implementation?

impl fmt::Debug for Mpv {

}

impl Mpv {

    /// Connect to a unix socket, hosted by mpv, at the given path.

    /// This is the inteded way of creating a new [`Mpv`] instance.

    /// Connect to an existing [`UnixStream`].

    /// This is an alternative to [`Mpv::connect`], if you already have a [`UnixStream`] available.

    ///

    /// Internally, this is used for testing purposes.

    /// Disconnect from the mpv socket.

    ///

    /// Note that this will also kill communication for all other clones of this instance.

    /// It will not kill the mpv process itself - for that you should use [`MpvCommand::Quit`]

    /// or run [`MpvExt::kill`](crate::MpvExt::kill).

        }

    /// Create a new stream, providing [`Event`]s from mpv.

    ///

    /// This is intended to be used with [`MpvCommand::Observe`] and [`MpvCommand::Unobserve`]

    /// (or [`MpvExt::observe_property`] and [`MpvExt::unobserve_property`] respectively).

    /// Run a custom command.

    /// This should only be used if the desired command is not implemented

    /// with [`MpvCommand`].

        }

    /// Helper function to ignore the return value of a command, and only check for errors.

    /// # Description

    ///

    /// Runs mpv commands. The arguments are passed as a String-Vector reference:

    ///

    /// ## Input arguments

    ///

    /// - **command**   defines the mpv command that should be executed

    /// - **args**      a slice of `&str`'s which define the arguments

    ///

    /// # Example

    /// ```

    /// use mpvipc_async::{Mpv, MpvError};

    ///

    /// #[tokio::main]

    /// async fn main() -> Result<(), MpvError> {

    ///     let mpv = Mpv::connect("/tmp/mpvsocket").await?;

    ///

    ///     //Run command 'playlist-shuffle' which takes no arguments

    ///     mpv.run_command(MpvCommand::PlaylistShuffle).await?;

    ///

    ///     //Run command 'seek' which in this case takes two arguments

    ///     mpv.run_command(MpvCommand::Seek {

    ///         seconds: 0f64,

    ///         option: SeekOptions::Absolute,

    ///     }).await?;

    ///     Ok(())

    /// }

    /// ```

            }

            }

                }

            }

            MpvCommand::PlaylistClear => {

            }

            }

            MpvCommand::PlaylistNext => {

            }

            MpvCommand::PlaylistPrev => {

            }

            }

            MpvCommand::PlaylistShuffle => {

            }

            }

            }

            }

                }

            }

        };

    /// # Description

    ///

    /// Retrieves the property value from mpv.

    ///

    /// ## Supported types

    /// - `String`

    /// - `bool`

    /// - `HashMap<String, String>` (e.g. for the 'metadata' property)

    /// - `Vec<PlaylistEntry>` (for the 'playlist' property)

    /// - `usize`

    /// - `f64`

    ///

    /// ## Input arguments

    ///

    /// - **property** defines the mpv property that should be retrieved

    ///

    /// # Example

    /// ```

    /// use mpvipc_async::{Mpv, MpvError};

    ///

    /// #[tokio::main]

    /// async fn main() -> Result<(), MpvError> {

    ///     let mpv = Mpv::connect("/tmp/mpvsocket").await?;

    ///     let paused: bool = mpv.get_property("pause").await?;

    ///     let title: String = mpv.get_property("media-title").await?;

    ///     Ok(())

    /// }

    /// ```

    /// # Description

    ///

    /// Retrieves the property value from mpv.

    /// The result is always of type String, regardless of the type of the value of the mpv property

    ///

    /// ## Input arguments

    ///

    /// - **property** defines the mpv property that should be retrieved

    ///

    /// # Example

    ///

    /// ```

    /// use mpvipc_async::{Mpv, MpvError};

    ///

    /// #[tokio::main]

    /// async fn main() -> Result<(), MpvError> {

    ///     let mpv = Mpv::connect("/tmp/mpvsocket").await?;

    ///     let title = mpv.get_property_string("media-title").await?;

    ///     Ok(())

    /// }

    /// ```

        }

    /// # Description

    ///

    /// Sets the mpv property _`<property>`_ to _`<value>`_.

    ///

    /// ## Supported types

    /// - `String`

    /// - `bool`

    /// - `f64`

    /// - `usize`

    ///

    /// ## Input arguments

    ///

    /// - **property** defines the mpv property that should be retrieved

    /// - **value** defines the value of the given mpv property _`<property>`_

    ///

    /// # Example

    /// ```

    /// use mpvipc_async::{Mpv, MpvError};

    /// async fn main() -> Result<(), MpvError> {

    ///     let mpv = Mpv::connect("/tmp/mpvsocket").await?;

    ///     mpv.set_property("pause", true).await?;

    ///     Ok(())

    /// }

    /// ```

}