//! 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.

pub enum MpvCommand {

    LoadFile {

        file: String,

        option: PlaylistAddOptions,

    },

    LoadList {

        file: String,

        option: PlaylistAddOptions,

    },

    PlaylistClear,

    PlaylistMove {

        from: usize,

        to: usize,

    },

    Observe {

        id: usize,

        property: String,

    },

    PlaylistNext,

    PlaylistPrev,

    PlaylistRemove(usize),

    PlaylistShuffle,

    Quit,

    ScriptMessage(Vec<String>),

    ScriptMessageTo {

        target: String,

        args: Vec<String>,

    },

    Seek {

        seconds: f64,

        option: SeekOptions,

    },

    Stop,

    Unobserve(usize),

}

/// 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.

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.

pub struct Playlist(pub Vec<PlaylistEntry>);

/// A single entry in the mpv playlist.

pub struct PlaylistEntry {

    pub id: usize,

    pub filename: String,

    pub title: String,

    pub current: bool,

}

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

pub enum PlaylistAddOptions {

    Replace,

    Append,

}

impl IntoRawCommandPart for PlaylistAddOptions {

        }

}

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

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<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::{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::{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::{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::{Mpv, MpvError};

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

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

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

    ///     Ok(())

    /// }

    /// ```

}