use axum::{
    extract::{Form, Path, State},
    http::StatusCode,
    response::{
        sse::{self, Sse},
        IntoResponse, Redirect,
    },
    routing::{get, post},
    Router,
};
use axum_extra::TypedHeader;
use chrono::{format::SecondsFormat, DateTime};
use futures::{future, stream::TryStreamExt as _};

use super::{
    header::LastEventId,
    repo::{channels::Id as ChannelId, messages::BroadcastMessage},
};
use crate::{
    app::App, clock::RequestedAt, error::BoxedError, error::InternalError,
    login::repo::logins::Login,
};

pub fn router() -> Router<App> {
    Router::new()
        .route("/create", post(on_create))
        .route("/:channel/send", post(on_send))
        .route("/:channel/events", get(on_events))
}

#[derive(serde::Deserialize)]
struct CreateRequest {
    name: String,
}

async fn on_create(
    State(app): State<App>,
    _: Login, // requires auth, but doesn't actually care who you are
    Form(form): Form<CreateRequest>,
) -> Result<impl IntoResponse, InternalError> {
    app.channels().create(&form.name).await?;

    Ok(Redirect::to("/"))
}

#[derive(serde::Deserialize)]
struct SendRequest {
    message: String,
}

async fn on_send(
    Path(channel): Path<ChannelId>,
    RequestedAt(sent_at): RequestedAt,
    State(app): State<App>,
    login: Login,
    Form(form): Form<SendRequest>,
) -> Result<impl IntoResponse, InternalError> {
    app.channels()
        .send(&login, &channel, &form.message, &sent_at)
        .await?;

    Ok(StatusCode::ACCEPTED)
}

async fn on_events(
    Path(channel): Path<ChannelId>,
    State(app): State<App>,
    _: Login, // requires auth, but doesn't actually care who you are
    last_event_id: Option<TypedHeader<LastEventId>>,
) -> Result<impl IntoResponse, InternalError> {
    let resume_at = last_event_id
        .map(|TypedHeader(header)| header)
        .map(|LastEventId(header)| header)
        .map(|header| DateTime::parse_from_rfc3339(&header))
        .transpose()?
        .map(|ts| ts.to_utc());

    let stream = app
        .channels()
        .events(&channel, resume_at.as_ref())
        .await?
        .and_then(|msg| future::ready(to_event(msg)));

    Ok(Sse::new(stream).keep_alive(sse::KeepAlive::default()))
}

fn to_event(msg: BroadcastMessage) -> Result<sse::Event, BoxedError> {
    let data = serde_json::to_string(&msg)?;
    let event = sse::Event::default()
        .id(msg
            .sent_at
            .to_rfc3339_opts(SecondsFormat::AutoSi, /* use_z */ true))
        .data(&data);

    Ok(event)
}