extern crate native;

use std::comm::{Sender, Receiver, TryRecvResult, Data, channel};

struct Master<'a> {
    chan_wc_to_engine: Sender<uint>,
    chan_wc_from_engine: Receiver<uint>,
    chan_engine_to_wc: Sender<uint>,
    chan_engine_from_wc: Receiver<uint>,
}

impl<'a> Master<'a> {
    fn new() -> Master<'a> {

        let (chan_wc_to_engine, chan_engine_from_wc) = channel();
        let (chan_engine_to_wc, chan_wc_from_engine) = channel();

        let master =  Master{ chan_wc_to_engine: chan_wc_to_engine,
                              chan_wc_from_engine: chan_wc_from_engine,
                              chan_engine_to_wc: chan_engine_to_wc,
                              chan_engine_from_wc: chan_engine_from_wc,
        };

        master
    }

    fn start_engine(&self) {

        println!("start_engine");

        native::task::spawn( proc() {

            println!("process");
            self.chan_engine_to_wc.send(42); // ***
            println!("done");
        });

    }

    fn listen(&self) {
        println!("listen");
        let indata = self.chan_wc_from_engine.recv();
        println!("indata = {}", indata);
    }
}

fn main() {
    let m = Master::new();
    m.start_engine();
    m.listen();
    println!("fin");
}