Untitled

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::sync::mpsc::{channel, Receiver, Sender};

struct Joiner{
    senders: Arc<Vec<Sender<f64>>>,
    receivers: Vec<Receiver<f64>>
}

struct SingleJoiner{
    num_threads: usize,
    senders: Mutex<Arc<Vec<Sender<f64>>>>,
    receiver: Receiver<f64>
}

impl Joiner {
    fn new(n: usize) -> Self{
        let mut listsenders = Vec::new();
        let mut listreceivers = Vec::new();
        for i in 0..n{
            let (sender, receiver) = channel();
            listreceivers.push(receiver);
            listsenders.push(sender);
        }
        return Joiner{
            senders: Arc::new(listsenders),
            receivers: listreceivers
        }
    }
}

impl SingleJoiner {
    fn new(senders: Mutex<Arc<Vec<Sender<f64>>>>, receiver: Receiver<f64>, num_threads: usize) -> Self{
        return SingleJoiner{
            num_threads,
            senders,
            receiver
        }
    }

    fn supply(&self, num_thread: usize) -> HashMap<usize, f64>{
        let mut res = HashMap::new();
        //genero valore
        let val = 1.064;
        //invio sui canali tranne il mio
        let lock = self.senders.lock().unwrap();
        for i in 0..self.num_threads{
            if i != num_thread{
                lock[i].send(val);
            }
        }

        for i in 0..self.num_threads-1{
            res.insert(i, self.receiver.recv().unwrap());
        }

        return res;
    }
}

fn main() {
    let mut threads = Vec::new();

    let mut joiner = Joiner::new(3);

    for i in 0..3{
        let singlejoiner = SingleJoiner::new(Mutex::new(joiner.senders.clone()), joiner.receivers.pop().unwrap(), 3);
        threads.push(std::thread::spawn(move || {
            for j in 0..10{
                let res = singlejoiner.supply(i);
                println!("Il thread {}, al ciclo {}, ha stampato: {:?}", i, j, res);
            }
        }))
    }

    for i in threads{
        i.join().unwrap();
    }

}