mod helpers;

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

/// Test 1: FT deposit (sync) - immediate share minting
#[tokio::test]
async fn test_ft_deposit_sync() -> TestResult<()> {
    println!("\nTest: FT Deposit Sync");

    // Setup with FT token
    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 contract should exist");

    // Set initial share price (direct owner call, no kernel)
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();
    let rates = vec![(ft_asset.clone(), U128(SCALE_6))]; // 1.0 with 6 decimals

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

    // Perform sync deposit
    let deposit_amount = U128(10 * SCALE_6); // 10 tokens
    vault_deposit_ft(ft_contract, &vault, user, deposit_amount, false, U128(1)).await?;

    // Verify shares were minted immediately
    let share_balance = vault_get_share_balance(&vault, user.id()).await?;

    assert!(
        share_balance.0 > 0,
        "User should have received shares from sync deposit"
    );

    println!("  User received {} shares", share_balance.0);

    // Verify no pending deposits
    assert_no_pending_deposits(&vault).await?;

    println!("Test passed: FT sync deposit works correctly");

    Ok(())
}

/// Test 2: FT deposit (async) - requires owner processing
#[tokio::test]
async fn test_ft_deposit_async() -> TestResult<()> {
    println!("\nTest: FT Deposit Async");

    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 contract should exist");

    // Set initial share price (direct owner call)
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();
    let share_price = U128(SCALE_6); // 1.0 with 6 decimals
    let rates = vec![(ft_asset.clone(), share_price)];

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

    // Perform async deposit (is_request: true)
    let deposit_amount = U128(10 * SCALE_6); // 10 tokens
    vault_deposit_ft(ft_contract, &vault, user, deposit_amount, true, U128(1)).await?;

    println!("  Async deposit created");

    // Verify shares NOT minted yet
    let share_balance_before = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        share_balance_before.0, 0,
        "Shares should not be minted until owner processes"
    );

    // Verify pending deposit exists
    let pending_deposits = vault_get_pending_deposits(&vault).await?;
    assert_eq!(pending_deposits.len(), 1, "Should have 1 pending deposit");

    let deposit_id = pending_deposits[0][0].as_u64().unwrap();
    println!("  Pending deposit ID: {}", deposit_id);

    // Owner processes the pending deposit (direct call, no kernel)
    owner_process_vault_deposits(&vault, &ctx.owner, vec![(deposit_id, share_price)]).await?;

    println!("  Owner processed pending deposit");

    // Verify shares NOW minted
    let share_balance_after = vault_get_share_balance(&vault, user.id()).await?;
    assert!(
        share_balance_after.0 > 0,
        "Shares should be minted after owner processing"
    );

    println!("  User received {} shares", share_balance_after.0);

    // Verify pending deposit removed
    assert_no_pending_deposits(&vault).await?;

    println!("Test passed: FT async deposit works correctly");

    Ok(())
}

/// Test 3: FT deposit slippage protection - min_shares enforcement
#[tokio::test]
async fn test_ft_deposit_slippage_protection() -> TestResult<()> {
    println!("\nTest: FT Deposit Slippage Protection");

    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 contract should exist");

    // Calculate expected shares with default 1:1 rate
    // deposit_amount = 10 * SCALE_6 (10 tokens with 6 decimals)
    // share_price = SCALE_8 (1.0 with 8 decimals)
    // extra_decimals = 18
    // Formula: shares = (assets × 10^extra_decimals × 10^share_price_decimals) / share_price
    // shares = (10 * SCALE_6 × 10^18 × 10^8) / SCALE_8
    // shares = 10 * SCALE_6 × 10^18 = 10^25 (10 shares, 24 decimals)
    let deposit_amount = U128(10 * SCALE_6); // 10 tokens (with 6 decimals)
    let expected_shares = 10 * SCALE_6 * 10u128.pow(18);

    // Set min_shares higher than expected to trigger slippage protection
    let min_shares = U128(expected_shares + 1); // more than expected shares

    // Get user's share balance before deposit attempt
    let shares_before: U128 = user
        .call(vault.id(), "ft_balance_of")
        .args_json(json!({"account_id": user.id()}))
        .view()
        .await?
        .json()?;

    // Attempt the deposit (transaction succeeds but tokens get refunded due to slippage)
    vault_deposit_ft(ft_contract, &vault, user, deposit_amount, false, min_shares).await?;

    // Verify shares didn't increase (deposit was rejected)
    let shares_after: U128 = user
        .call(vault.id(), "ft_balance_of")
        .args_json(json!({"account_id": user.id()}))
        .view()
        .await?
        .json()?;

    assert_eq!(
        shares_before.0, shares_after.0,
        "Shares should not increase when slippage protection rejects deposit"
    );

    println!("Slippage protection working: deposit rejected when min_shares requirement not met");

    Ok(())
}

