lpn 0.2.0

use std::sync::Once;
use std::boxed::Box;

use m4ri_rust::friendly::BinMatrix;
use m4ri_rust::friendly::BinVector;

use crate::codes::BinaryCode;
use crate::oracle::{Sample, SAMPLE_LEN};

/// ``[{{n}}, {{k}}]`` Hamming code
/// 
/// Decodes using direct lookup tables
#[derive(Debug,Serialize)]
pub struct HammingCode{{n}}_{{k}};

static INIT: Once = Once::new();
static mut GENERATOR_MATRIX: *const BinMatrix = 0 as *const BinMatrix;
static mut PARITY_MATRIX: *const BinMatrix = 0 as *const BinMatrix;

fn init() {
    INIT.call_once(|| {
        unsafe {
            let matrix = Box::new(BinMatrix::from_slices(&[
                {% for row in generator %}&[{{ row|intlist }}],
                {% endfor %}
            ], {{ n }}));
            GENERATOR_MATRIX = Box::into_raw(matrix);

            let matrix = Box::new(BinMatrix::from_slices(&[
                    {% for row in parity_matrix %}&[{{ row|intlist }}],
                    {% endfor %}
            ], {{ n }}));
            PARITY_MATRIX = Box::into_raw(matrix);
        }
    });
}

// only supports 1-block syndromes
static SYNDROME: [usize; {{ 2**n }}] = [
{% for syndrome in syndromes %}     {{ syndrome|intlist }}, // {{ syndrome }}
{% endfor %}];

static ENCODE: [usize; {{ 2**k }}] = [
{% for encoding in encodings %}       {{ encoding|intlist }}, // {{ encoding }}
{% endfor %}];


impl BinaryCode for HammingCode{{n}}_{{k}} {
    fn name(&self) -> String {
        "[{{ n }}, {{ k }}] Hamming code".to_owned()
    }

    fn length(&self) -> usize {
        {{ n }}
    }

    fn dimension(&self) -> usize {
        {{ k }}
    }

    fn generator_matrix(&self) -> &BinMatrix {
        init();
        unsafe {
            GENERATOR_MATRIX.as_ref().unwrap()
        }
    }

    fn parity_check_matrix(&self) -> &BinMatrix {
        init();
        unsafe {
            PARITY_MATRIX.as_ref().unwrap()
        }
    }

    fn decode_to_message(&self, c: &BinVector) -> Result<BinVector, &str> {
        debug_assert_eq!(c.len(), self.length());
        let mut v = BinVector::with_capacity(self.dimension());
        let stor = unsafe { v.get_storage_mut() };
        stor.push(SYNDROME[c.as_u32() as usize]);
        unsafe { v.set_len(self.dimension()); }
        Ok(v)
    }

    /// Encode using lookup table
    fn encode(&self, c: &BinVector) -> BinVector {
        debug_assert_eq!(c.len(), self.dimension());
        let mut v = BinVector::with_capacity( self.length() );
        let stor = unsafe { v.get_storage_mut() };
        stor.push(ENCODE[c.as_u32() as usize]);
        unsafe { v.set_len(self.length()); }
        v
    }

    /// Decode a Sample
    #[inline]
    fn decode_sample(&self, sample: &mut Sample) {
        assert!(self.length() < 64);
        const MASK: u64 = (1 << {{ n }}) - 1;
        let c = sample.get_sample_mut();
        if SAMPLE_LEN == 1 { // need to ignore product
            c[0] = (c[0] & !MASK) | (SYNDROME[(c[0] & MASK) as usize] as u64);
        } else {
            self.decode_slice(c)
        }
    }

    #[inline]
    fn decode_slice(&self, c: &mut [u64]) {
        debug_assert_eq!(c[0] & !((1 << self.length()) - 1), 0, "this message is too long");

        c[0] = SYNDROME[c[0] as usize] as u64
    }

    // for hamming codes
    fn bias(&self, delta: f64) -> f64 {
        (1f64 + f64::from({{ n }}) * delta) / f64::from({{ n }} + 1)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use m4ri_rust::friendly::BinVector;

    #[test]
    fn size() {
        let code = HammingCode{{n}}_{{k}}.generator_matrix();
        assert_eq!(code.ncols(), {{n}});
        assert_eq!(code.nrows(), {{k}});
    }

    #[test]
    fn decode() {
        let code = HammingCode{{n}}_{{k}};

        let codeword = code.decode_to_message(&BinVector::from_elem({{n}}, true)).unwrap();
        assert_eq!(codeword, BinVector::from_elem({{k}}, true));

        let mut vec = BinVector::from_elem({{n}}, true);
        vec.set(0, false);
        let codeword = code.decode_to_message(&vec).unwrap();
        assert_eq!(codeword, BinVector::from_elem({{k}}, true));

        let vec = code.decode_to_code(&BinVector::from_elem({{n}}, false)).unwrap();
        assert_eq!(vec, BinVector::from_elem({{n}}, false));
    }

    #[test]
    fn test_decode_sample() {
        let code = HammingCode{{n}}_{{k}};
        for _ in 0..1000 {
            // setup
            let vec = BinVector::random(code.length());
            let mut sample_a = Sample::from_binvector(&vec, false);
            let mut sample_b = Sample::from_binvector(&vec, true);
            
            let decoded_vec = code.decode_to_message(&vec).unwrap();
            println!("decoded_vec: {:?}", decoded_vec);

            // test vectors
            let decoded_vec_sample_a = Sample::from_binvector(&decoded_vec, false);
            let decoded_vec_sample_b = Sample::from_binvector(&decoded_vec, true);

            code.decode_sample(&mut sample_a);
            code.decode_sample(&mut sample_b);
            assert_eq!(sample_a.get_product(), false);
            assert_eq!(sample_b.get_product(), true);
            assert_eq!(sample_a, decoded_vec_sample_a);
            assert_eq!(sample_b, decoded_vec_sample_b);
        }
    }

}