pcsc-mon 0.2.2

use std::{
    process, sync::atomic::{AtomicBool, Ordering}, thread, time::Duration
};

use rand::Rng;

use pcsc_mon::PcscMonitor;

static RUNNING: AtomicBool = AtomicBool::new(true);

fn main() -> anyhow::Result<()> {
    let mut monitor = PcscMonitor::instance();
    monitor.on_card_inserted(|_ctx, card| {
        let mut buf: [u8; 2048] = [0; 2048];
        match card.get_attribute(pcsc::Attribute::AtrString, &mut buf) {
            Ok(atr) => println!("Card ATR: {:02X?}", atr),
            Err(err) => eprintln!("Failed to read ATR: {:?}", err),
        }

        let mut rng = rand::thread_rng();
        let chance: f32 = rng.gen();

        if chance > 0.7 {
            panic!("intentional panic to poison mutex");
        }
    });
    monitor.on_card_removed(move |reader| {
        println!("Card removed from reader: {}", reader);
        let mut rng = rand::thread_rng();
        let chance: f32 = rng.gen();

        if chance > 0.7 {
            panic!("intentional panic to poison mutex");
        }
    });
    monitor.on_reader_added(move |reader| {
        println!("Reader added: {}", reader);
        let mut rng = rand::thread_rng();
        let chance: f32 = rng.gen();

        if chance > 0.7 {
            panic!("intentional panic to poison mutex");
        }
    });
    monitor.on_reader_removed(move |reader| {
        println!("Reader removed: {}", reader);
        let mut rng = rand::thread_rng();
        let chance: f32 = rng.gen();

        if chance > 0.7 {
            panic!("intentional panic to poison mutex");
        }
    });
    monitor.on_error(move |e| {
        match e {
            pcsc_mon::ReaderError::Pcsc(error) => println!("PCSC Error: {:?}", error),
            pcsc_mon::ReaderError::ReaderStatePoisoned => {
                println!("Reader State poisoned!!! KMN");
                process::exit(1);
            }
            pcsc_mon::ReaderError::KnownReadersPoisoned => {
                println!("Known Readers poisoned!!! KMN");
                process::exit(1);
            }
            pcsc_mon::ReaderError::HandlerPanicked(error) => println!("Handler Error {:?}", error),
        }
        let mut rng = rand::thread_rng();
        let chance: f32 = rng.gen();

        if chance > 0.7 {
            panic!("I'm just f**king with you");
        }
    });
    monitor.start();

    let _ = ctrlc::set_handler(|| {
        RUNNING.store(false, Ordering::SeqCst);
    });

    eprintln!("pcsc-monitor running… press Ctrl+C to quit.");
    while RUNNING.load(Ordering::SeqCst) {
        thread::sleep(Duration::from_millis(200));
    }

    Ok(())
    // If you have a graceful stop API, call it here:
    // m.stop();
}