use log::{error, info};
use std::sync::Arc;
use tokio::signal::unix::{SignalKind, signal};
use tokio::sync::Mutex;
use tokio::sync::mpsc;
use tokio::sync::mpsc::{Receiver, Sender};

async fn shutdown_signal(mut rx: Receiver<String>) {
    // перехватчик сигнала SIGTERM
    let _terminate = signal(SignalKind::terminate())
        .expect("failed to install signal handler") // если не удалось поставить handler
        .recv() // ожидаем следующий сигнал
        .await; // await

    println!("SIGTERM received!");

    match rx.recv().await {
        Some(x) => {
            println!("gotcha!");
            println!("string from thread: {}", x)
        }
        None => (),
    }
    std::process::exit(0); // Graceful exit
}

async fn test_fx(tx: Arc<Mutex<Option<Sender<String>>>>) {
    let tx = tx.lock().await.as_ref().cloned().unwrap();

    let mut s = 0;
    
    for i in 1..100 {
        // some hard work
        s += i;
        tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
    }
    
    let _res = tx.send(format!("-> {}", s)).await;
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Hello, world!");

    let (tx, mut rx) = mpsc::channel::<String>(1);
    let shared_tx = Arc::new(Mutex::new(Some(tx)));

    tokio::spawn(async move {
        shutdown_signal(rx).await;
    });

    println!("test");

    let tx = shared_tx.clone();
    tokio::spawn(async move { test_fx(tx).await });

    println!("test2");

    loop {
        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    };

}