// 示例代码：使用solana-svm-rent-collector管理账户租金

use solana_svm_rent_collector::RentCollector;
use solana_sdk::{
    account::{Account, AccountSharedData},
    clock::Epoch,
    pubkey::Pubkey,
    rent::Rent,
    sysvar::rent,
};

fn main() {
    // 创建租金收集器实例
    let rent_collector = RentCollector::default();
    
    // 模拟账户数据
    let account_pubkey = Pubkey::new_unique();
    let mut account = AccountSharedData::new(100_000, 0, &Pubkey::default());
    
    // 设置当前epoch
    let current_epoch = Epoch::default();
    
    // 检查账户是否需要支付租金
    let rent_due = rent_collector.collect_rent(
        &account_pubkey,
        &mut account,
        current_epoch,
        |lamports| {
            // 租金支付回调函数
            println!("支付租金: {} lamports", lamports);
            Ok(())
        },
    );
    
    match rent_due {
        Ok(rent_paid) => {
            if rent_paid > 0 {
                println!("成功支付租金: {} lamports", rent_paid);
            } else {
                println!("无需支付租金");
            }
        }
        Err(err) => {
            eprintln!("租金收集失败: {:?}", err);
        }
    }
    
    // 批量处理多个账户
    let accounts = vec![
        (Pubkey::new_unique(), AccountSharedData::new(50_000, 0, &Pubkey::default())),
        (Pubkey::new_unique(), AccountSharedData::new(200_000, 0, &Pubkey::default())),
    ];
    
    process_accounts_batch(accounts, &rent_collector, current_epoch);
}

fn process_accounts_batch(
    accounts: Vec<(Pubkey, AccountSharedData)>,
    rent_collector: &RentCollector,
    current_epoch: Epoch,
) {
    for (pubkey, mut account) in accounts {
        let rent_result = rent_collector.collect_rent(
            &pubkey,
            &mut account,
            current_epoch,
            |lamports| {
                println!("为账户 {} 支付租金: {} lamports", pubkey, lamports);
                Ok(())
            },
        );
        
        if let Ok(rent_paid) = rent_result {
            println!("账户 {} 租金处理完成，支付: {} lamports", pubkey, rent_paid);
        }
    }
}

// 自定义租金配置示例
fn custom_rent_configuration() {
    let custom_rent = Rent {
        lamports_per_byte_year: 3_480,      // 每字节每年的租金
        exemption_threshold: 2.0,           // 豁免阈值
        burn_percent: 50,                   // 燃烧百分比
    };
    
    let rent_collector = RentCollector::new(custom_rent);
    println!("使用自定义租金配置: {:?}", rent_collector.rent());
}

// 租金豁免检查
fn check_rent_exemption(rent_collector: &RentCollector, account: &AccountSharedData) -> bool {
    rent_collector.is_exempt(account.lamports(), account.data().len())
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_rent_collection() {
        let rent_collector = RentCollector::default();
        let pubkey = Pubkey::new_unique();
        let mut account = AccountSharedData::new(500_000, 1000, &Pubkey::default());
        
        let result = rent_collector.collect_rent(
            &pubkey,
            &mut account,
            Epoch::default(),
            |_| Ok(()),
        );
        
        assert!(result.is_ok());
    }
}

// 完整示例：完整的Solana程序租金管理

use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    program_error::ProgramError,
    pubkey::Pubkey,
    rent::Rent,
    sysvar::Sysvar,
};
use solana_svm_rent_collector::RentCollector;

// 程序入口点
entrypoint!(process_instruction);

fn process_instruction(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    instruction_data: &[u8],
) -> ProgramResult {
    // 获取账户迭代器
    let accounts_iter = &mut accounts.iter();
    
    // 获取需要支付租金的账户
    let account_to_pay_rent = next_account_info(accounts_iter)?;
    
    // 验证程序所有权
    if account_to_pay_rent.owner != program_id {
        return Err(ProgramError::IncorrectProgramId);
    }
    
    // 创建租金收集器
    let rent_collector = RentCollector::default();
    
    // 获取当前租金sysvar
    let rent = Rent::get()?;
    
    msg!("开始处理租金支付");
    
    // 收集租金
    let rent_due = rent_collector.collect_rent(
        account_to_pay_rent.key,
        &mut account_to_pay_rent.try_borrow_mut_data()?,
        0, // 当前epoch
        |lamports| {
            msg!("从账户扣除租金: {} lamports", lamports);
            // 在实际应用中，这里会处理lamports的转移
            Ok(())
        },
    )?;
    
    msg!("租金处理完成，支付金额: {} lamports", rent_due);
    
    Ok(())
}

// 辅助函数：检查账户是否租金豁免
pub fn is_account_rent_exempt(account: &AccountInfo) -> Result<bool, ProgramError> {
    let rent = Rent::get()?;
    Ok(rent.is_exempt(account.lamports(), account.data_len()))
}

// 辅助函数：计算所需租金
pub fn calculate_rent_required(data_len: usize) -> Result<u64, ProgramError> {
    let rent = Rent::get()?;
    Ok(rent.minimum_balance(data_len))
}

#[cfg(test)]
mod tests {
    use super::*;
    use solana_program_test::*;
    use solana_sdk::{account::Account, signature::Signer, transaction::Transaction};
    
    #[tokio::test]
    async fn test_rent_payment() {
        // 设置测试环境
        let program_id = Pubkey::new_unique();
        let mut program_test = ProgramTest::new(
            "rent_management_program",
            program_id,
            processor!(process_instruction),
        );
        
        // 创建测试账户
        let user = Keypair::new();
        let rent_exempt_balance = Rent::default().minimum_balance(100);
        
        let test_account = Account {
            lamports: rent_exempt_balance + 1000, // 额外资金用于支付租金
            data: vec![0; 100],
            owner: program_id,
            executable: false,
            rent_epoch: 0,
        };
        
        program_test.add_account(user.pubkey(), Account::new(1000000000, 0, &program_id));
        program_test.add_account(Pubkey::new_unique(), test_account);
        
        // 运行测试
        let (mut banks_client, payer, recent_blockhash) = program_test.start().await;
        
        let mut transaction = Transaction::new_with_payer(
            &[/* 指令数据 */],
            Some(&payer.pubkey()),
        );
        
        transaction.sign(&[&payer], recent_blockhash);
        banks_client.process_transaction(transaction).await.unwrap();
    }
}