aurabase 0.1.1

use aurabase::create_client;
use aurabase::types::*;
use wiremock::matchers::{method, path, query_param};
use wiremock::{Mock, MockServer, ResponseTemplate};

fn fake_admin_user() -> serde_json::Value {
    serde_json::json!({
        "id": "user-1",
        "email": "admin@example.com",
        "phone": null,
        "role": "user",
        "email_verified": true,
        "is_banned": false,
        "is_anonymous": false,
        "mfa_enabled": false,
        "avatar_url": null,
        "user_metadata": {},
        "app_metadata": {},
        "created_at": "2026-01-01T00:00:00Z",
        "last_sign_in_at": "2026-01-01T00:00:00Z",
        "is_active": true,
        "password_hash": null
    })
}

#[tokio::test]
async fn admin_list_users() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v1/auth/admin/users"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": [fake_admin_user()]
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .list_users(None, None, None)
        .await
        .unwrap();
    assert!(res.data.is_some());
    assert_eq!(res.data.unwrap().len(), 1);
}

#[tokio::test]
async fn admin_list_users_with_params() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v1/auth/admin/users"))
        .and(query_param("limit", "10"))
        .and(query_param("offset", "5"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": []
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .list_users(Some(10), Some(5), None)
        .await
        .unwrap();
    assert!(res.data.is_some());
}

#[tokio::test]
async fn admin_get_user() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v1/auth/admin/users/user-1"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": fake_admin_user()
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client.auth_admin().get_user("user-1").await.unwrap();
    assert!(res.data.is_some());
}

#[tokio::test]
async fn admin_create_user() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/v1/auth/admin/users"))
        .respond_with(ResponseTemplate::new(201).set_body_json(serde_json::json!({
            "data": fake_admin_user()
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .create_user(AdminCreateUserRequest {
            email: "new@example.com".into(),
            password: Some("secret123".into()),
            role: None,
            email_verified: Some(true),
            user_metadata: None,
        })
        .await
        .unwrap();
    assert!(res.data.is_some());
}

#[tokio::test]
async fn admin_update_user() {
    let server = MockServer::start().await;
    Mock::given(method("PUT"))
        .and(path("/v1/auth/admin/users/user-1"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": fake_admin_user()
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .update_user(
            "user-1",
            AdminUpdateUserRequest {
                role: Some("admin".into()),
                ..Default::default()
            },
        )
        .await
        .unwrap();
    assert!(res.data.is_some());
}

#[tokio::test]
async fn admin_delete_user() {
    let server = MockServer::start().await;
    Mock::given(method("DELETE"))
        .and(path("/v1/auth/admin/users/user-1"))
        .respond_with(ResponseTemplate::new(204))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client.auth_admin().delete_user("user-1").await.unwrap();
    assert!(res.error.is_none());
}

#[tokio::test]
async fn admin_ban_user() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/v1/auth/admin/users/user-1/ban"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": { "message": "User banned" }
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client.auth_admin().ban_user("user-1").await.unwrap();
    assert!(res.error.is_none());
}

#[tokio::test]
async fn admin_unban_user() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/v1/auth/admin/users/user-1/unban"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": { "message": "User unbanned" }
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client.auth_admin().unban_user("user-1").await.unwrap();
    assert!(res.error.is_none());
}

#[tokio::test]
async fn admin_generate_link() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/v1/auth/admin/users/user-1/generate-link"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": { "link": "https://example.com/verify?token=abc" }
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .generate_link("user-1", "recovery", Some("https://example.com/reset"))
        .await
        .unwrap();
    assert!(res.data.is_some());
}

#[tokio::test]
async fn admin_get_audit_log() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v1/auth/admin/audit-log"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": [{
                "id": "log-1",
                "user_id": "user-1",
                "action": "login",
                "ip_address": "1.2.3.4",
                "user_agent": "test",
                "created_at": "2026-01-01T00:00:00Z"
            }]
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .get_audit_log(Some(50), None)
        .await
        .unwrap();
    assert!(res.data.is_some());
    assert_eq!(res.data.unwrap().len(), 1);
}

#[tokio::test]
async fn admin_get_settings() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v1/auth/admin/settings"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": {
                "allow_signup": true,
                "email_confirmation_required": false,
                "password_min_length": 8,
                "mfa_enabled": false,
                "allow_anonymous_users": true,
                "jwt_expiry_seconds": 900,
                "refresh_token_expiry_days": 30,
                "site_url": null,
                "oauth_providers": {},
                "new_device_alerts_enabled": false,
                "webhook_url": null,
                "smtp_host": null,
                "smtp_port": null,
                "smtp_username": null,
                "smtp_password_set": null,
                "smtp_from_email": null,
                "smtp_from_name": null,
                "oauth_credentials": {},
                "captcha_enabled": false,
                "captcha_provider": null,
                "captcha_site_key": null,
                "captcha_secret_key_set": null,
                "password_check_hibp": false,
                "sms_provider": null,
                "sms_api_key_set": null,
                "sms_from_number": null,
                "redirect_urls": [],
                "session_inactivity_timeout_seconds": 86400,
                "hook_send_sms_url": null,
                "hook_send_email_url": null,
                "hook_mfa_verification_url": null,
                "hook_password_verification_url": null,
                "auto_link_by_email": true,
                "revoke_on_new_device": false,
                "enforce_ip_binding": false,
                "allowed_email_domains": [],
                "blocked_email_domains": [],
                "updated_at": "2026-01-01T00:00:00Z"
            }
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client.auth_admin().get_settings().await.unwrap();
    assert!(res.data.is_some());
    assert!(res.data.unwrap().allow_signup);
}

