use axum::{
    extract::{Path, State},
    response::{self, IntoResponse, Redirect},
};

use crate::{
    app::App,
    conversation::{self, app},
    error::Internal,
    token::extract::Identity,
    ui::{
        assets::{Asset, Assets},
        error::NotFound,
    },
};

pub async fn handler(
    State(app): State<App>,
    identity: Option<Identity>,
    Path(conversation): Path<conversation::Id>,
) -> Result<Asset, Error> {
    let _ = identity.ok_or(Error::NotLoggedIn)?;
    app.conversations()
        .get(&conversation)
        .await
        .map_err(Error::from)?;

    Assets::index().map_err(Error::Internal)
}

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("conversation not found")]
    NotFound,
    #[error("not logged in")]
    NotLoggedIn,
    #[error("{0}")]
    Internal(Internal),
}

impl From<app::Error> for Error {
    fn from(error: app::Error) -> Self {
        match error {
            app::Error::NotFound(_) | app::Error::Deleted(_) => Self::NotFound,
            other => Self::Internal(other.into()),
        }
    }
}

impl IntoResponse for Error {
    fn into_response(self) -> response::Response {
        match self {
            Self::NotFound => match Assets::index() {
                Ok(asset) => NotFound(asset).into_response(),
                Err(internal) => internal.into_response(),
            },
            Self::NotLoggedIn => Redirect::temporary("/login").into_response(),
            Self::Internal(error) => error.into_response(),
        }
    }
}