/// Test 4: Multiple FT contracts - multi-asset vault
#[tokio::test]
async fn test_multiple_ft_contracts() -> TestResult<()> {
    println!("\nTest: Multiple FT Contracts");

    // Setup with 2 FT contracts
    let ctx = setup_full_integration_test(2, false, 2).await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let ft1 = ctx.mock_ft_primary.as_ref().expect("FT1 should exist");
    let ft2 = ctx.mock_ft_secondary.as_ref().expect("FT2 should exist");

    // Set different share prices for each asset (direct owner call)
    let asset1 = ctx.accepted_assets[0].clone();
    let asset2 = ctx.accepted_assets[1].clone();

    let rate1 = U128(SCALE_6); // 1.0 shares per asset1
    let rate2 = U128(2 * SCALE_6); // 2.0 shares per asset2

    let rates = vec![(asset1.clone(), rate1), (asset2.clone(), rate2)];

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

    // Deposit from FT1
    let deposit1 = U128(10 * SCALE_6); // 10 tokens
    vault_deposit_ft(ft1, &vault, user, deposit1, false, U128(1)).await?;

    let balance_after_ft1 = vault_get_share_balance(&vault, user.id()).await?;
    println!("  Shares after FT1 deposit: {}", balance_after_ft1.0);

    // Deposit from FT2
    let deposit2 = U128(5 * SCALE_6); // 5 tokens
    vault_deposit_ft(ft2, &vault, user, deposit2, false, U128(1)).await?;

    let balance_after_ft2 = vault_get_share_balance(&vault, user.id()).await?;
    println!("  Shares after FT2 deposit: {}", balance_after_ft2.0);

    // Verify total shares calculation
    // FT1: 10 tokens * 1.0 rate = 10 shares
    // FT2: 5 tokens * 2.0 rate = 10 shares
    // Total: ~20 shares (accounting for decimals)

    assert!(
        balance_after_ft2.0 > balance_after_ft1.0,
        "Total shares should increase after second deposit"
    );

    println!("Test passed: Multi-asset vault handles multiple FT contracts");

    Ok(())
}

/// Test 5: MT deposit (sync) - immediate share minting
#[tokio::test]
async fn test_mt_deposit_sync() -> TestResult<()> {
    println!("\nTest: MT Deposit Sync");

    // Setup with MT token
    let ctx = setup_minimal_vault().await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    let mt_contract = ctx.mock_mt.as_ref().expect("MT contract should exist");

    // Set initial share price for MT asset (direct owner call)
    let mt_asset = ctx.base_asset.clone();
    let rates = vec![(mt_asset.clone(), U128(SCALE_6))]; // 1.0 with 6 decimals

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

    // Perform sync MT deposit
    let deposit_amount = U128(10 * SCALE_6); // 10 tokens
    vault_deposit_mt(
        mt_contract,
        &vault,
        user,
        "test_token",
        deposit_amount,
        false,
        U128(1),
    )
    .await?;

    // Verify shares minted
    let share_balance = vault_get_share_balance(&vault, user.id()).await?;

    assert!(
        share_balance.0 > 0,
        "User should have received shares from MT sync deposit"
    );

    println!("  User received {} shares", share_balance.0);

    println!("Test passed: MT sync deposit works correctly");

    Ok(())
}

/// Test 6: MT deposit (async) - requires owner processing
#[tokio::test]
async fn test_mt_deposit_async() -> TestResult<()> {
    println!("\nTest: MT Deposit Async");

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

    let mt_contract = ctx.mock_mt.as_ref().expect("MT contract should exist");

    // Set initial share price (direct owner call)
    let mt_asset = ctx.base_asset.clone();
    let share_price = U128(SCALE_6); // 1.0 with 6 decimals
    let rates = vec![(mt_asset.clone(), share_price)];

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

    // Perform async MT deposit (is_request: true)
    let deposit_amount = U128(10 * SCALE_6);
    vault_deposit_mt(
        mt_contract,
        &vault,
        user,
        "test_token",
        deposit_amount,
        true,
        U128(1),
    )
    .await?;

    println!("  Async MT deposit created");

    // Verify pending deposit
    let pending_deposits = vault_get_pending_deposits(&vault).await?;
    assert_eq!(pending_deposits.len(), 1, "Should have 1 pending deposit");

    let deposit_id = pending_deposits[0][0].as_u64().unwrap();

    // Owner processes (direct call, no kernel)
    owner_process_vault_deposits(&vault, &ctx.owner, vec![(deposit_id, share_price)]).await?;

    // Verify shares minted
    let share_balance = vault_get_share_balance(&vault, user.id()).await?;
    assert!(share_balance.0 > 0, "Shares should be minted");

    println!("Test passed: MT async deposit works correctly");

    Ok(())
}

