use crate::permutations::PermutationGenerator;
use crate::solvers::{opencl, wall_stats, IteratorSolver, Solver};
use crate::structs::StoneWall;

#[derive(Debug)]
pub struct GpuSolver {
    n: u32,
    h: u32,
    w: u32,
    permutations: Vec<Vec<u32>>,
    masks: Vec<u64>,
}

impl GpuSolver {
    fn solve_to_vec(&mut self) -> Vec<StoneWall> {
        let src =
            std::fs::read_to_string("src/solvers/check.cl").expect("failed to open kernel file");

        let senders =
            opencl::GpuSolver::launch_sevice(&self.masks, self.n, self.h, self.w, 4, src.as_ref())
                .unwrap();
        for i in 0..12 {
            senders[1 - i / 6]
                .send(opencl::Job::new(vec![i as u32], self.masks[i]))
                .unwrap();
        }
        loop {
            std::thread::sleep(std::time::Duration::from_secs(5));
        }
        vec![]
    }
}

fn generate_permutations(n: u32) -> Vec<Vec<u32>> {
    crate::permutations::HeapsPermutations::permutations(n)
}

fn generate_masks(permutations: &[Vec<u32>]) -> Vec<u64> {
    let mut masks = Vec::with_capacity(permutations.len());
    for p in permutations {
        let mut v = 0;
        let mut x = 0u64;
        for i in p.iter().take(p.len() - 1).map(|i| {
            v += i;
            v
        }) {
            x |= 1 << i
        }
        masks.push(x)
    }
    masks
}

impl Solver for GpuSolver {
    fn new(n: u32) -> Self {
        let (h, w) = wall_stats(n);
        let permutations = generate_permutations(n);
        let masks = generate_masks(&permutations);
        Self {
            n,
            h,
            w,
            permutations,
            masks,
        }
    }
    fn n(&self) -> u32 {
        self.n
    }
    fn h(&self) -> u32 {
        self.h
    }
    fn w(&self) -> u32 {
        self.w
    }
}

impl IteratorSolver for GpuSolver {
    type IntoIter = std::vec::IntoIter<StoneWall>;
    fn solve(mut self) -> Self::IntoIter {
        self.solve_to_vec().into_iter()
    }
}