#[tokio::test]
async fn admin_update_settings() {
    let server = MockServer::start().await;
    Mock::given(method("PUT"))
        .and(path("/v1/auth/admin/settings"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": {
                "allow_signup": false,
                "email_confirmation_required": true,
                "password_min_length": 12,
                "mfa_enabled": false,
                "allow_anonymous_users": true,
                "jwt_expiry_seconds": 900,
                "refresh_token_expiry_days": 30,
                "site_url": null,
                "oauth_providers": {},
                "new_device_alerts_enabled": false,
                "webhook_url": null,
                "smtp_host": null,
                "smtp_port": null,
                "smtp_username": null,
                "smtp_password_set": null,
                "smtp_from_email": null,
                "smtp_from_name": null,
                "oauth_credentials": {},
                "captcha_enabled": false,
                "captcha_provider": null,
                "captcha_site_key": null,
                "captcha_secret_key_set": null,
                "password_check_hibp": false,
                "sms_provider": null,
                "sms_api_key_set": null,
                "sms_from_number": null,
                "redirect_urls": [],
                "session_inactivity_timeout_seconds": 86400,
                "hook_send_sms_url": null,
                "hook_send_email_url": null,
                "hook_mfa_verification_url": null,
                "hook_password_verification_url": null,
                "auto_link_by_email": true,
                "revoke_on_new_device": false,
                "enforce_ip_binding": false,
                "allowed_email_domains": [],
                "blocked_email_domains": [],
                "updated_at": "2026-01-01T00:00:00Z"
            }
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .update_settings(serde_json::json!({ "allow_signup": false, "password_min_length": 12 }))
        .await
        .unwrap();
    assert!(res.data.is_some());
    assert!(!res.data.unwrap().allow_signup);
}

#[tokio::test]
async fn admin_list_email_templates() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v1/auth/admin/email-templates"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": [{ "type": "confirmation", "subject": "Confirm" }]
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client.auth_admin().list_email_templates().await.unwrap();
    assert!(res.data.is_some());
    assert_eq!(res.data.unwrap().len(), 1);
}

#[tokio::test]
async fn admin_get_email_template() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v1/auth/admin/email-templates/confirmation"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": { "type": "confirmation", "subject": "Confirm your email" }
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .get_email_template("confirmation")
        .await
        .unwrap();
    assert!(res.data.is_some());
}

#[tokio::test]
async fn admin_update_email_template() {
    let server = MockServer::start().await;
    Mock::given(method("PUT"))
        .and(path("/v1/auth/admin/email-templates/confirmation"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "data": { "type": "confirmation", "subject": "New subject" }
        })))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .update_email_template(
            "confirmation",
            EmailTemplateUpdate {
                subject: Some("New subject".into()),
                body: None,
            },
        )
        .await
        .unwrap();
    assert!(res.data.is_some());
}

#[tokio::test]
async fn admin_delete_email_template() {
    let server = MockServer::start().await;
    Mock::given(method("DELETE"))
        .and(path("/v1/auth/admin/email-templates/confirmation"))
        .respond_with(ResponseTemplate::new(204))
        .mount(&server)
        .await;

    let client = create_client(&server.uri(), "aura_anon_test", None);
    let res = client
        .auth_admin()
        .delete_email_template("confirmation")
        .await
        .unwrap();
    assert!(res.error.is_none());
}