use std::collections::HashMap;
use std::ops::{Deref, DerefMut};

/// Represents the content of a cached file.
/// It is stored as a HashMap, because we do not
/// have to store the zeros. With that we save a lot
/// of storage.
#[derive(Clone, Debug)]
pub struct FileVector {
    data : HashMap<u64, u64>
}

impl Deref for FileVector {
    type Target = HashMap<u64, u64>;
    fn deref(&self) -> &Self::Target {
        &self.data
    }
}

impl DerefMut for FileVector {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.data
    }
}

impl Default for FileVector {
    fn default() -> Self {
        Self::new()
    }
}

impl FileVector {
    pub fn new() -> Self {
        Self { data : HashMap::new() }
    }

    pub fn from_string(hex : String) -> Self {
        let mut data : HashMap<u64, u64> = HashMap::new();
        let data_chunks : Vec<&str> = hex.split(' ').collect();

        for chunk in data_chunks {
            if !chunk.is_empty() {
                let n : Vec<&str> = chunk.split(';').collect();
                let i : u64 = u64::from_str_radix(n[0], 16).expect("could not extract index");
                let v : u64 = u64::from_str_radix(n[1], 16).expect("could not extract value");
                data.insert(i, v);
            }
        }

        Self { data }
    }

    pub fn stringify(&self) -> String {
        let mut hex = String::new();

        for (i, v) in self.data.iter() {
            hex += &format!("{:x};{:x} ", *i, *v);
        }

        hex.trim().to_string()
    }
}

pub fn scalar_product(a : &FileVector, b : &FileVector) -> u64 {
    let mut c = 0;
    for (i, x) in a.iter() {
        c += x * (b.get(i).unwrap_or(&0));
    }
    c
}