use std::fmt::{Debug, Display};

use anyhow::Result;
use chrono::{DateTime, Local, TimeZone, Utc};
use serde::{de, Deserialize, Deserializer};

#[derive(Deserialize, Debug)]
#[serde(rename_all = "PascalCase")]
pub struct Departure {
    line_name: String,
    direction: String,
    #[serde(default, deserialize_with = "deserialize_realtime")]
    real_time: Option<DateTime<Local>>,
    #[serde(deserialize_with = "deserialize_timestamp")]
    scheduled_time: DateTime<Local>,
}

#[derive(Deserialize, Debug)]
#[serde(rename_all = "PascalCase")]
pub struct Response {
    pub departures: Vec<Departure>,
}

/// Deserialize a timestamp in the form of '/Date(1671713820000-0000)/'
fn deserialize_timestamp<'de, D>(deserializer: D) -> Result<DateTime<Local>, D::Error>
where
    D: Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    let timestamp: i64 = s
        .trim_start_matches("/Date(")
        .trim_end_matches(")/")
        .split('-')
        .next()
        .ok_or_else(|| de::Error::custom("Invalid timestamp format"))?
        .parse()
        .map_err(de::Error::custom)?;
    let result = Utc.timestamp_millis_opt(timestamp).unwrap();

    let local_tz = chrono::offset::Local::now().timezone();
    Ok(result.with_timezone(&local_tz))
}

fn deserialize_realtime<'de, D>(deserializer: D) -> Result<Option<DateTime<Local>>, D::Error>
where
    D: Deserializer<'de>,
{
    match deserialize_timestamp(deserializer) {
        Ok(inner) => Ok(Some(inner)),
        Err(_) => Ok(None),
    }
}

impl Display for Departure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("{} {}\n", &self.line_name, &self.direction))?;

        let scheduled_time = self.scheduled_time.format("%H:%M");
        f.write_str(&format!("departure: {}", &scheduled_time))?;

        if let Some(real_time) = self.real_time {
            let actual_time = real_time.format("%H:%M");
            if real_time != self.scheduled_time {
                f.write_str(&format!(" | delayed: {actual_time} "))?;
            }
        }
        Ok(())
    }
}

pub fn format_departures(response: Response) -> String {
    let departures: Vec<String> = response.departures.iter().map(|d| d.to_string()).collect();
    departures.join("\n\n")
}