use crate::helpers::vault_operations::*;
use crate::helpers::HIGH_GAS;
use common_data::asset::Asset;
use near_sdk::json_types::U128;
use near_sdk::Gas;
use near_workspaces::{Account, Contract};

pub type TestResult<T> = Result<T, Box<dyn std::error::Error>>;

/// Update share prices for multiple assets in the vault
/// Directly calls dew_vault_update_share_prices as the owner
pub async fn owner_update_vault_share_prices(
    vault: &Contract,
    owner: &Account,
    rates: Vec<(Asset, U128)>,
) -> TestResult<()> {
    let result = owner
        .call(vault.id(), "dew_vault_update_share_prices")
        .args_json(serde_json::json!({
            "rates": rates,
        }))
        .transact()
        .await?
        .into_result()?;

    if !result.logs().is_empty() {
        println!("Logs:");
        for log in result.logs() {
            println!("  {}", log);
        }
    }
    Ok(())
}

/// Process pending deposits with provided share prices
/// Directly calls dew_vault_process_pending_deposits as the owner
pub async fn owner_process_vault_deposits(
    vault: &Contract,
    owner: &Account,
    requests: Vec<(u64, U128)>,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_process_pending_deposits")
        .args_json(serde_json::json!({
            "requests": requests,
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Confirm pending redeems with locked share prices
/// Directly calls dew_vault_confirm_pending_redeems as the owner
pub async fn owner_confirm_vault_redeems(
    vault: &Contract,
    owner: &Account,
    requests: Vec<(u64, U128)>,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_confirm_pending_redeems")
        .args_json(serde_json::json!({
            "requests": requests,
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Process confirmed redeems (execute transfers)
/// Uses ft_transfer_call/mt_transfer_call flow where token_source provides liquidity to vault
/// token_source is typically a user account with sufficient token balance
pub async fn owner_process_vault_redeems(
    vault: &Contract,
    token_source: &Account,
    request_ids: Vec<u64>,
) -> TestResult<()> {
    use near_workspaces::types::{Gas, NearToken};

    println!(
        "Processing {} redeem requests for vault {}",
        request_ids.len(),
        vault.id()
    );

    // Calculate total assets needed from vault state
    let (total_needed, asset) = vault_calculate_redeem_amounts(vault, &request_ids).await?;

    // Create process_redeems message
    let msg = serde_json::json!({
        "is_request": false,
        "min_shares": "0",
        "process_redeems": request_ids
    });

    // Transfer tokens to vault with process_redeems message
    let result = match &asset {
        Asset::FungibleToken { contract_id } => token_source
            .call(contract_id, "ft_transfer_call")
            .args_json(serde_json::json!({
                "receiver_id": vault.id(),
                "amount": total_needed,
                "memo": "Process redeems",
                "msg": msg.to_string()
            }))
            .deposit(NearToken::from_yoctonear(1))
            .gas(Gas::from_tgas(HIGH_GAS))
            .transact()
            .await?
            .into_result()?,
        Asset::MultiToken {
            contract_id,
            token_id,
        } => token_source
            .call(contract_id, "mt_transfer_call")
            .args_json(serde_json::json!({
                "receiver_id": vault.id(),
                "token_id": token_id,
                "amount": total_needed,
                "approval": null,
                "memo": "Process redeems",
                "msg": msg.to_string()
            }))
            .deposit(NearToken::from_yoctonear(1))
            .gas(Gas::from_tgas(HIGH_GAS))
            .transact()
            .await?
            .into_result()?,
    };

    if !result.logs().is_empty() {
        println!("Logs:");
        for log in result.logs() {
            println!("  {}", log);
        }
    }

    println!(
        "Processed {} redeems ({} of {})",
        request_ids.len(),
        total_needed.0,
        asset
    );

    Ok(())
}

/// Reject pending deposit requests
/// Directly calls dew_vault_reject_pending_deposits as the owner
pub async fn owner_reject_pending_deposits(
    vault: &Contract,
    owner: &Account,
    request_ids: Vec<u64>,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_reject_pending_deposits")
        .args_json(serde_json::json!({
            "request_ids": request_ids,
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Reject pending redeem requests
/// Directly calls dew_vault_reject_pending_redeems as the owner
pub async fn owner_reject_pending_redeems(
    vault: &Contract,
    owner: &Account,
    request_ids: Vec<u64>,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_reject_pending_redeems")
        .args_json(serde_json::json!({
            "request_ids": request_ids,
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Claim vault owner fees for a specific asset
/// Directly calls dew_vault_claim_fees as the owner
/// Note: The contract claims all fees owed for this asset automatically
pub async fn owner_claim_vault_fees(
    vault: &Contract,
    owner: &Account,
    asset: Asset,
    _amount: U128, // Amount parameter is kept for compatibility but not used by contract
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_claim_fees")
        .args_json(serde_json::json!({
            "asset": asset,
        }))
        .gas(Gas::from_tgas(HIGH_GAS))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Claim protocol fees for a specific asset
/// Directly calls dew_vault_claim_protocol_fees as the owner
/// Note: The contract claims all protocol fees owed for this asset automatically
pub async fn owner_claim_protocol_fees(
    vault: &Contract,
    owner: &Account,
    asset: Asset,
    _amount: U128, // Amount parameter is kept for compatibility but not used by contract
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_claim_protocol_fees")
        .args_json(serde_json::json!({
            "asset": asset,
        }))
        .gas(Gas::from_tgas(HIGH_GAS))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Crystallize performance fees (update high water mark)
/// Directly calls dew_vault_crystallize_performance_fee as the owner
pub async fn owner_crystallize_performance_fee(
    vault: &Contract,
    owner: &Account,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_crystallize_performance_fee")
        .args_json(serde_json::json!({}))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Unpause the accountant module
/// Directly calls dew_vault_unpause_accountant as the owner
pub async fn owner_unpause_accountant(vault: &Contract, owner: &Account) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_unpause_accountant")
        .args_json(serde_json::json!({}))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Start the vault (enable fee accrual)
/// Directly calls dew_vault_start_vault as the owner
pub async fn owner_start_vault(vault: &Contract, owner: &Account) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_start_vault")
        .args_json(serde_json::json!({}))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Update vault configuration
/// Directly calls dew_vault_update_config as the owner
pub async fn owner_update_vault_config(
    vault: &Contract,
    owner: &Account,
    new_config: serde_json::Value,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_update_config")
        .args_json(serde_json::json!({
            "new_config": new_config,
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Emergency pause/unpause the vault
/// Directly calls dew_vault_emergency_pause as the owner
pub async fn owner_emergency_pause(
    vault: &Contract,
    owner: &Account,
    paused: bool,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_emergency_pause")
        .args_json(serde_json::json!({
            "paused": paused,
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Add account to whitelist
/// Directly calls dew_vault_add_to_whitelist as the owner
pub async fn owner_add_to_whitelist(
    vault: &Contract,
    owner: &Account,
    account_id: &Account,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_add_to_whitelist")
        .args_json(serde_json::json!({
            "account_id": account_id.id(),
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Remove account from whitelist
/// Directly calls dew_vault_remove_from_whitelist as the owner
pub async fn owner_remove_from_whitelist(
    vault: &Contract,
    owner: &Account,
    account_id: &Account,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_remove_from_whitelist")
        .args_json(serde_json::json!({
            "account_id": account_id.id(),
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Add account to blacklist
/// Directly calls dew_vault_add_to_blacklist as the owner
pub async fn owner_add_to_blacklist(
    vault: &Contract,
    owner: &Account,
    account_id: &Account,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_add_to_blacklist")
        .args_json(serde_json::json!({
            "account_id": account_id.id(),
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Remove account from blacklist
/// Directly calls dew_vault_remove_from_blacklist as the owner
pub async fn owner_remove_from_blacklist(
    vault: &Contract,
    owner: &Account,
    account_id: &Account,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_remove_from_blacklist")
        .args_json(serde_json::json!({
            "account_id": account_id.id(),
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Increase available asset balance in vault
/// Directly calls dew_vault_increase_available_asset as the owner
pub async fn owner_increase_available_asset(
    vault: &Contract,
    owner: &Account,
    asset: Asset,
    amount: U128,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_increase_available_asset")
        .args_json(serde_json::json!({
            "asset": asset,
            "amount": amount,
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}

/// Decrease available asset balance in vault
/// Directly calls dew_vault_decrease_available_asset as the owner
pub async fn owner_decrease_available_asset(
    vault: &Contract,
    owner: &Account,
    asset: Asset,
    amount: U128,
) -> TestResult<()> {
    owner
        .call(vault.id(), "dew_vault_decrease_available_asset")
        .args_json(serde_json::json!({
            "asset": asset,
            "amount": amount,
        }))
        .transact()
        .await?
        .into_result()?;

    Ok(())
}