// 添加依赖到Cargo.toml
// agave-transaction-view = "3.0.0"

use agave_transaction_view::{
    transaction_view::TransactionView, 
    transaction_view_item::TransactionViewItem
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建交易视图实例
    let mut transaction_view = TransactionView::new();
    
    // 解析区块链交易数据
    let transaction_data = vec![
        // 示例交易数据
        TransactionViewItem {
            account_key: "Account1".to_string(),
            pre_lamports: 1000,
            post_lamports: 900,
            // 其他交易字段...
        },
        TransactionViewItem {
            account_key: "Account2".to_string(),
            pre_lamports: 500,
            post_lamports: 600,
            // 其他交易字段...
        }
    ];
    
    // 添加交易项到视图
    for item in transaction_data {
        transaction_view.add_item(item);
    }
    
    // 高效管理交易数据
    println!("交易总数: {}", transaction_view.len());
    
    // 获取特定账户的交易信息
    if let Some(account_info) = transaction_view.get_account_info("Account1") {
        println!("账户1余额变化: {} -> {}", account_info.pre_lamports, account_info.post_lamports);
    }
    
    // 批量处理交易数据
    transaction_view.process_transactions(|items| {
        for item in items {
            println!("处理交易: {}", item.account_key);
        }
    });
    
    Ok(())
}

// 完整示例：解析和管理Solana交易数据
#[cfg(test)]
mod tests {
    use super::*;
    use agave_transaction_view::transaction_status::TransactionStatus;
    
    #[test]
    fn test_transaction_parsing() {
        let mut view = TransactionView::new();
        
        // 模拟区块链交易数据
        let transaction_items = vec![
            TransactionViewItem {
                account_key: "11111111111111111111111111111111".to_string(),
                pre_lamports: 0,
                post_lamports: 0,
                // 其他必要字段...
            },
            TransactionViewItem {
                account_key: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA".to_string(),
                pre_lamports: 1000000000,
                post_lamports: 999999900,
                // 其他必要字段...
            }
        ];
        
        // 添加并验证交易数据
        for item in transaction_items {
            view.add_item(item);
        }
        
        assert_eq!(view.len(), 2);
        assert!(view.get_account_info("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA").is_some());
    }
    
    #[test]
    fn test_transaction_processing() {
        let view = TransactionView::new();
        
        // 处理交易状态
        let status = TransactionStatus::Confirmed;
        println!("交易状态: {:?}", status);
        
        // 这里可以添加更多交易处理逻辑
        assert!(matches!(status, TransactionStatus::Confirmed));
    }
}

这个示例展示了如何使用agave-transaction-view库来：

1. 创建交易视图实例
2. 解析区块链交易数据
3. 添加和管理交易项
4. 获取特定账户信息
5. 批量处理交易数据
6. 处理交易状态

库提供了高效的数据结构和方法来处理区块链交易数据，特别适合Solana等区块链的交易视图处理需求。

完整示例demo：

// Cargo.toml 依赖配置
// [dependencies]
// agave-transaction-view = "3.0.0"

use agave_transaction_view::{
    transaction_view::TransactionView,
    transaction_view_item::TransactionViewItem,
    transaction_status::TransactionStatus
};
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化交易视图
    let mut transaction_view = TransactionView::new();
    
    // 模拟从区块链节点获取的交易数据
    let transactions = simulate_blockchain_transactions();
    
    // 添加所有交易项到视图
    for transaction in transactions {
        transaction_view.add_item(transaction);
    }
    
    // 显示交易统计信息
    display_transaction_stats(&transaction_view);
    
    // 处理特定账户的交易
    process_specific_accounts(&transaction_view);
    
    // 批量处理所有交易
    batch_process_transactions(&transaction_view);
    
    // 检查交易状态
    check_transaction_status();
    
    Ok(())
}

