use axum::{
    extract::{Form, Path, State},
    http::StatusCode,
    response::{IntoResponse, Redirect, Response},
    routing::post,
    Router,
};

use super::app::EventsError;
use crate::{
    app::App,
    clock::RequestedAt,
    error::InternalError,
    repo::{channel, login::Login},
};

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

#[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<channel::Id>,
    RequestedAt(sent_at): RequestedAt,
    State(app): State<App>,
    login: Login,
    Form(form): Form<SendRequest>,
) -> Result<impl IntoResponse, ErrorResponse> {
    app.channels()
        .send(&login, &channel, &form.message, &sent_at)
        .await
        // Could impl `From` here, but it's more code and this is used once.
        .map_err(ErrorResponse)?;

    Ok(Redirect::to(&format!("/{}", channel)))
}

struct ErrorResponse(EventsError);

impl IntoResponse for ErrorResponse {
    fn into_response(self) -> Response {
        let Self(error) = self;
        match error {
            not_found @ EventsError::ChannelNotFound(_) => {
                (StatusCode::NOT_FOUND, not_found.to_string()).into_response()
            }
            EventsError::DatabaseError(error) => InternalError::from(error).into_response(),
        }
    }
}