#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate horrorshow;
#[macro_use]
extern crate lazy_static;

use chrono::{Datelike, Utc};
use chrono_tz::America::New_York;
use fluent::{FluentArgs, FluentValue};
use geo_types::{Latitude, Longitude};
use horrorshow::helper::doctype;
use horrorshow::prelude::*;
use international_fixed_calendar as IFC;
use std::{
    borrow::Cow,
    net::{IpAddr, Ipv4Addr, SocketAddr},
    sync::Arc,
};
use warp::{reply::Html, Filter, Rejection};

mod soluna_client;
use soluna_client::{SolunaClient, SunMoon};

mod solstices;
use solstices::{Event, Solstices, EVENTS};

const EO_TEXT: &'static str = "
day = {$day ->
    *[Sunday] Dimanĉo
    [Monday] Lundo
    [Tuesday] Mardo
    [Wednesday] Merkredo
    [Thursday] Ĵaŭdo
    [Friday] Vendredo
    [Saturday] Sabato
    [LeapDay] Leap Day
    [YearDay] Year Day
}
month = {$month ->
    *[January] Januaro
    [February] Februaro
    [March] Marto
    [April] Aprilo
    [May] Mayo
    [June] Junio
    [Sol] Solo
    [July] Julio
    [August] Aŭgusto
    [September] Septembro
    [October] Oktobro
    [November] Novembro
    [December] Decembro
}
spring_equinox = Printempa Ekvinokso
summer_solstice = Somera Solstico
autumn_equinox = Aŭtuna Ekvinokso
winter_solstice = Vintra Solstico
";

fn date(fluent: Arc<fluent_ergonomics::FluentErgo>, today: IFC::IFC) -> impl Render {
    let mut day_args = FluentArgs::new();
    day_args.set(
        "day",
        FluentValue::String(Cow::Owned(String::from(today.weekday_ifc()))),
    );
    let tago = fluent.tr("tago", Some(&day_args)).unwrap();

    let mut month_args = FluentArgs::new();
    month_args.set(
        "month",
        FluentValue::String(Cow::Owned(String::from(today.month_ifc()))),
    );
    let monato = fluent.tr("month", Some(&month_args)).unwrap();

    owned_html! {p : format!("{}, {} {}, {}", tago, monato, today.day(), today.year());}
}

fn soluna_desegno(sun_moon: SunMoon) -> impl Render {
    owned_html! {
        table {
            tr {
                th : "Sunleviĝo";
                th : "Sunfalo";
                th : "Lunleviĝo";
                th : "Lunfalo";
            }
            tr {
                td : format!("{}", sun_moon.sunleviĝo.format("%H:%M"));
                td : format!("{}", sun_moon.sunfalo.format("%H:%M"));
                td : sun_moon.lunleviĝo.map(|v| format!("{}", v.format("%H:%M"))).unwrap_or("".to_string());
                td : sun_moon.lunfalo.map(|v| format!("{}", v.format("%H:%M"))).unwrap_or("".to_string());
                td : format!("{:?}", sun_moon.lunfazo);
            }
        }
    }
}

fn astronomia_eventa_desegno(
    fluent: Arc<fluent_ergonomics::FluentErgo>,
    event: Option<Event>,
) -> impl Render {
    let s = match event {
        None => "".to_owned(),
        Some(event) => {
            let eventa_str = match event {
                Event::SpringEquinox(_) => fluent.tr("printempa_ekvinokso", None),
                Event::SummerSolstice(_) => fluent.tr("somera_solstico", None),
                Event::AutumnEquinox(_) => fluent.tr("auxtuna_ekvinokso", None),
                Event::WinterSolstice(_) => fluent.tr("vintra_solstico", None),
            }
            .unwrap();
            format!("{} {}", eventa_str, event.date().format("%Y-%m-%d"))
        }
    };
    owned_html! {
        div : s.clone();
    }
}

fn page_template(
    fluent: Arc<fluent_ergonomics::FluentErgo>,
    today: IFC::IFC,
    sun_moon: SunMoon,
    event: Option<solstices::Event>,
) -> String {
    format!(
        "{}",
        html! {
            : doctype::HTML;
            html {
                head {
                    title: "Superrigardo";
                }
                body {
                    h1(id="heading", class="title") : date(fluent.clone(), today);
                    div : soluna_desegno(sun_moon.clone());
                    div : astronomia_eventa_desegno(fluent.clone(), event);
                    // div : cirklo();
                }
            }
        }
    )
}

async fn page(
    fluent: Arc<fluent_ergonomics::FluentErgo>,
    solar_client: Arc<SolunaClient>,
    latitude: Latitude,
    longitude: Longitude,
) -> Result<Html<String>, Rejection> {
    let now = Utc::now();
    let d = IFC::IFC::from(now.with_timezone(&New_York).date());
    let sun_moon = solar_client
        .request(latitude, longitude, now.with_timezone(&New_York).date())
        .await;
    let next_event = EVENTS.next_event(now);
    Ok(warp::reply::html(page_template(
        fluent, d, sun_moon, next_event,
    )))
}

#[tokio::main]
pub async fn main() {
    /*
    let latitudo = Latitude::from(41.78);
    let longitudo = Longitude::from(-71.41);
    let eo_id = "eo".parse::<unic_langid::LanguageIdentifier>().unwrap();
    let mut fluent = fluent_ergonomics::FluentErgo::new(&[eo_id.clone()]);
    let solar_client = Arc::new(SolunaClient::new());

    fluent.add_from_text(eo_id, EO_TEXT.to_owned()).unwrap();
    let fluent = Arc::new(fluent);

    let pageview = {
        warp::path::end().and_then(move || {
            page(
                fluent.clone(),
                solar_client.clone(),
                latitudo.clone(),
                longitudo.clone(),
            )
        })
    };

    let server = warp::serve(paĝvojo);
    server
        .run(SocketAddr::new(
            IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
            8000,
        ))
        .await;
    */
}