use crate::{AppState, LayoutData, Request, RequestExt};
use async_trait::async_trait;
use serde::Serialize;
use std::sync::Arc;
use tide::http::mime;

pub struct Middleware;

#[async_trait]
impl tide::Middleware<Arc<AppState>> for Middleware {
    async fn handle(
        &self,
        mut request: Request,
        next: tide::Next<'_, Arc<AppState>>,
    ) -> tide::Result {
        let app = request.state().clone();
        let layout_data = request.layout_data().await?;

        let mut response = next.run(request).await;

        #[derive(Serialize)]
        struct ErrorData {
            #[serde(flatten)]
            layout: Arc<LayoutData>,
            status: u16,
            reason: &'static str,
        }

        if !response.status().is_success() {
            response.set_body(app.render_template(
                "error.hbs",
                &ErrorData {
                    layout: layout_data,
                    status: response.status().into(),
                    reason: response.status().canonical_reason(),
                },
            )?);
            response.set_content_type(mime::HTML);
        }

        Ok(response)
    }
}

// Allow tide Results to accept context like other Results do when
// using anyhow.
pub trait TideResultExt {
    fn context<C>(self, cx: C) -> Self
    where
        C: std::fmt::Display + Send + Sync + 'static;

    fn with_context<C, F>(self, f: F) -> Self
    where
        C: std::fmt::Display + Send + Sync + 'static,
        F: FnOnce() -> C;
}

impl<T> TideResultExt for tide::Result<T> {
    fn context<C>(self, cx: C) -> Self
    where
        C: std::fmt::Display + Send + Sync + 'static,
    {
        self.map_err(|e| tide::Error::new(e.status(), e.into_inner().context(cx)))
    }

    fn with_context<C, F>(self, f: F) -> Self
    where
        C: std::fmt::Display + Send + Sync + 'static,
        F: FnOnce() -> C,
    {
        self.map_err(|e| tide::Error::new(e.status(), e.into_inner().context(f())))
    }
}