use anyhow::Result;
use axum::{
    extract::{Path, Query},
    response::{IntoResponse, Redirect},
};
use axum_htmx::{HxRedirect, HxRequest};
use http::StatusCode;
use minijinja::context as template_context;

use crate::{
    contextual_error, create_renderer,
    http::{
        context::AdminRequestContext,
        errors::{WebError, CommonError},
        pagination::{Pagination, PaginationView},
    },
    storage::handle::{handle_list, handle_nuke},
};

pub async fn handle_admin_handles(
    admin_ctx: AdminRequestContext,
    pagination: Query<Pagination>,
) -> Result<impl IntoResponse, WebError> {
    let canonical_url = format!(
        "https://{}/admin/handles",
        admin_ctx.web_context.config.external_base
    );
    
    // Create the template renderer with enhanced context
    let renderer = create_renderer!(admin_ctx.web_context.clone(), admin_ctx.language, false, false);

    let (page, page_size) = pagination.admin_clamped();

    let handles = handle_list(&admin_ctx.web_context.pool, page, page_size).await;
    if let Err(err) = handles {
        return contextual_error!(renderer: renderer, err, template_context!{});
    }
    let (total_count, mut handles) = handles.unwrap();

    let params: Vec<(&str, &str)> = vec![];

    let pagination_view = PaginationView::new(page_size, handles.len() as i64, page, params);

    if handles.len() > page_size as usize {
        handles.truncate(page_size as usize);
    }

    Ok(renderer.render_template(
        "admin_handles",
        template_context! {
            handles,
            total_count,
            pagination => pagination_view,
        },
        Some(&admin_ctx.admin_handle),
        &canonical_url,
    ))
}

pub async fn handle_admin_nuke_identity(
    admin_ctx: AdminRequestContext,
    HxRequest(hx_request): HxRequest,
    Path(did): Path<String>,
) -> Result<impl IntoResponse, WebError> {
    let renderer = create_renderer!(admin_ctx.web_context.clone(), admin_ctx.language, false, false);

    if did == admin_ctx.admin_handle.did {
        return contextual_error!(
            renderer: renderer,
            CommonError::NotAuthorized,
            template_context!{}
        );
    }
    if let Err(err) = handle_nuke(
        &admin_ctx.web_context.pool,
        &did,
        &admin_ctx.admin_handle.did,
    )
    .await
    {
        return contextual_error!(
            renderer: renderer,
            err,
            template_context! {}
        );
    }

    if hx_request {
        let hx_redirect = HxRedirect::try_from("/admin/handles");
        if let Err(err) = hx_redirect {
            return contextual_error!(
                renderer: renderer,
                err,
                template_context! {}
            );
        }
        let hx_redirect = hx_redirect.unwrap();
        Ok((StatusCode::OK, hx_redirect, "").into_response())
    } else {
        Ok(Redirect::to("/admin/handles").into_response())
    }
}