# Construct a transfer instruction to send the tip to Lunar Lander
tip_instruction = transfer(
	TransferParams(
  from_pubkey=payer.pubkey(), # your wallet
  to_pubkey=tip_wallet, # our tip account
  lamports=tip_amount # the tip amount
  )
)

# Build the message with both instructions
message = Message.new_with_blockhash(
  [
    other_instruction, # The other instruction(s) in your transaction you want to submit
    tip_instruction # The tip instruction you made above
  ],
  payer.pubkey(), # your wallet
  recent_blockhash # the recent blockhash
)

# ... now sign the messsage and send it to our endpoint!

use anyhow::{anyhow, Context, Result};
use base64::Engine;
use solana_client::rpc_client::RpcClient;
use solana_sdk::{
    hash::Hash,
    message::Message,
    native_token::LAMPORTS_PER_SOL,
    pubkey::Pubkey,
    signature::{Keypair, Signature, Signer},
    system_instruction,
    transaction::Transaction,
};
use std::str::FromStr;

/// Minimum tip amount in lamports
const MIN_TIP_LAMPORTS: u64 = 1000000;

/// System Program ID
const SYSTEM_PROGRAM_ID: &str = "11111111111111111111111111111111";

/// Configuration loaded from environment
struct Config {
    landing_endpoint: String,
    tip_wallet: String,
    private_key: Option<String>,
}

impl Config {
    fn from_env() -> Result<Self> {
        dotenv::dotenv().ok();

        let landing_endpoint = std::env::var("LANDING_ENDPOINT")
            .context("LANDING_ENDPOINT not set in environment")?;
        let tip_wallet = std::env::var("LANDING_TIP_WALLET")
            .context("LANDING_TIP_WALLET not set in environment")?;
        let private_key = std::env::var("PRIVATE_KEY").ok();

        Ok(Self {
            landing_endpoint,
            tip_wallet,
            private_key,
        })
    }
}

/// Load a Keypair from a base58-encoded private key string
fn load_keypair_from_base58(base58_string: &str) -> Result<Keypair> {
    let key_bytes = bs58::decode(base58_string)
        .into_vec()
        .context("Failed to decode base58 private key")?;
    Keypair::from_bytes(&key_bytes).context("Failed to create keypair from bytes")
}

/// Create a demo transaction that includes:
/// 1. A simple self-transfer (placeholder for your actual transaction logic)
/// 2. A tip transfer to the landing service
fn create_demo_transaction(
    payer: &Keypair,
    recent_blockhash: Hash,
    tip_wallet: &Pubkey,
    tip_amount: u64,
) -> Result<Transaction> {
    if tip_amount < MIN_TIP_LAMPORTS {
        return Err(anyhow!(
            "Tip amount must be at least {} lamports",
            MIN_TIP_LAMPORTS
        ));
    }

    // Instruction 1: Your actual transaction logic goes here
    // This is a placeholder self-transfer of 0 lamports
    let demo_instruction = system_instruction::transfer(&payer.pubkey(), &payer.pubkey(), 0);

    // Instruction 2: Tip transfer to the landing service
    let tip_instruction = system_instruction::transfer(&payer.pubkey(), tip_wallet, tip_amount);

    // Create the transaction with both instructions
    let message = Message::new(&[demo_instruction, tip_instruction], Some(&payer.pubkey()));
    let mut transaction = Transaction::new_unsigned(message);
    transaction.sign(&[payer], recent_blockhash);

    Ok(transaction)
}

/// Print human-readable details of a transaction
fn print_transaction_details(transaction: &Transaction) {
    let message = &transaction.message;

    println!("{}", "=".repeat(60));
    println!("TRANSACTION DETAILS");
    println!("{}", "=".repeat(60));

    // Signatures
    println!("\n📝 SIGNATURES:");
    for (i, sig) in transaction.signatures.iter().enumerate() {
        let sig_str = sig.to_string();
        if sig == &Signature::default() {
            println!("  [{}] (empty/unsigned)", i);
        } else {
            println!("  [{}] {}", i, sig_str);
        }
    }

    // Message header
    let header = &message.header;
    println!("\n📋 MESSAGE HEADER:");
    println!(
        "  Required signatures: {}",
        header.num_required_signatures
    );
    println!(
        "  Read-only signed accounts: {}",
        header.num_readonly_signed_accounts
    );
    println!(
        "  Read-only unsigned accounts: {}",
        header.num_readonly_unsigned_accounts
    );

    // Account keys
    println!(
        "\n🔑 ACCOUNT KEYS ({} accounts):",
        message.account_keys.len()
    );
    for (i, key) in message.account_keys.iter().enumerate() {
        let key_str = key.to_string();
        let mut labels = Vec::new();

        if i < header.num_required_signatures as usize {
            labels.push("signer");
            if i < (header.num_required_signatures - header.num_readonly_signed_accounts) as usize {
                labels.push("writable");
            }
        } else {
            let readonly_unsigned_start =
                message.account_keys.len() - header.num_readonly_unsigned_accounts as usize;
            if i < readonly_unsigned_start {
                labels.push("writable");
            }
        }

        if key_str == SYSTEM_PROGRAM_ID {
            labels.push("System Program");
        }

        let label_str = if labels.is_empty() {
            String::new()
        } else {
            format!(" ({})", labels.join(", "))
        };
        println!("  [{}] {}{}", i, key_str, label_str);
    }

    // Recent blockhash
    println!("\n🔗 RECENT BLOCKHASH:");
    println!("  {}", message.recent_blockhash);

    // Instructions
    println!(
        "\n📦 INSTRUCTIONS ({} total):",
        message.instructions.len()
    );
    for (i, ix) in message.instructions.iter().enumerate() {
        let program_key = &message.account_keys[ix.program_id_index as usize];
        print!("\n  Instruction [{}]:", i);
        print!("\n    Program: {}", program_key);
        if program_key.to_string() == SYSTEM_PROGRAM_ID {
            println!(" (System Program)");
        } else {
            println!();
        }

        println!("    Accounts:");
        for (j, acc_idx) in ix.accounts.iter().enumerate() {
            let acc_key = &message.account_keys[*acc_idx as usize];
            println!("      [{}] {}", j, acc_key);
        }

        // Decode System Program transfer instruction
        if program_key.to_string() == SYSTEM_PROGRAM_ID && ix.data.len() >= 12 {
            let instruction_type = u32::from_le_bytes(ix.data[0..4].try_into().unwrap_or([0; 4]));
            if instruction_type == 2 {
                // Transfer instruction
                let lamports = u64::from_le_bytes(ix.data[4..12].try_into().unwrap_or([0; 8]));
                println!(
                    "    Data (decoded): Transfer {} lamports ({:.9} SOL)",
                    lamports,
                    lamports as f64 / LAMPORTS_PER_SOL as f64
                );
            } else {
                println!("    Data (hex): {}", hex_encode(&ix.data));
            }
        } else {
            println!("    Data (hex): {}", hex_encode(&ix.data));
        }
    }

    // Raw serialized
    let serialized = bincode::serialize(transaction).unwrap_or_default();
    let hex_serialized = hex_encode(&serialized);
    println!("\n📄 RAW SERIALIZED (hex):");
    println!("  {}", hex_serialized);
    println!("\n  Length: {} bytes", serialized.len());
    println!("{}", "=".repeat(60));
}

