#[macro_use]
use ocl::{Buffer, Context, Device, Platform, Program, Queue};
use std::sync::mpsc::{Receiver, Sender};

pub struct Job {
    rows: Vec<u32>,
    bitmask: u64,
}

pub struct GpuSolver {
    platform: Platform,
    device: Device,
    context: Context,
    queue: Queue,
    n: u32,
    h: u32,
    w: u32,
    permutations: Buffer<u64>,
    rec_queues: Vec<Receiver<Job>>,
}

impl GpuSolver {
    pub fn new(permutation_masks: &[u64], n: u32, h: u32, w: u32) -> ocl::Result<Vec<Sender<Job>>> {
        let platform = ocl::Platform::default();
        let device = ocl::Device::first(platform)?;
        let context = ocl::Context::builder()
            .platform(platform)
            .devices(device.clone())
            .build()?;
        let queue = ocl::Queue::new(&context, device, None)?;

        let buffer = ocl::Buffer::builder()
            .queue(queue.clone())
            .copy_host_slice(permutation_masks)
            .len(permutation_masks.len())
            .build()?;

        let mut senders = Vec::with_capacity(h as usize);
        let mut receivers = Vec::with_capacity(h as usize);
        for _ in 0..h {
            let (sx, rx) = std::sync::mpsc::channel();
            senders.push(sx);
            receivers.push(rx);
        }

        let solver = Self {
            platform,
            device,
            context,
            queue,
            n,
            h,
            w,
            permutations: buffer,
            rec_queues: receivers,
        };
        std::thread::spawn(move || {
            solver.run();
        });
        Ok(senders)
    }

    fn run(self) -> ! {
        for rec in self.rec_queues.iter().cycle() {
            //if rec.
        }
        loop {}
    }
}
/*
pub fn check(permutations: &[u64], w: u32, n: u32, mask: u64, offset: usize) -> ocl::Result<()> {
    //println!("read src!");
    let src = std::fs::read_to_string("src/solvers/check.cl").expect("failed to open kernel file");

    //println!("created queue!");
    println!("offset: {}", offset);
    println!("length: {}", permutations.len() - offset);
    let pro_que = ocl::ProQue::builder()
        .src(src)
        .dims(permutations.len() - offset)
        .build()?;

    let results = pro_que.create_buffer::<i32>()?;
    let kernel = pro_que
        .kernel_builder("check")
        .arg(get_buffer())
        .arg(&results)
        .arg(mask)
        .arg(n)
        .arg(w)
        .arg(offset as u64)
        //.global_work_offset(offset)
        .build()?;

    //println!("starting calculation");
    unsafe {
        kernel.enq()?;
    }

    let mut vec = vec![0; results.len()];
    results.read(&mut vec).enq()?;

    if vec.iter().any(|x| *x != 0) {
        println!("The resuts are now '{:?}'!", vec);
    }
    Ok(())
}*/