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,
  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")]
  _type: String,
  line: Option<String>,
  no: String,
  id: String
}

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

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

pub struct Trip<'a, 'i, S: IsStation>(
  pub &'i mut dyn std::iter::Iterator<Item = &'a S>
);

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

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

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(&mut self.intermediate_stops.iter()),
        self
          .to_station
          .as_ref()
          .map(|s| s.to_fancy_string())
          .unwrap_or_else(|| "🚄 Fahrt ins Blaue".blue().to_string())
      )
    }
  }
}