/// Convert bytes to hex string
fn hex_encode(bytes: &[u8]) -> String {
    bytes.iter().map(|b| format!("{:02x}", b)).collect()
}

/// Send a signed transaction via the landing endpoint using JSON-RPC sendTransaction method
fn send_via_landing_endpoint(
    endpoint: &str,
    transaction: &Transaction,
) -> Result<serde_json::Value> {
    let serialized = bincode::serialize(transaction).context("Failed to serialize transaction")?;
    let base64_encoded = base64::engine::general_purpose::STANDARD.encode(&serialized);

    // Build JSON-RPC request for sendTransaction
    let rpc_request = serde_json::json!({
        "jsonrpc": "2.0",
        "id": 1,
        "method": "sendTransaction",
        "params": [
            base64_encoded,
            {
                "encoding": "base64"
            }
        ]
    });

    let client = reqwest::blocking::Client::new();
    let response = client
        .post(endpoint)
        .json(&rpc_request)
        .timeout(std::time::Duration::from_secs(30))
        .send()
        .context("Failed to send request to landing endpoint")?;

    let json: serde_json::Value = response.json().context("Failed to parse response JSON")?;
    Ok(json)
}

fn main() -> Result<()> {
    println!("=== Solana Transaction Landing Demo (Rust) ===\n");

    // Load configuration
    let config = Config::from_env()?;

    println!("Landing Endpoint: {}", config.landing_endpoint);
    println!("Tip Wallet: {}", config.tip_wallet);
    println!("Minimum Tip: {} lamports\n", MIN_TIP_LAMPORTS);

    // Parse tip wallet pubkey
    let tip_wallet = Pubkey::from_str(&config.tip_wallet)
        .context("Invalid tip wallet pubkey")?;

    // Check if a private key was provided
    let (payer, will_submit) = if let Some(ref pk) = config.private_key {
        println!("Private key found in .env - will submit transaction\n");
        let keypair = load_keypair_from_base58(pk)?;
        println!("Payer Pubkey: {}\n", keypair.pubkey());
        (keypair, true)
    } else {
        println!("No private key found in .env - running in demo mode only");
        println!("To submit transactions, add PRIVATE_KEY=<base58_string> to your .env file\n");
        let keypair = Keypair::new();
        println!("Demo Payer Pubkey: {}", keypair.pubkey());
        println!("(Note: This is a randomly generated keypair for demo purposes)\n");
        (keypair, false)
    };

    // Connect to Solana mainnet to get a recent blockhash - this can also be your node's RPC endpoint
    let rpc_client = RpcClient::new("https://api.mainnet-beta.solana.com".to_string());

    // Get recent blockhash
    let recent_blockhash = rpc_client
        .get_latest_blockhash()
        .context("Failed to get recent blockhash")?;
    println!("Recent Blockhash: {}\n", recent_blockhash);

    // Create the transaction with tip
    println!("Creating transaction with tip instruction...");
    let transaction = create_demo_transaction(
        &payer,
        recent_blockhash,
        &tip_wallet,
        MIN_TIP_LAMPORTS,
    )?;

    println!("Transaction created successfully!\n");

    // Show detailed transaction breakdown
    print_transaction_details(&transaction);
    println!();

    if will_submit {
        // Send via landing endpoint using JSON-RPC sendTransaction
        println!("Sending transaction via landing endpoint...");
        match send_via_landing_endpoint(&config.landing_endpoint, &transaction) {
            Ok(result) => {
                println!("Response: {:?}", result);
                // Extract signature from JSON-RPC response
                if let Some(sig) = result.get("result").and_then(|r| r.as_str()) {
                    println!("Signature: {}", sig);
                    println!("View on Solscan: https://solscan.io/tx/{}", sig);
                }
            }
            Err(e) => println!("Error sending transaction: {}", e),
        }
    } else {
        println!("Demo complete! (transaction not submitted)");
        println!("\nTo submit transactions, add your private key to .env:");
        println!("PRIVATE_KEY=<your_base58_encoded_private_key>");
    }

    Ok(())
}