/// 模拟区块链交易数据生成
fn simulate_blockchain_transactions() -> Vec<TransactionViewItem> {
    vec![
        TransactionViewItem {
            account_key: "SystemProgram11111111111111111111111111".to_string(),
            pre_lamports: 1000000000,
            post_lamports: 999999000,
            // 其他字段可根据实际需求添加
            // instruction_count: 1,
            // signature: "5ver...".to_string(),
            // timestamp: 1633046400,
        },
        TransactionViewItem {
            account_key: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA".to_string(),
            pre_lamports: 500000000,
            post_lamports: 499999500,
            // 其他字段...
        },
        TransactionViewItem {
            account_key: "Vote111111111111111111111111111111111111111".to_string(),
            pre_lamports: 200000000,
            post_lamports: 199999800,
            // 其他字段...
        }
    ]
}

/// 显示交易统计信息
fn display_transaction_stats(view: &TransactionView) {
    println!("=== 交易统计 ===");
    println!("总交易数: {}", view.len());
    println!("账户数量: {}", get_unique_account_count(view));
}

/// 获取唯一账户数量
fn get_unique_account_count(view: &TransactionView) -> usize {
    let mut accounts = HashMap::new();
    // 这里假设有遍历交易项的方法
    // 实际实现可能需要根据库的具体API调整
    accounts.len()
}

/// 处理特定账户的交易
fn process_specific_accounts(view: &TransactionView) {
    println!("\n=== 特定账户处理 ===");
    
    let target_accounts = vec![
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
        "SystemProgram11111111111111111111111111"
    ];
    
    for account in target_accounts {
        if let Some(info) = view.get_account_info(account) {
            println!("账户 {}: {} lamports -> {} lamports", 
                    account, info.pre_lamports, info.post_lamports);
            let change = info.post_lamports as i64 - info.pre_lamports as i64;
            println!("余额变化: {} lamports", change);
        }
    }
}

/// 批量处理交易数据
fn batch_process_transactions(view: &TransactionView) {
    println!("\n=== 批量交易处理 ===");
    
    view.process_transactions(|items| {
        for (index, item) in items.iter().enumerate() {
            println!("交易 {}: 账户 {}", index + 1, item.account_key);
            println!("  前余额: {} lamports", item.pre_lamports);
            println!("  后余额: {} lamports", item.post_lamports);
            
            // 这里可以添加更多的处理逻辑，如：
            // - 验证交易签名
            // - 检查余额变化是否合理
            // - 记录交易日志
            // - 更新数据库等
        }
    });
}

/// 检查交易状态
fn check_transaction_status() {
    println!("\n=== 交易状态检查 ===");
    
    let statuses = vec![
        TransactionStatus::Confirmed,
        TransactionStatus::Finalized,
        TransactionStatus::Processed,
    ];
    
    for status in statuses {
        match status {
            TransactionStatus::Confirmed => println!("交易状态: 已确认"),
            TransactionStatus::Finalized => println!("交易状态: 已最终确认"),
            TransactionStatus::Processed => println!("交易状态: 已处理"),
            // 处理其他可能的状态
            _ => println!("交易状态: 未知"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_transaction_processing() {
        let mut view = TransactionView::new();
        let test_data = vec![
            TransactionViewItem {
                account_key: "TestAccount1".to_string(),
                pre_lamports: 1000,
                post_lamports: 900,
            },
            TransactionViewItem {
                account_key: "TestAccount2".to_string(),
                pre_lamports: 2000,
                post_lamports: 2100,
            }
        ];
        
        for item in test_data {
            view.add_item(item);
        }
        
        assert_eq!(view.len(), 2);
        assert!(view.get_account_info("TestAccount1").is_some());
        assert!(view.get_account_info("TestAccount2").is_some());
    }
    
    #[test]
    fn test_balance_calculation() {
        let item = TransactionViewItem {
            account_key: "TestAccount".to_string(),
            pre_lamports: 1000,
            post_lamports: 1100,
        };
        
        let balance_change = item.post_lamports as i64 - item.pre_lamports as i64;
        assert_eq!(balance_change, 100);
    }
}