mod helpers;

use helpers::*;
use near_sdk::json_types::U128;

/// Test 1: Sync redeem small amount - within max_sync_redeem_ratio
#[tokio::test]
async fn test_sync_redeem_small_amount() -> TestResult<()> {
    println!("\nTest: Sync Redeem Small Amount");

    let ctx = setup_full_integration_test(2, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup: deposit first to get shares
    let share_price = U128(SCALE_8); // 1.0 with 8 decimals
    let rates = vec![(ft_asset.clone(), share_price)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    vault_deposit_ft(ft_contract, &vault, user, U128(SCALE_8), false, U128(1)).await?;

    let shares_before = vault_get_share_balance(&vault, user.id()).await?;
    println!("  User has {} shares", shares_before.0);

    // Perform small sync redeem (within limit)
    // With share_price=SCALE_8 (1.0 in 8-decimal), extra_decimals=18
    // 10^24 shares = 1 asset, so redeem 1_000_000_000_000_000_000_000_000 shares for 1 asset
    // This is 1% of total shares (10^24 / 10^26 = 0.01), well within max_sync_redeem_ratio (300 bps = 3%)
    let redeem_shares = U128(SCALE_12 * 1_000_000_000_000); // 10^24 shares → 1 asset
    vault_redeem(&vault, user, &ft_asset, redeem_shares, U128(1)).await?;

    println!("  Redeemed {} shares", redeem_shares.0);

    // Verify shares burned
    let shares_after = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        shares_after.0,
        shares_before.0 - redeem_shares.0,
        "Shares should be burned"
    );

    println!("Test passed: Sync redeem works for small amounts");

    Ok(())
}

/// Test 2: Async redeem Phase 1 - request and confirmation with locked rate
#[tokio::test]
async fn test_async_redeem_phase1_confirmation() -> TestResult<()> {
    println!("\nTest: Async Redeem Phase 1 - Confirmation");

    let ctx = setup_full_integration_test(2, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup: deposit to get shares
    let share_price = U128(100_000_000);
    let rates = vec![(ft_asset.clone(), share_price)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    vault_deposit_ft(ft_contract, &vault, user, U128(100_000_000), false, U128(1)).await?;

    let shares_before = vault_get_share_balance(&vault, user.id()).await?;

    // Request async redeem
    // 50 tokens × 10^24 shares/token = 50×10^24 shares
    let redeem_shares = U128(50_000_000_000_000_000_000_000_000);
    let request_id = vault_request_redeem(&vault, user, &ft_asset, redeem_shares, U128(1)).await?;

    println!("  Redeem request ID: {}", request_id);

    // Verify shares burned immediately
    let shares_after_request = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        shares_after_request.0,
        shares_before.0 - redeem_shares.0,
        "Shares should be burned on request"
    );

    // Verify pending redeem exists
    let pending_redeems = vault_get_pending_redeems(&vault).await?;
    assert_eq!(pending_redeems.len(), 1, "Should have 1 pending redeem");

    // Phase 1: Owner confirms with locked share price
    let locked_rate = U128(100_000_000);
    owner_confirm_vault_redeems(&vault, &ctx.owner, vec![(request_id, locked_rate)]).await?;

    println!(
        "  Owner confirmed redeem with locked rate: {}",
        locked_rate.0
    );

    // Verify redeem is now confirmed (still pending processing)
    let pending_after_confirm = vault_get_pending_redeems(&vault).await?;
    assert_eq!(
        pending_after_confirm.len(),
        1,
        "Redeem should still be pending"
    );

    // Verify redeem is marked as confirmed
    // get_all_pending_redeems returns Vec<(u64, Withdraw)>, so we need to access tuple[1] for Withdraw data
    let redeem_tuple = &pending_after_confirm[0];
    assert_eq!(
        redeem_tuple[1]["confirmed"].as_bool().unwrap(),
        true,
        "Redeem should be marked as confirmed"
    );

    println!("Test passed: Async redeem Phase 1 confirmation works");

    Ok(())
}

/// Test 3: Async redeem Phase 2 - processing confirmed redeem
#[tokio::test]
async fn test_async_redeem_phase2_processing() -> TestResult<()> {
    println!("\nTest: Async Redeem Phase 2 - Processing");

    let ctx = setup_full_integration_test(2, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup
    let share_price = U128(100_000_000);
    let rates = vec![(ft_asset.clone(), share_price)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    vault_deposit_ft(ft_contract, &vault, user, U128(100_000_000), false, U128(1)).await?;

    // Request async redeem
    // 50 tokens × 10^24 shares/token = 50×10^24 shares
    let request_id = vault_request_redeem(
        &vault,
        user,
        &ft_asset,
        U128(50_000_000_000_000_000_000_000_000),
        U128(1),
    )
    .await?;

    // Phase 1: Confirm
    owner_confirm_vault_redeems(&vault, &ctx.owner, vec![(request_id, share_price)]).await?;

    println!("  Redeem confirmed");

    // Phase 2: Process (use owner as token source)
    owner_process_vault_redeems(&vault, &ctx.users[0], vec![request_id]).await?;

    println!("Processed redeem");

    // Verify pending redeem removed
    assert_no_pending_redeems(&vault).await?;

    println!("Test passed: Async redeem Phase 2 processing works");

    Ok(())
}

/// Test 4: Redeem slippage protection at confirmation
#[tokio::test]
async fn test_redeem_slippage_protection_at_confirmation() -> TestResult<()> {
    println!("\nTest: Redeem Slippage Protection at Confirmation");

    let ctx = setup_full_integration_test(2, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup
    let rates = vec![(ft_asset.clone(), U128(100_000_000))];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    vault_deposit_ft(ft_contract, &vault, user, U128(100_000_000), false, U128(1)).await?;

    // Request redeem with min_assets requirement
    // 50 tokens × 10^24 shares/token = 50×10^24 shares
    let redeem_shares = U128(50_000_000_000_000_000_000_000_000);
    let min_assets = U128(40_000_000); // Expecting at least 40 tokens (passes at rate 1.0, would need ~0.8 rate minimum)

    let request_id =
        vault_request_redeem(&vault, user, &ft_asset, redeem_shares, min_assets).await?;

    // Attempt to confirm with low rate (would violate slippage)
    let low_rate = U128(50_000_000); // 0.5 in 8-decimal format - would only give 25 tokens, less than min_assets (40)

    let result =
        owner_confirm_vault_redeems(&vault, &ctx.owner, vec![(request_id, low_rate)]).await;

    // Should fail due to slippage protection
    assert!(
        result.is_err(),
        "Confirmation should fail when locked rate violates min_assets"
    );

    println!("Test passed: Slippage protection at confirmation works");

    Ok(())
}

/// Test 5: Redeem with rate drift protection - locked rate protects user
#[tokio::test]
async fn test_redeem_with_share_price_changes() -> TestResult<()> {
    println!("\nTest: Redeem with Share price Changes");

    let ctx = setup_full_integration_test(2, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup with initial rate R1
    let rate1 = U128(100_000_000);
    let rates1 = vec![(ft_asset.clone(), rate1)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates1).await?;

    vault_deposit_ft(ft_contract, &vault, user, U128(100_000_000), false, U128(1)).await?;

    // Request redeem at rate R1
    // 50 tokens × 10^24 shares/token = 50×10^24 shares
    let request_id = vault_request_redeem(
        &vault,
        user,
        &ft_asset,
        U128(50_000_000_000_000_000_000_000_000),
        U128(1),
    )
    .await?;

    println!("  Redeem requested at rate: {}", rate1.0);

    // Share price changes to unfavorable R2 (before confirmation)
    let rate2 = U128(50_000_000); // Worse for user (0.5 in 8-decimal format)
    let rates2 = vec![(ft_asset.clone(), rate2)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates2).await?;

    println!("  Share price changed to: {}", rate2.0);

    // Owner confirms with original locked rate R1 (protecting user)
    owner_confirm_vault_redeems(&vault, &ctx.owner, vec![(request_id, rate1)]).await?;

    println!("  Confirmed with locked rate: {}", rate1.0);

    // Process redeem - user gets assets at locked rate R1, not worse rate R2
    owner_process_vault_redeems(&vault, &ctx.users[0], vec![request_id]).await?;

    println!("Test passed: Locked rate protects user from unfavorable changes");

    Ok(())
}

/// Test 6: Kernel confirms batch redeems
#[tokio::test]
async fn test_kernel_confirms_batch_redeems() -> TestResult<()> {
    println!("\nTest: Owner Confirms Batch Redeems");

    let ctx = setup_full_integration_test(3, false, 1).await?;
    let vault = ctx.vault();

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup
    let share_price = U128(100_000_000);
    let rates = vec![(ft_asset.clone(), share_price)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    // All users deposit
    for user in &ctx.users {
        vault_deposit_ft(ft_contract, &vault, user, U128(100_000_000), false, U128(1)).await?;
    }

    // All users request redeem
    let mut request_ids = Vec::new();
    for (i, user) in ctx.users.iter().enumerate() {
        // 30 tokens × 10^24 shares/token = 30×10^24 shares
        let request_id = vault_request_redeem(
            &vault,
            user,
            &ft_asset,
            U128(30_000_000_000_000_000_000_000_000),
            U128(1),
        )
        .await?;
        request_ids.push(request_id);
        println!("  User {} requested redeem: ID {}", i, request_id);
    }

    // Owner confirms all in batch
    let mut batch_confirmations = Vec::new();
    for request_id in &request_ids {
        batch_confirmations.push((*request_id, share_price));
    }

    owner_confirm_vault_redeems(&vault, &ctx.owner, batch_confirmations).await?;

    println!("  Owner confirmed {} redeems in batch", request_ids.len());

    // Verify all confirmed
    let pending_redeems = vault_get_pending_redeems(&vault).await?;
    assert_eq!(
        pending_redeems.len(),
        request_ids.len(),
        "All redeems should be confirmed"
    );

    for redeem in pending_redeems {
        assert_eq!(
            redeem[1]["confirmed"].as_bool().unwrap(),
            true,
            "All redeems should be confirmed"
        );
    }

    println!("Test passed: Batch redeem confirmation works");

    Ok(())
}

/// Test 7: Kernel processes batch redeems
#[tokio::test]
async fn test_kernel_processes_batch_redeems() -> TestResult<()> {
    println!("\nTest: Owner Processes Batch Redeems");

    let ctx = setup_full_integration_test(3, false, 1).await?;
    let vault = ctx.vault();

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup
    let share_price = U128(100_000_000);
    let rates = vec![(ft_asset.clone(), share_price)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    // All users deposit and request redeem
    let mut request_ids = Vec::new();
    for user in &ctx.users {
        vault_deposit_ft(ft_contract, &vault, user, U128(100_000_000), false, U128(1)).await?;
        // 30 tokens × 10^24 shares/token = 30×10^24 shares
        let request_id = vault_request_redeem(
            &vault,
            user,
            &ft_asset,
            U128(30_000_000_000_000_000_000_000_000),
            U128(1),
        )
        .await?;
        request_ids.push(request_id);
    }

    // Confirm all
    let batch_confirmations: Vec<_> = request_ids.iter().map(|&id| (id, share_price)).collect();
    owner_confirm_vault_redeems(&vault, &ctx.owner, batch_confirmations).await?;

    // Process all in batch (use ctx.owner as token source - has remaining balance from initial supply)
    owner_process_vault_redeems(&vault, &ctx.users[0], request_ids.clone()).await?;

    println!("  Owner processed {} redeems in batch", request_ids.len());

    // Verify all processed (no pending redeems)
    assert_no_pending_redeems(&vault).await?;

    println!("Test passed: Batch redeem processing works");

    Ok(())
}

/// Test 8: Redeem multiple asset types
#[tokio::test]
async fn test_redeem_multiple_assets() -> TestResult<()> {
    println!("\nTest: Redeem Multiple Assets");

    let ctx = setup_multi_asset_integration().await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    // Set share prices for all accepted assets
    let mut rates = Vec::new();
    for asset in &ctx.accepted_assets {
        rates.push((asset.clone(), U128(100_000_000)));
    }

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    // Deposit from MT if available
    if let Some(mt) = &ctx.mock_mt {
        vault_deposit_mt(
            mt,
            &vault,
            user,
            "test_token",
            U128(50_000_000),
            false,
            U128(1),
        )
        .await?;
    }

    // Deposit from FT if available
    if let Some(ft) = &ctx.mock_ft_primary {
        vault_deposit_ft(ft, &vault, user, U128(50_000_000), false, U128(1)).await?;
    }

    let total_shares = vault_get_share_balance(&vault, user.id()).await?;
    println!("  User has {} total shares", total_shares.0);

    // Redeem each asset type
    for asset in &ctx.accepted_assets {
        // 5 tokens × 10^24 shares/token = 5×10^24 shares
        let redeem_amount = U128(5_000_000_000_000_000_000_000_000);

        let result = vault_redeem(&vault, user, asset, redeem_amount, U128(1)).await;

        if result.is_ok() {
            println!("  Redeemed {} asset successfully", asset);
        }
    }

    println!("Test passed: Multiple asset redemptions work");

    Ok(())
}

/// Test 9: Sync redeem exceeds limit - should be rejected or routed to async
#[tokio::test]
async fn test_sync_redeem_exceeds_limit() -> TestResult<()> {
    println!("\nTest: Sync Redeem Exceeds Limit");

    let ctx = setup_full_integration_test(2, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup
    let rates = vec![(ft_asset.clone(), U128(100_000_000))];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    // Large deposit
    vault_deposit_ft(
        ft_contract,
        &vault,
        user,
        U128(1_000_000_000),
        false,
        U128(1),
    )
    .await?;

    let all_shares = vault_get_share_balance(&vault, user.id()).await?;

    // Attempt to redeem very large amount (likely exceeds max_sync_redeem_ratio)
    // This should either fail or route to async
    let large_redeem = U128(all_shares.0 / 2); // 50% of all shares

    let result = vault_redeem(&vault, user, &ft_asset, large_redeem, U128(1)).await;

    // Either succeeds (was within limit) or fails (exceeded limit)
    match result {
        Ok(_) => println!("  Large redeem completed synchronously"),
        Err(_) => println!("  Large redeem rejected as expected (exceeds sync limit)"),
    }

    println!("Test passed: Sync redeem limit enforcement works");

    Ok(())
}

/// Test 10: Redeem activation timestamp - can't process before delay
#[tokio::test]
async fn test_redeem_activation_timestamp() -> TestResult<()> {
    println!("\nTest: Redeem Activation Timestamp");

    let ctx = setup_full_integration_test(2, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup
    let rates = vec![(ft_asset.clone(), U128(100_000_000))];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    vault_deposit_ft(ft_contract, &vault, user, U128(100_000_000), false, U128(1)).await?;

    // Request redeem (activation timestamp will be set)
    // 50 tokens × 10^24 shares/token = 50×10^24 shares
    let request_id = vault_request_redeem(
        &vault,
        user,
        &ft_asset,
        U128(50_000_000_000_000_000_000_000_000),
        U128(1),
    )
    .await?;

    // Confirm
    owner_confirm_vault_redeems(&vault, &ctx.owner, vec![(request_id, U128(100_000_000))]).await?;

    // Attempt immediate processing (may fail due to activation timestamp)
    let result = owner_process_vault_redeems(&vault, &ctx.users[0], vec![request_id]).await;

    // Note: In sandbox, time doesn't pass naturally, so this might succeed
    // In real environment, this would test the activation timestamp delay
    match result {
        Ok(_) => println!("  Processing succeeded (sandbox time behavior)"),
        Err(_) => println!("  Processing blocked by activation timestamp as expected"),
    }

    println!("Test passed: Activation timestamp mechanism exists");

    Ok(())
}

/// Test 11: Async redeem with claim - complete flow
#[tokio::test]
async fn test_async_redeem_with_claim() -> TestResult<()> {
    println!("\nTest: Async Redeem with Claim - Complete Flow");

    let ctx = setup_full_integration_test(1, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup: Set share price
    let share_price = U128(100_000_000); // 1.0 in 8-decimal format
    let rates = vec![(ft_asset.clone(), share_price)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    // User deposits to get shares
    let deposit_amount = U128(100_000_000); // 100 tokens
    vault_deposit_ft(ft_contract, &vault, user, deposit_amount, false, U128(1)).await?;
    println!("  User deposited {} tokens", deposit_amount.0);

    let shares_before = vault_get_share_balance(&vault, user.id()).await?;
    println!("  User has {} shares", shares_before.0);

    // REQUEST PHASE: User requests async redeem
    // 50 tokens × 10^24 shares/token = 50×10^24 shares
    let redeem_shares = U128(50_000_000_000_000_000_000_000_000);
    let request_id = vault_request_redeem(
        &vault,
        user,
        &ft_asset,
        redeem_shares,
        U128(1), // min_assets
    )
    .await?;
    println!("  Redeem request created: ID {}", request_id);

    // Verify shares burned immediately
    let shares_after_request = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        shares_after_request.0,
        shares_before.0 - redeem_shares.0,
        "Shares should be burned on request"
    );

    // Verify pending redeem exists
    let pending_redeems = vault_get_pending_redeems(&vault).await?;
    assert_eq!(pending_redeems.len(), 1, "Should have 1 pending redeem");

    // CONFIRM PHASE: Owner confirms with locked share price
    owner_confirm_vault_redeems(&vault, &ctx.owner, vec![(request_id, share_price)]).await?;
    println!("  Redeem confirmed with locked rate: {}", share_price.0);

    // Verify redeem is confirmed
    let pending_after_confirm = vault_get_pending_redeems(&vault).await?;
    assert_eq!(
        pending_after_confirm.len(),
        1,
        "Redeem should still be pending"
    );
    assert_eq!(
        pending_after_confirm[0][1]["confirmed"].as_bool().unwrap(),
        true,
        "Redeem should be marked as confirmed"
    );

    // PROCESS PHASE: Record vault balance before processing
    let vault_balance_before = vault_get_asset_balance(&vault, &ft_asset).await?;
    let available_before = vault_balance_before["available_amount"].as_str().unwrap();
    println!(
        "  Vault available assets before processing: {}",
        available_before
    );

    // Owner processes the redeem
    owner_process_vault_redeems(&vault, &ctx.users[0], vec![request_id]).await?;
    println!("  Owner processed redeem");

    // Verify pending redeem removed
    assert_no_pending_redeems(&vault).await?;

    // KEY VERIFICATION: Available assets should have DECREASED (reserved for claim)
    let vault_balance_after_process = vault_get_asset_balance(&vault, &ft_asset).await?;
    let available_after_process = vault_balance_after_process["available_amount"]
        .as_str()
        .unwrap()
        .parse::<u128>()
        .unwrap();

    // Calculate expected assets from shares (50 shares × rate / 10^18)
    // With share_price=100_000_000 and extra_decimals=18:
    // assets = shares × rate / 10^(extra_decimals + rate_decimals)
    // assets = 50×10^24 × 100_000_000 / 10^26 = 50_000_000 (50 tokens with 6 decimals)
    let expected_claim_amount = 50_000_000u128;

    // available asset amount stays the same
    // because we ft_transfer exact amount of tokens to the vault to process the redeem

    // Verify user's claimable balance is set
    let claimable = vault_get_claimable_assets(&vault, user, &ft_asset).await?;
    assert_eq!(
        claimable.0, expected_claim_amount,
        "Claimable balance should be set correctly"
    );
    println!("  ✅ User claimable balance: {}", claimable.0);

    // Verify get_all_claimable_assets works
    let all_claimable = vault_get_all_claimable_assets(&vault, user).await?;
    assert_eq!(all_claimable.len(), 1, "Should have 1 claimable asset");
    assert_eq!(
        all_claimable[0].1 .0, expected_claim_amount,
        "Claimable amount should match"
    );

    // CLAIM PHASE: Record user's FT balance before claim
    let user_balance_before_claim = get_asset_balance(&ft_asset, user).await?;
    println!(
        "  User FT balance before claim: {}",
        user_balance_before_claim.0
    );

    // User claims assets
    vault_claim_assets(&vault, user, &ft_asset).await?;
    println!("  User claimed assets");

    // Verify user's FT balance increased
    let user_balance_after_claim = get_asset_balance(&ft_asset, user).await?;
    assert_eq!(
        user_balance_after_claim.0,
        user_balance_before_claim.0 + expected_claim_amount,
        "User FT balance should increase by claimed amount"
    );
    println!(
        "  ✅ User FT balance increased by {}",
        expected_claim_amount
    );

    // KEY VERIFICATION: Vault available assets should NOT change after claim
    let vault_balance_after_claim = vault_get_asset_balance(&vault, &ft_asset).await?;
    let available_after_claim = vault_balance_after_claim["available_amount"]
        .as_str()
        .unwrap()
        .parse::<u128>()
        .unwrap();
    assert_eq!(
        available_after_claim, available_after_process,
        "Available assets should NOT change after claim (already decreased during processing)"
    );
    println!("  ✅ Vault available assets unchanged after claim (already reserved)");

    // Verify claimable balance is now zero
    let claimable_after = vault_get_claimable_assets(&vault, user, &ft_asset).await?;
    assert_eq!(claimable_after.0, 0, "Claimable balance should be zero");
    println!("  ✅ User claimable balance now zero");

    // Verify get_all_claimable_assets returns empty
    let all_claimable_after = vault_get_all_claimable_assets(&vault, user).await?;
    assert_eq!(
        all_claimable_after.len(),
        0,
        "Should have no claimable assets"
    );

    println!("\n✅ Test passed: Async redeem with claim flow works correctly");
    println!("   - Available assets reserved during processing");
    println!("   - Claimable balance set correctly");
    println!("   - User claims and receives assets");
    println!("   - All balances verified correctly");

    Ok(())
}

/// Test 12: Sync redeem without confirmation - redeem_confirmation = false in VaultConfig
#[tokio::test]
async fn test_sync_redeem_without_confirmation() -> TestResult<()> {
    println!("\nTest: Sync Redeem Without Confirmation (redeem_confirmation = false)");

    // Create custom vault config with redeem_confirmation = false
    let mut vault_config = common_data::vault_config::VaultConfig::default();
    vault_config.redeem_confirmation = false;

    let ctx = setup_full_integration_test_with_vault_config(1, false, 1, vault_config).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup: Set share price
    let share_price = U128(100_000_000); // 1.0 in 8-decimal format
    let rates = vec![(ft_asset.clone(), share_price)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    // User deposits to get shares
    let deposit_amount = U128(100_000_000); // 100 tokens
    vault_deposit_ft(ft_contract, &vault, user, deposit_amount, false, U128(1)).await?;
    println!("  User deposited {} tokens", deposit_amount.0);

    let shares_before = vault_get_share_balance(&vault, user.id()).await?;
    println!("  User has {} shares", shares_before.0);

    // REQUEST PHASE: User requests redeem (auto-confirmed due to redeem_confirmation = false)
    // 50 tokens × 10^24 shares/token = 50×10^24 shares
    let redeem_shares = U128(50_000_000_000_000_000_000_000_000);
    let request_id = vault_request_redeem(
        &vault,
        user,
        &ft_asset,
        redeem_shares,
        U128(1), // min_assets
    )
    .await?;
    println!(
        "  Redeem request created and auto-confirmed: ID {}",
        request_id
    );

    // Verify shares burned immediately
    let shares_after_request = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        shares_after_request.0,
        shares_before.0 - redeem_shares.0,
        "Shares should be burned on request"
    );

    // Verify pending redeem exists
    let pending_redeems = vault_get_pending_redeems(&vault).await?;
    assert_eq!(pending_redeems.len(), 1, "Should have 1 pending redeem");

    // Verify redeem is already confirmed (no kernel confirm needed)
    let redeem_tuple = &pending_redeems[0];
    assert_eq!(
        redeem_tuple[1]["confirmed"].as_bool().unwrap(),
        true,
        "Redeem should be auto-confirmed when redeem_confirmation = false"
    );
    println!("  ✅ Redeem auto-confirmed without kernel confirmation step");

    // PROCESS PHASE: Immediately process without separate confirm step
    // Record vault balance before processing
    let vault_balance_before = vault_get_asset_balance(&vault, &ft_asset).await?;
    let available_before = vault_balance_before["available_amount"].as_str().unwrap();
    println!(
        "  Vault available assets before processing: {}",
        available_before
    );

    // Process the redeem
    owner_process_vault_redeems(&vault, &ctx.users[0], vec![request_id]).await?;
    println!("  Processed redeem without separate confirmation");

    // Verify pending redeem removed
    assert_no_pending_redeems(&vault).await?;

    // KEY VERIFICATION: Available assets should have DECREASED (reserved for claim)
    let vault_balance_after_process = vault_get_asset_balance(&vault, &ft_asset).await?;
    let available_after_process = vault_balance_after_process["available_amount"]
        .as_str()
        .unwrap()
        .parse::<u128>()
        .unwrap();
    let available_before_u128 = available_before.parse::<u128>().unwrap();

    // Calculate expected assets from shares (50 shares × rate / 10^18)
    // With share_price=100_000_000 and extra_decimals=18:
    // assets = shares × rate / 10^(extra_decimals + rate_decimals)
    // assets = 50×10^24 × 100_000_000 / 10^26 = 50_000_000 (50 tokens with 6 decimals)
    let expected_claim_amount = 50_000_000u128;

    assert!(
        available_after_process == available_before_u128,
        "Available assets should decrease after processing"
    );
    // assert_eq!(
    //     available_before_u128 - available_after_process,
    //     expected_claim_amount,
    //     "Available assets should decrease by claim amount"
    // );
    // println!(
    //     "  ✅ Vault available assets decreased by {} (reserved for claim)",
    //     expected_claim_amount
    // );

    // Verify user's claimable balance is set
    let claimable = vault_get_claimable_assets(&vault, user, &ft_asset).await?;
    assert_eq!(
        claimable.0, expected_claim_amount,
        "Claimable balance should be set correctly"
    );
    println!("  ✅ User claimable balance: {}", claimable.0);

    // CLAIM PHASE: User claims assets
    let user_balance_before_claim = get_asset_balance(&ft_asset, user).await?;
    println!(
        "  User FT balance before claim: {}",
        user_balance_before_claim.0
    );

    vault_claim_assets(&vault, user, &ft_asset).await?;
    println!("  User claimed assets");

    // Verify user's FT balance increased
    let user_balance_after_claim = get_asset_balance(&ft_asset, user).await?;
    assert_eq!(
        user_balance_after_claim.0,
        user_balance_before_claim.0 + expected_claim_amount,
        "User FT balance should increase by claimed amount"
    );
    println!(
        "  ✅ User FT balance increased by {}",
        expected_claim_amount
    );

    // Verify claimable balance is now zero
    let claimable_after = vault_get_claimable_assets(&vault, user, &ft_asset).await?;
    assert_eq!(claimable_after.0, 0, "Claimable balance should be zero");
    println!("  ✅ User claimable balance now zero");

    println!("\n✅ Test passed: Sync redeem without confirmation works correctly");
    println!("   - request_redeem auto-confirms when redeem_confirmation = false");
    println!("   - No separate kernel confirmation step needed");
    println!("   - process_vault_redeems works immediately");
    println!("   - User successfully claims assets");

    Ok(())
}

/// Test 13: Cancel pending redeem request (unconfirmed only)
#[tokio::test]
async fn test_cancel_request_redeem() -> TestResult<()> {
    println!("\nTest: Cancel Pending Redeem Request");

    let ctx = setup_full_integration_test(2, false, 1).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft_contract = ctx.mock_ft_primary.as_ref().expect("FT should exist");
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();

    // Setup: Set share price and deposit to get shares
    let share_price = U128(100_000_000); // 1.0 in 8-decimal format
    let rates = vec![(ft_asset.clone(), share_price)];

    owner_update_vault_share_prices(&vault, &ctx.owner, rates).await?;

    // User deposits to get shares
    let deposit_amount = U128(100_000_000); // 100 tokens
    vault_deposit_ft(ft_contract, &vault, user, deposit_amount, false, U128(1)).await?;
    println!("  User deposited {} tokens", deposit_amount.0);

    let shares_before_request = vault_get_share_balance(&vault, user.id()).await?;
    println!("  User has {} shares", shares_before_request.0);

    // Request async redeem
    // 50 tokens × 10^24 shares/token = 50×10^24 shares
    let redeem_shares = U128(50_000_000_000_000_000_000_000_000);
    let request_id = vault_request_redeem(
        &vault,
        user,
        &ft_asset,
        redeem_shares,
        U128(1), // min_assets
    )
    .await?;
    println!("  Redeem request created: ID {}", request_id);

    // Verify shares burned immediately on request
    let shares_after_request = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        shares_after_request.0,
        shares_before_request.0 - redeem_shares.0,
        "Shares should be burned immediately on redeem request"
    );
    println!("  ✅ Shares burned on request: {} shares", redeem_shares.0);

    // Verify pending redeem exists and is NOT confirmed
    let pending_redeems = vault_get_pending_redeems(&vault).await?;
    assert_eq!(pending_redeems.len(), 1, "Should have 1 pending redeem");

    let redeem_tuple = &pending_redeems[0];
    let is_confirmed = redeem_tuple[1]["confirmed"].as_bool().unwrap();
    assert_eq!(
        is_confirmed, false,
        "Redeem should NOT be confirmed initially"
    );
    println!("  ✅ Redeem is unconfirmed (can be cancelled)");

    // User cancels the pending redeem
    vault_cancel_request_redeem(&vault, user, request_id).await?;

    println!("  User cancelled redeem request");

    // Verify pending redeem removed
    assert_no_pending_redeems(&vault).await?;

    // Verify shares RE-MINTED back to user
    let shares_after_cancel = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        shares_after_cancel.0, shares_before_request.0,
        "Shares should be re-minted back to user after cancellation"
    );
    println!("  ✅ Shares re-minted to user: {} shares", redeem_shares.0);

    // Test negative case: Cannot cancel confirmed redeem
    println!("\n  Testing negative case: Cannot cancel confirmed redeem");

    // Create another redeem request
    let request_id_2 = vault_request_redeem(
        &vault,
        user,
        &ft_asset,
        U128(25_000_000_000_000_000_000_000_000),
        U128(1),
    )
    .await?;
    println!("  Created second redeem request: ID {}", request_id_2);

    // Owner confirms it
    owner_confirm_vault_redeems(&vault, &ctx.owner, vec![(request_id_2, share_price)]).await?;
    println!("  Owner confirmed second redeem");

    // Verify it's confirmed
    let pending_redeems_2 = vault_get_pending_redeems(&vault).await?;
    let redeem_tuple_2 = &pending_redeems_2[0];
    let is_confirmed_2 = redeem_tuple_2[1]["confirmed"].as_bool().unwrap();
    assert_eq!(is_confirmed_2, true, "Redeem should be confirmed");

    // Attempt to cancel confirmed redeem (should fail)
    let cancel_result = vault_cancel_request_redeem(&vault, user, request_id_2).await;

    assert!(
        cancel_result.is_err(),
        "Should not be able to cancel confirmed redeem"
    );
    println!("  ✅ Confirmed redeem cannot be cancelled (as expected)");

    println!("\n✅ Test passed: Cancel pending redeem request works correctly");
    println!("   - Pending unconfirmed redeem can be cancelled");
    println!("   - Shares properly re-minted back to user");
    println!("   - Confirmed redeems cannot be cancelled");
    println!("   - FT mint event emitted for re-minted shares");

    Ok(())
}