use serde::{Deserialize, Deserializer};

use chrono::{DateTime, Utc};
use colored::*;

use crate::serde::*;
use crate::traits::IsStation;

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Station {
  name: String,
  pub ds100: String,
  uic: u64,
  latitude: f64,
  longitude: f64,
  #[serde(deserialize_with = "naive_read_unixtime")]
  scheduled_time: DateTime<Utc>,
  #[serde(deserialize_with = "naive_read_unixtime")]
  real_time: DateTime<Utc>
}

pub fn parse_optional_station<'de, D>(d: D) -> Result<Option<Station>, D::Error>
where
  D: Deserializer<'de>
{
  let val = <serde_json::Value>::deserialize(d)?;
  match serde_json::from_value(val) {
    Ok(station) => Ok(Some(station)),
    Err(_) => Ok(None)
  }
}

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Stop {
  name: String,
  #[serde(deserialize_with = "option_naive_read_unixtime")]
  scheduled_arrival: Option<DateTime<Utc>>,
  #[serde(deserialize_with = "option_naive_read_unixtime")]
  real_arrival: Option<DateTime<Utc>>,
  #[serde(deserialize_with = "option_naive_read_unixtime")]
  scheduled_departure: Option<DateTime<Utc>>,
  #[serde(deserialize_with = "option_naive_read_unixtime")]
  real_departure: Option<DateTime<Utc>>
}

impl IsStation for Station {
  fn name(&self) -> &str {
    &self.name
  }
  fn scheduled_arrival(&self) -> Option<&DateTime<Utc>> {
    Some(&self.scheduled_time)
  }
  fn real_arrival(&self) -> Option<&DateTime<Utc>> {
    Some(&self.real_time)
  }

  fn ds100(&self) -> &str {
    &self.ds100
  }
}

impl IsStation for Stop {
  fn name(&self) -> &str {
    &self.name
  }
  fn scheduled_arrival(&self) -> Option<&DateTime<Utc>> {
    self.scheduled_arrival.as_ref()
  }
  fn real_arrival(&self) -> Option<&DateTime<Utc>> {
    self.real_arrival.as_ref()
  }

  fn ds100(&self) -> &str {
    "[??]"
  }
}

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Train {
  #[serde(rename = "type")]
  pub _type: String,
  pub line: Option<String>,
  pub no: String,
  pub id: String
}

impl std::fmt::Display for Train {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "{} {}", self._type, self.no)
  }
}

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Status {
  deprecated: bool,
  pub checked_in: bool,
  pub from_station: Station,
  #[serde(deserialize_with = "parse_optional_station")]
  pub to_station: Option<Station>,
  intermediate_stops: Vec<Stop>,
  pub train: Option<Train>,
  action_time: u64
}

#[allow(dead_code)]
pub struct Ds100 {
  inner: String
}

/// this type is a little silly, but apparently there's no better way
/// to 'forget' what the concrete type is than re-constructing the vec?
pub struct Trip<'a>(Vec<&'a dyn IsStation>);

impl std::fmt::Display for Trip<'_> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    if self.0.len() != 0 {
      self
        .0
        .iter()
        .map(|stop| stop.to_fancy_string())
        .for_each(|l| writeln!(f, "  {}\n    ↓", l).unwrap());
    }
    Ok(())
  }
}

/// with this, you sometimes have to write (&self.stops).into()
/// yay for reference syntax!
impl<'a, S: IsStation + 'a> From<&'a Vec<S>> for Trip<'a> {
  fn from(from: &'a Vec<S>) -> Self {
    Trip(from.iter().map(|s| s as &dyn IsStation).collect())
  }
}

impl std::fmt::Display for Status {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    match self.checked_in {
      false => write!(
        f,
        "not checked in. \n\n\
                 last trip: \n  {}  {}",
        self.from_station.to_fancy_string(),
        self.to_station.as_ref().unwrap().to_fancy_string()
      ),
      true => write!(
        f,
        "checked in to: {}.\n\n\
                 stops:\n  {}\n    ↓\n{}  {}",
        self
          .train
          .as_ref()
          .map(|t| t.to_string())
          .unwrap_or("".to_string())
          .green(),
        self.from_station.to_fancy_string(),
        Trip::from(&self.intermediate_stops),
        self
          .to_station
          .as_ref()
          .map(|s| s.to_fancy_string())
          .unwrap_or_else(|| "🚄 Fahrt ins Blaue".blue().to_string())
      )
    }
  }
}