use helpers::*;
use serde::Deserialize;
use std::time::Duration;

#[derive(Deserialize, Clone, Debug, Default, PartialEq)]
#[serde(default)]
pub struct Track {
  pub file:                       String,
  #[serde(rename = "artistsort")]
  pub artist_sort:                Option<String>,
  #[serde(rename = "albumartist")]
  pub album_artist:               Option<String>,
  #[serde(rename = "albumsort")]
  pub album_sort:                 Option<String>,
  #[serde(rename = "albumartistsort")]
  pub album_artist_sort:          Option<String>,
  #[serde(deserialize_with = "de_string_or_vec")]
  #[serde(rename = "performer")]
  pub performers:                 Vec<String>,
  pub genre:                      Option<String>,
  pub title:                      Option<String>,
  #[serde(deserialize_with = "de_position")]
  pub track:                      Option<Position>,
  pub album:                      Option<String>,
  pub artist:                     Option<String>,
  pub pos:                        u32,
  pub id:                         u32,
  // TODO: use proper time here
  #[serde(rename = "last-modified")]
  pub last_modified:              Option<String>,
  #[serde(rename = "originaldate")]
  pub original_date:              Option<u16>,
  // probably not needed. it’s just the duration but as an int
  // pub time: u16,
  pub format:                     Option<String>,
  #[serde(deserialize_with = "de_time_float")]
  pub duration:                   Duration,
  pub label:                      Option<String>,
  pub date:                       Option<u16>,
  #[serde(deserialize_with = "de_position")]
  pub disc:                       Option<Position>,
  pub musicbraiz_trackid:         Option<String>,
  pub musicbrainz_albumid:        Option<String>,
  pub musicbrainz_albumartistid:  Option<String>,
  pub musicbrainz_artistid:       Option<String>,
  pub musicbrainz_releasetrackid: Option<String>,
  pub musicbrainz_trackid:        Option<String>,
  pub composer:                   Option<String>,
}

/// The position of an item in a list with an optional total length.
/// Can be used for e.g. track number,
/// where `Position { 3, 12 }` represents track 3 of a CD with 12 tracks,
/// or disc numbers in a multi-disc set.
#[derive(Deserialize, Clone, Debug, Default, PartialEq)]
pub struct Position {
  pub item_position: u16,
  pub total_items:   Option<u16>,
}

/// Deserialization helpers to handle the quirks of mpd’s output.
mod helpers {
  use super::*;
  use crate::SEPARATOR;
  use serde::{de, Deserialize};
  use std::{str::FromStr, time::Duration};

  /// Deserialize time from an integer that represents the seconds.
  /// mpd uses int for the database stats (e.g. total time played).
  pub fn de_time_int<'de, D>(deserializer: D) -> Result<Duration, D::Error>
  where D: de::Deserializer<'de> {
    u64::deserialize(deserializer).map(Duration::from_secs)
  }

  /// Deserialize time from a float that represents the seconds.
  /// mpd uses floats for the current status (e.g. time elapsed in song).
  pub fn de_time_float<'de, D>(deserializer: D) -> Result<Duration, D::Error>
  where D: de::Deserializer<'de> {
    f64::deserialize(deserializer).map(Duration::from_secs_f64)
  }

  pub fn de_string_or_vec<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
  where D: de::Deserializer<'de> {
    String::deserialize(deserializer).map(|s| s.split(SEPARATOR).map(std::string::String::from).collect())
  }

  /// mpd uses bints (0 or 1) to represent booleans,
  /// so we need a special parser for those.
  pub fn de_bint<'de, D>(deserializer: D) -> Result<bool, D::Error>
  where D: de::Deserializer<'de> {
    match u8::deserialize(deserializer)? {
      0 => Ok(false),
      1 => Ok(true),
      n => Err(de::Error::invalid_value(de::Unexpected::Unsigned(n as u64), &"zero or one")),
    }
  }

  /// Deserialize a position with an optional total length.
  /// The input string here is either a number or two numbers separated by `SEPARATOR`.
  pub fn de_position<'de, D>(deserializer: D) -> Result<Option<Position>, D::Error>
  where D: de::Deserializer<'de> {
    let s = String::deserialize(deserializer)?;
    let mut ints = s.split(SEPARATOR).filter_map(|s| u16::from_str(s).ok());
    if let Some(n) = ints.next() {
      return Ok(Some(Position {
        item_position: n,
        total_items:   ints.next(),
      }));
    }
    Ok(None)
  }
}