use anyhow::Result;
use crossbeam::channel::{unbounded, Receiver, TryRecvError};
use lasprs::daq::{InStreamMsg, StreamHandler, StreamMgr, StreamStatus, StreamType};
use lasprs::siggen::Siggen;
use std::io;
use std::{thread, time};
// use

fn spawn_stdin_channel() -> Receiver<String> {
    let (tx, rx) = unbounded();
    thread::spawn(move || 'tt: loop {
        let mut buffer = String::new();
        io::stdin().read_line(&mut buffer).unwrap();
        if let Err(_) = tx.send(buffer) {
            break 'tt;
        }
    });
    rx
}
fn sleep(millis: u64) {
    let duration = time::Duration::from_millis(millis);
    thread::sleep(duration);
}
fn main() -> Result<()> {
    let mut smgr = StreamMgr::new();

    println!("Starting stream...");
    smgr.startDefaultOutputStream()?;
    let stdin_channel = spawn_stdin_channel();

    println!("Creating signal generator...");
    let mut siggen = Siggen::newSineWave(2, 100.);
    siggen.setDCOffset(&[0.1, 0.]);
    // let mut siggen = Siggen::newWhiteNoise(2);
    siggen.setAllGains(0.1);
    // siggen.setMute(&[true, true]);
    // siggen.setMute(&[true, false]);
    // siggen.setAllMute(false);
    smgr.setSiggen(siggen)?;

    'infy: loop {
        match stdin_channel.try_recv() {
            Ok(_key) => break 'infy,
            Err(TryRecvError::Empty) => {}
            Err(TryRecvError::Disconnected) => panic!("Channel disconnected"),
        }
        sleep(1000);
        match smgr.getStatus(StreamType::Output) {
            StreamStatus::NotRunning => {
                println!("Stream is not running?");
                break 'infy;
            }
            StreamStatus::Running => {
                println!("Stream is running...");
            }
            StreamStatus::Error(e) => {
                println!("Stream error: {}", e);
                break 'infy;
            }
        }

        // let stat = smgr.
    }

    Ok(())
}