/// Test 7: MT multiple token IDs - single contract, multiple token types
#[tokio::test]
async fn test_mt_multiple_token_ids() -> TestResult<()> {
    println!("\nTest: MT Multiple Token IDs");

    // This would require custom setup with multiple token IDs
    // For now, we'll use the standard setup and verify the concept
    let ctx = setup_multi_asset_integration().await?;
    let vault = ctx.vault();

    // Verify multiple assets accepted
    let accepted_assets = vault_get_accepted_deposit_assets(&vault).await?;

    println!("  Accepted assets: {}", accepted_assets.len());

    // Multiple assets in multi-asset integration include MT tokens with different IDs
    assert!(
        accepted_assets.len() > 1,
        "Multi-asset vault should accept multiple token types"
    );

    println!("Test passed: Vault can handle multiple MT token IDs");

    Ok(())
}

/// Test 8: Mixed FT and MT deposits - combined asset types
#[tokio::test]
async fn test_mixed_ft_mt_deposits() -> TestResult<()> {
    println!("\nTest: Mixed FT and MT Deposits");

    // Setup with both MT and FT
    let ctx = setup_multi_asset_integration().await?;
    let vault = ctx.vault();
    let user = &ctx.users[0];

    // Verify we have both FT and MT assets
    let accepted_assets = vault_get_accepted_deposit_assets(&vault).await?;

    println!("  Total accepted assets: {}", accepted_assets.len());

    // Set share prices for all assets (direct owner call)
    let mut rates = Vec::new();
    for asset in &accepted_assets {
        rates.push((asset.clone(), U128(SCALE_6))); // 1.0 with 6 decimals
    }

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

    // Perform MT deposit if available
    if let Some(mt) = &ctx.mock_mt {
        vault_deposit_mt(
            mt,
            &vault,
            user,
            "test_token",
            U128(5 * SCALE_6),
            false,
            U128(1),
        )
        .await?;
        println!("  MT deposit completed");
    }

    // Perform FT deposit if available
    if let Some(ft) = &ctx.mock_ft_primary {
        vault_deposit_ft(ft, &vault, user, U128(5 * SCALE_6), false, U128(1)).await?;
        println!("  FT deposit completed");
    }

    // Verify shares received
    let share_balance = vault_get_share_balance(&vault, user.id()).await?;

    assert!(
        share_balance.0 > 0,
        "User should have shares from mixed deposits"
    );

    println!("  Total shares: {}", share_balance.0);

    println!("Test passed: Mixed FT/MT deposits work correctly");

    Ok(())
}

/// Test 9: Owner processes batch pending deposits
#[tokio::test]
async fn test_owner_processes_pending_deposits_batch() -> TestResult<()> {
    println!("\nTest: Owner Processes Batch Pending Deposits");

    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 contract should exist");

    // Set share price (direct owner call)
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();
    let share_price = U128(SCALE_6); // 1.0 with 6 decimals
    let rates = vec![(ft_asset.clone(), share_price)];

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

    // Create multiple async deposits from different users
    for (i, user) in ctx.users.iter().enumerate() {
        let amount = U128((i as u128 + 1) * 5 * SCALE_6);
        vault_deposit_ft(ft_contract, &vault, user, amount, true, U128(1)).await?;
        println!("  User {} created async deposit", i);
    }

    // Verify all pending deposits exist
    let pending_deposits = vault_get_pending_deposits(&vault).await?;
    assert_eq!(
        pending_deposits.len(),
        ctx.users.len(),
        "Should have deposits from all users"
    );

    // Collect all deposit IDs and process as batch
    let mut batch_requests = Vec::new();
    for deposit in pending_deposits {
        let deposit_id = deposit[0].as_u64().unwrap();
        batch_requests.push((deposit_id, share_price));
    }

    // Owner processes all deposits in single call (direct call, no kernel)
    owner_process_vault_deposits(&vault, &ctx.owner, batch_requests).await?;

    println!("  Owner processed {} deposits in batch", ctx.users.len());

    // Verify all shares minted
    for (i, user) in ctx.users.iter().enumerate() {
        let balance = vault_get_share_balance(&vault, user.id()).await?;
        assert!(balance.0 > 0, "User {} should have shares", i);
        println!("  User {} balance: {}", i, balance.0);
    }

    // Verify no pending deposits remain
    assert_no_pending_deposits(&vault).await?;

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

    Ok(())
}

