use std::sync::{Arc, RwLock};
use std::thread;
use std::time::Duration;


// Reduzierter Server mit einer gemeinsamen Ressource `data`
struct Server {
    data: Arc<RwLock<usize>>,
}

impl Server {
    fn new() -> Self {
        Server {
            data: Arc::new(RwLock::new(0)),
        }
    }

    // Auch einmalige Aktionen können in `loop` threads ausgeführt werden.
    // Hier ist aber wichtig das wenn. die Aktion erfolgreich war,
    // der loop mit `break` unterbrochen wird.
    //
    // ```
    // thread::spawn(move || loop {
    //     if let Ok(data) = data.write() {
    //         *data = 0000;
    //         break;
    //     }
    // });
    // ```
    //
    // Alternative kann auch der `loop` weg gelassen werden. Dann muss aber
    // eine `while let` Anweisung Anstelle der `if let` verwendet werden.
    //
    // ```
    // thread::spawn(move || {
    //     while let Ok(data) = data.write() {
    //         *data = 0000;
    //         break;
    //     }
    // });
    // ```
    //
    // In der zweiten Version wird der `loop` nur einfach verschoben.


    // Der erste Thread soll data ein mal schreiben
    fn start_thread0(&self) {
        let data = self.data.clone();
        thread::spawn(move || {
            // warte 3ms und versuche dann die data zu schreiben
            thread::sleep(Duration::from_millis(3));
            while let Ok(mut data) = data.write() {
                println!(">> thread 0 write");
                *data = 9999;
                break;
            }
        });
    }

    // Der zweite Thread, der Hauptthread, schreibt unentwegt data.
    // Dabei blockiert der Thread nach jedem schreiben für 10ms, damit der lock
    // nicht gleich wieder frei gegeben wird.
    fn start_thread1(&self) {
        let data = self.data.clone();
        thread::spawn(move || loop {
            if let Ok(mut data) = data.write() {
                println!("thread 1 write");
                *data += 1;
                thread::sleep(Duration::from_millis(10));
            }
            // dieses sleep ist sehr wichtig. In dieser 1ms bekommen die anderen
            // thread die Möglichkeit ausgeführt zu werden.
            thread::sleep(Duration::from_millis(1));
        });
    }

    // Der dritte Thread liest die gemeinsame Ressource alle 30ms
    fn start_thread2(&self) {
        let data = self.data.clone();
        thread::spawn(move || loop {
            if let Ok(data) = data.read() {
                println!("thread 2 read");
                println!("\t|_data: {}", data);
            }
            thread::sleep(Duration::from_millis(30));
        });
    }
}


fn main() {
    let server = Server::new();
    // schreiben, ein mal
    server.start_thread0();
    // schreiben
    server.start_thread1();
    // lesen
    server.start_thread2();

    // Alles läuft in diesem Beispiel 100ms
    thread::sleep(Duration::from_millis(100));
}