use std::os::raw::c_uchar;
use std::sync::mpsc::*;
use std::thread::*;

use spiral_rs::client::PublicParameters;
use spiral_rs::params::Params;

use crate::params;

enum Command {
    PubParams(Vec<u8>),
    PreProcMsg(Vec<u8>),
}

enum Response {
    PreProcResp(Vec<u8>),
}

pub struct Server {
    r: usize,
    thread_handle: JoinHandle<()>,
    incoming_cmd: SyncSender<Command>,
    outgoing_resp: Receiver<Response>,
}

impl Server {
    pub fn new(r: usize, pub_params: Vec<u8>) -> Self {
        let (incoming_cmd, incoming_cmd_recv) = sync_channel(0);
        let (outgoing_resp_send, outgoing_resp) = sync_channel(0);
        let thread_handle = spawn(move || {
            let spiral_params = params::get_spiral_params(r);
            let pub_params = PublicParameters::deserialize(&spiral_params, &pub_params);
            loop {
                println!("Waiting");
                match incoming_cmd_recv.recv() {
                    Err(_) => break,
                    _ => panic!("Received something unexpected"),
                }
            }
            println!("Ending");
        });
        Server {
            r,
            thread_handle,
            incoming_cmd,
            outgoing_resp,
        }
    }
}

#[no_mangle]
pub extern "C" fn spir_server_new(
    r: u8,
    pub_params: *const c_uchar,
    pub_params_len: usize,
) -> *mut Server {
    let pub_params_slice = unsafe {
        assert!(!pub_params.is_null());
        std::slice::from_raw_parts(pub_params, pub_params_len)
    };
    let mut pub_params_vec: Vec<u8> = Vec::new();
    pub_params_vec.extend_from_slice(pub_params_slice);
    let server = Server::new(r as usize, pub_params_vec);
    Box::into_raw(Box::new(server))
}

#[no_mangle]
pub extern "C" fn spir_server_free(server: *mut Server) {
    if server.is_null() {
        return;
    }
    unsafe {
        Box::from_raw(server);
    }
}