Optimization

// Bad: Multiple comparisons
let a_gt_b = a.gt(&b)?;
let b_gt_c = b.gt(&c)?;
let c_gt_d = c.gt(&d)?;

// Better: Rethink the algorithm to minimize comparisons

// Good: u8 for small values
let price: Encrypted<u8> = price_ref.load()?;  // ~10KB ciphertext

// Avoid: u64 when not needed
let price: Encrypted<u64> = price_ref.load()?;  // ~80KB ciphertext

// Good
let price = price_ref.load()?;
let result1 = price.add(&a)?;
let result2 = price.add(&b)?;

// Bad
let result1 = price_ref.load()?.add(&a)?;
let result2 = price_ref.load()?.add(&b)?; // Extra load!

// Good: All arithmetic first
let sum1 = a.add(&b)?;
let sum2 = c.add(&d)?;
let comparison = sum1.ge(&sum2)?;

// Avoid: Interleaving
let comparison1 = a.ge(&b)?;
let sum = c.add(&d)?;
let comparison2 = sum.ge(&e)?;

// Good
let min = a.min(&b)?;

// Bad
let is_smaller = a.lt(&b)?;
let min = is_smaller.select(&a, &b)?;

// Good: Single store
let result = a.add(&b)?.mul(&c)?;
let result_ref = result.store()?;

// Avoid: Multiple stores
let sum = a.add(&b)?;
let sum_ref = sum.store()?;  // Unnecessary intermediate store

// Good: Minimal on-chain storage
pub struct Order {
    pub owner: Pubkey,           // 32 bytes
    pub price_ref: EncryptedRef<u8>,  // 32 bytes (not 10KB!)
    pub qty_ref: EncryptedRef<u8>,    // 32 bytes
}
// Total: 96 bytes

// Bad: Storing raw ciphertexts
pub struct Order {
    pub price_data: [u8; 10000],  // 10KB on-chain!
}

// Default: ~1MB heap
privora_sdk_program::setup_fhe_allocator!();

// If needed: larger heap
privora_sdk_program::setup_fhe_allocator!(2 * 1024 * 1024);

// Instead of checking both conditions
let a_ge_b = a.ge(&b)?;
let a_lt_b = a.lt(&b)?;  // Redundant!

// Use one comparison and derive
let a_ge_b = a.ge(&b)?;
// a_lt_b is the logical negation

// If computing: encrypted_a + plaintext_constant
// Consider: encrypt(plaintext_a + plaintext_constant) on client
// Then send single encrypted value

#[test]
fn benchmark_operations() {
    let mut env = FheTestEnv::new();

    let start = std::time::Instant::now();

    // Perform operations...

    println!("Time: {:?}", start.elapsed());
}