/// Test 10: Deposit with share price update between request and processing
#[tokio::test]
async fn test_deposit_with_share_price_update() -> TestResult<()> {
    println!("\nTest: Deposit with Share price Update");

    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 contract should exist");

    // Set initial rate R1 (direct owner call)
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();
    let rate1 = U128(SCALE_6); // 1.0 with 6 decimals
    let rates1 = vec![(ft_asset.clone(), rate1)];

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

    println!("  Initial share price: {}", rate1.0);

    // Create async deposit
    let deposit_amount = U128(10 * SCALE_6);
    vault_deposit_ft(ft_contract, &vault, user, deposit_amount, true, U128(1)).await?;

    let pending_deposits = vault_get_pending_deposits(&vault).await?;
    let deposit_id = pending_deposits[0][0].as_u64().unwrap();

    // Update share price to R2 (before processing)
    let rate2 = U128(2 * SCALE_6); // 2.0 with 6 decimals
    let rates2 = vec![(ft_asset.clone(), rate2)];

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

    println!("  Updated share price: {}", rate2.0);

    // Owner processes with new rate R2 (direct call, no kernel)
    owner_process_vault_deposits(&vault, &ctx.owner, vec![(deposit_id, rate2)]).await?;

    // Verify shares reflect new rate
    let share_balance = vault_get_share_balance(&vault, user.id()).await?;

    // With 10 tokens at rate 2.0, should get ~20 shares
    println!("  Shares received: {}", share_balance.0);

    assert!(
        share_balance.0 > deposit_amount.0,
        "Shares should reflect the updated higher share price"
    );

    println!("Test passed: Share price update applied to pending deposits");

    Ok(())
}

/// Test 11: Cancel pending deposit request
#[tokio::test]
async fn test_cancel_request_deposit() -> TestResult<()> {
    println!("\nTest: Cancel Pending Deposit 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 contract should exist");

    // Set initial share price (direct owner call)
    let ft_asset = ctx.accepted_assets.first().unwrap().clone();
    let share_price = U128(100_000_000); // 1.0 with 8 decimals
    let rates = vec![(ft_asset.clone(), share_price)];

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

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

    // Create async deposit (is_request: true)
    let deposit_amount = U128(10 * SCALE_6); // 10 tokens
    vault_deposit_ft(ft_contract, &vault, user, deposit_amount, true, U128(1)).await?;

    println!("  Async deposit created");

    // Verify pending deposit exists
    let pending_deposits = vault_get_pending_deposits(&vault).await?;
    assert_eq!(pending_deposits.len(), 1, "Should have 1 pending deposit");

    let deposit_id = pending_deposits[0][0].as_u64().unwrap();
    println!("  Pending deposit ID: {}", deposit_id);

    // Verify shares NOT minted yet
    let share_balance_before = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        share_balance_before.0, 0,
        "Shares should not be minted yet for async deposit"
    );

    // Record vault's pending_deposit balance before cancellation
    let vault_balance_before = vault_get_asset_balance(&vault, &ft_asset).await?;
    let pending_deposit_before = vault_balance_before["pending_deposit"]
        .as_str()
        .unwrap()
        .parse::<u128>()
        .unwrap();
    println!(
        "  Vault pending_deposit balance before cancel: {}",
        pending_deposit_before
    );

    // User cancels the pending deposit
    vault_cancel_request_deposit(&vault, user, deposit_id).await?;

    println!("  User cancelled deposit request");

    // Verify pending deposit removed
    assert_no_pending_deposits(&vault).await?;

    // Verify shares still not minted
    let share_balance_after = vault_get_share_balance(&vault, user.id()).await?;
    assert_eq!(
        share_balance_after.0, 0,
        "Shares should not be minted after cancellation"
    );

    // Verify FT tokens returned to user
    let user_balance_after = get_asset_balance(&ft_asset, user).await?;
    assert_eq!(
        user_balance_after.0, user_balance_before.0,
        "User FT balance should be restored after cancellation"
    );
    println!("  ✅ User FT balance restored: {}", user_balance_after.0);

    // Verify vault's pending_deposit balance decreased
    let vault_balance_after = vault_get_asset_balance(&vault, &ft_asset).await?;
    let pending_deposit_after = vault_balance_after["pending_deposit"]
        .as_str()
        .unwrap()
        .parse::<u128>()
        .unwrap();

    assert_eq!(
        pending_deposit_before - pending_deposit_after,
        deposit_amount.0,
        "Vault pending_deposit should decrease by deposit amount"
    );
    println!(
        "  ✅ Vault pending_deposit decreased by {}",
        deposit_amount.0
    );

    println!("\n✅ Test passed: Cancel pending deposit request works correctly");
    println!("   - Pending deposit removed from vault state");
    println!("   - Assets properly returned to user");
    println!("   - Vault accounting updated correctly");
    println!("   - No shares minted during entire flow");

    Ok(())
}