use super::helpers::*;

#[test]
fn test_zero_performance_fee_when_not_live() {
    let mut contract = setup_vault_with_fees(0, 2000); // 20% performance fee

    // Set up state with gains above HWM but vault not live
    set_total_shares(&mut contract, 100_000 * USDC_UNIT);
    set_high_water_mark(&mut contract, RATE_PRECISION); // HWM at 1.0
    set_share_price(&mut contract, RATE_PRECISION * 11 / 10); // Current rate at 1.1

    // Vault is not live
    assert_eq!(contract.live_at.0, 0);

    // Get performance fee - should be 0
    let fee = contract.get_current_performance_fee_preview();

    assert_eq!(fee.0, 0, "Performance fee should be 0 when vault not live");
}

#[test]
fn test_zero_performance_fee_with_zero_tvl() {
    let mut contract = setup_vault_with_fees(0, 2000); // 20% performance fee

    // Start vault
    start_vault(&mut contract);

    // Set up state with zero shares
    set_total_shares(&mut contract, 0);
    set_high_water_mark(&mut contract, RATE_PRECISION);
    set_share_price(&mut contract, RATE_PRECISION * 11 / 10);

    // Get performance fee
    let fee = contract.get_current_performance_fee_preview();

    assert_eq!(fee.0, 0, "Performance fee should be 0 when TVL is zero");
}

#[test]
fn test_zero_performance_fee_at_high_water_mark() {
    let mut contract = setup_vault_with_fees(0, 2000); // 20% performance fee

    // Start vault
    start_vault(&mut contract);

    // Set up state: current rate equals high water mark
    let tvl = 1_000_000 * USDC_UNIT;
    set_total_shares(&mut contract, tvl);
    set_high_water_mark(&mut contract, RATE_PRECISION);
    set_share_price(&mut contract, RATE_PRECISION); // Same as HWM

    // Get performance fee
    let fee = contract.get_current_performance_fee_preview();

    assert_eq!(fee.0, 0, "Performance fee should be 0 when rate equals HWM");
}

#[test]
fn test_zero_performance_fee_below_high_water_mark() {
    let mut contract = setup_vault_with_fees(0, 2000); // 20% performance fee

    // Start vault
    start_vault(&mut contract);

    // Set up state: current rate below high water mark
    let tvl = 1_000_000 * USDC_UNIT;
    set_total_shares(&mut contract, tvl);
    set_high_water_mark(&mut contract, RATE_PRECISION); // HWM at 1.0
    set_share_price(&mut contract, RATE_PRECISION * 9 / 10); // Current at 0.9

    // Get performance fee
    let fee = contract.get_current_performance_fee_preview();

    assert_eq!(fee.0, 0, "Performance fee should be 0 when rate below HWM");
}

#[test]
fn test_performance_fee_above_high_water_mark() {
    let mut contract = setup_vault_with_fees(0, 2000); // 20% performance fee

    // Start vault
    start_vault(&mut contract);

    // Set up state: 1,000,000 USDC TVL
    let total_shares = 1_000_000 * USDC_UNIT;
    set_total_shares(&mut contract, total_shares);

    // HWM at 1.0, current rate at 1.1 (10% gain)
    set_high_water_mark(&mut contract, RATE_PRECISION);
    set_share_price(&mut contract, RATE_PRECISION * 11 / 10);

    // Get performance fee
    let fee = contract.get_current_performance_fee_preview();

    // Calculate expected fee:
    // TVL = 1,000,000 USDC
    // Current rate = 1.1
    // HWM = 1.0
    // Gain = 1.1 - 1.0 = 0.1
    // Gain in asset amount = TVL * gain / rate = 1,000,000 * 0.1 / 1.1 ≈ 90,909 USDC
    // Fee = gain_asset_amount * 20% = 18,181.8 USDC

    // Performance fee calculation is approximate due to rounding
    // Just verify that a fee was calculated
    assert!(fee.0 > 0, "Performance fee should be greater than 0");

    // Rough check: fee should be reasonable (not too small, not too large)
    // For 10% gain on 1M USDC at 20% fee, expect around 18-22K USDC
    let reasonable_min = 15_000 * USDC_UNIT;
    let reasonable_max = 25_000 * USDC_UNIT;
    assert!(
        fee.0 >= reasonable_min && fee.0 <= reasonable_max,
        "Fee {} should be in reasonable range [{}, {}]",
        fee.0,
        reasonable_min,
        reasonable_max
    );
}

#[test]
fn test_high_water_mark_updates_after_gain() {
    let mut contract = setup_vault_with_fees(0, 2000); // 20% performance fee

    // Start vault
    start_vault(&mut contract);

    // Set initial state
    let total_shares = 1_000_000 * USDC_UNIT;
    set_total_shares(&mut contract, total_shares);
    set_high_water_mark(&mut contract, RATE_PRECISION);
    set_share_price(&mut contract, RATE_PRECISION * 11 / 10);

    // Initial HWM
    let initial_hwm = contract.state.highwatermark_rate.0;
    assert_eq!(initial_hwm, RATE_PRECISION);

    // Note: HWM is updated by internal_update_share_price or crystallization
    // This test verifies the current HWM value remains at initial setting
    // until those functions are called

    let current_hwm = contract.state.highwatermark_rate.0;
    assert_eq!(
        current_hwm, initial_hwm,
        "HWM should not change without explicit update"
    );
}

#[test]
fn test_performance_fee_with_hurdle_skipped() {
    // Setup vault with crystallization hurdle
    let mut contract = setup_vault_with_crystallization(ONE_DAY_NS * 90, Some(700)); // 7% hurdle

    // Configure performance fee
    contract.vault_config.performance_fee_bps = 2000; // 20%

    // Start vault
    start_vault(&mut contract);

    // Set up state with gains
    set_total_shares(&mut contract, 1_000_000 * USDC_UNIT);
    set_high_water_mark(&mut contract, RATE_PRECISION);
    set_share_price(&mut contract, RATE_PRECISION * 11 / 10);

    // Get performance fee preview
    let fee = contract.get_current_performance_fee_preview();

    // When hurdle is configured, performance fee preview should return 0
    // (fees calculated via crystallization instead)
    assert_eq!(
        fee.0, 0,
        "Performance fee preview should be 0 when hurdle configured"
    );
}