use super::Message;
use std::collections::{HashSet, HashMap};
use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread::JoinHandle;

struct InBuffer {
    receiver: Receiver<Message>,
    row_requests: HashMap<u64, Vec<u32>>,
    results_requests: HashMap<u64, Vec<u64>>,

}

impl InBuffer {
    fn new(receiver: Receiver<Message>) -> Self {
        Self {
            receiver,
            row_requests: HashMap::new(),
            results_requests: HashMap::new(),
        }
    }
    fn read(&mut self) -> Option<Result> {
        loop {
            match self.receiver.recv() {
                Message::OutputMessage((id, ResultMessage)) => {
                    if Some(result) = self.results_requests.get(id) {
                        Some(RowResult::new()
                    }
                    else {
                        self.row_requests.insert(id, walls);}
            }
        }
    }

}

#[derive(PartialEq, Eq, Hash)]
struct RowResult {
    rows: Vec<u32>,
}

impl RowResult {
    fn new(rows: Vec<u32>) -> Self {
        rows.push(0);
        Self { rows }
    }
    fn output(&self) {
        println!("{:?}", self.rows);
    }
}

pub struct Output {
    input: InBuffer,
    receiver: Receiver<Message>,
    permutations: Vec<Vec<u32>>,
    permutations_mask: Vec<u64>,
    results: HashSet<RowResult>,
}

impl Output {
    fn launch_sevice(
        permutations: &[Vec<u32>],
        permutation_masks: &[u64],
    ) -> (Sender<Message>, JoinHandle<String>) {
        let (sender, receiver) = channel();
        let input = InBuffer::new(receiver);

        let output = Self {
            input,
            permutations: permutations.into(),
            permutation_masks: permutation_masks.into(),
            HashSet::new(),
        }
        (
            sender,
            std::thread::Builder::new()
                .name("GPU Manager Deamon".into())
                .spawn(move || {
                    output.run();
                })
                .unwrap(),
        )
    }

    fn run(mut self) {
        loop {
            match self.receiver.recv() {
                Message::OutputMessage((id, ResultMessage)) => {
                    if Some(result) = self.results_requests.get(id) {
                        Some(RowResult::new()
                    }
                    else {
                        self.row_requests.insert(id, walls);}
            }
        }
    }
}