use solana_client::rpc_client::RpcClient;
use solana_sdk::pubkey::Pubkey;
use bs58;
use solana_sdk::instruction::Instruction;
use solana_sdk::message::Message;
use solana_client::rpc_response::RpcConfirmedTransactionStatusWithSignature;
use solana_client::rpc_response::EncodedConfirmedTransactionWithStatusMeta;
use solana_sdk::transaction::Transaction;

fn base58_to_pubkey(address: &str) -> Result<Pubkey, Box<dyn std::error::Error>> {
    let decoded = bs58::decode(address).into_vec()?;
    if decoded.len() != 32 {
        return Err("Address must be 32 bytes long".into());
    }
    let mut bytes = [0u8; 32];
    bytes.copy_from_slice(&decoded);
    Ok(Pubkey::new_from_array(bytes))
}

fn is_token_creation(instruction: &Instruction) -> bool {
    // L'instruction de création de token a un discriminant de 0
    if instruction.data.len() < 1 {
        return false;
    }
    instruction.data[0] == 0
}

fn main() {
    let rpc_url = "https://api.mainnet-beta.solana.com";
    let client = RpcClient::new(rpc_url.to_string());

    // Adresse du programme Token (SPL Token Program)
    let token_program_address = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA";
    
    match base58_to_pubkey(token_program_address) {
        Ok(token_program) => {
            println!("Récupération des transactions pour le programme Token...");
            
            // Récupérer les transactions associées au programme Token
            let transactions = client.get_signatures_for_address(&token_program);

            match transactions {
                Ok(sigs) => {
                    println!("Nombre total de transactions trouvées : {}", sigs.len());
                    for sig in sigs.iter().take(10) {  // Limiter à 10 transactions pour commencer
                        // Récupérer les détails de la transaction
                        match client.get_transaction(&sig.signature, solana_client::rpc_config::RpcTransactionConfig {
                            encoding: Some(solana_client::rpc_config::RpcTransactionEncoding::Base64),
                            commitment: Some(solana_client::rpc_config::RpcTransactionLogsConfig {
                                commitment: Some(solana_client::rpc_config::CommitmentConfig::confirmed()),
                                max_supported_transaction_version: Some(0),
                            }),
                            max_supported_transaction_version: Some(0),
                        }) {
                            Ok(tx) => {
                                println!(tx.transaction.meta);

                                //if let Some(meta) = tx.transaction.meta {
                                    //println!(meta);
                                    // Vérifier si c'est une création de token
                                    //let is_token_creation = meta.inner_instructions.iter().any(|inner| {
                                      //  inner.instructions.iter().any(|ix| {
                                            //if let Ok(instruction) = ix.try_into() {
                                                //is_token_creation(&instruction)
                                            //} else {
                                               // false
                                            //}
                                       // })
                                    //});

                                    //if is_token_creation {
                                        //println!("Création de token trouvée :");
                                        //println!("  Signature: {}", sig.signature);
                                        //println!("  Slot: {}", sig.slot);
                                        //println!("  Block time: {:?}", sig.block_time);
                                        //println!("  Status: {:?}", meta.err);
                                        //println!("---");
                                    //}
                               // }
                            }
                            Err(err) => eprintln!("Erreur lors de la récupération de la transaction : {:?}", err),
                        }
                    }
                }
                Err(err) => eprintln!("Erreur lors de la récupération des transactions : {:?}", err),
            }
        }
        Err(err) => eprintln!("Erreur lors de la conversion de l'adresse : {:?}", err),
    }
}