//! Various utility methods and modules
//! 
//! Contains modules for (de-)serializing various forms of [u8] as
//! base 64 and vice versa.

pub mod base64_u8 {
  use base64::Engine;
  use serde::{Serialize, Serializer};

  pub fn serialize<S: Serializer>(v: &[u8], s: S) -> Result<S::Ok, S::Error> {
    let engine = base64::engine::general_purpose::STANDARD_NO_PAD;
    let base64 = engine.encode(v);
    String::serialize(&base64, s)
  }
}

pub mod base64_vec_u8 {
  use base64::Engine;
  use serde::{Serialize, Deserialize};
  use serde::{Deserializer, Serializer};

  pub fn serialize<S: Serializer>(v: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
    let engine = base64::engine::general_purpose::STANDARD_NO_PAD;
    let base64 = engine.encode(v);
    String::serialize(&base64, s)
  }
  
  pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
    let base64 = String::deserialize(d)?;
    let engine = base64::engine::general_purpose::STANDARD_NO_PAD;
    engine.decode(base64.as_bytes())
      .map_err(|e| serde::de::Error::custom(e))
  }
}

pub mod base64_opt_vec_u8 {
  use serde::de::Visitor;
  use serde::{Deserializer, Serializer};

use super::base64_vec_u8;

  pub fn serialize<S: Serializer>(v: &Option<Vec<u8>>, s: S) -> Result<S::Ok, S::Error> {
    match v {
        Some(v) => return base64_vec_u8::serialize(v, s),
        None => return  s.serialize_none(),
    };
  }
  
  pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Vec<u8>>, D::Error> {
    return d.deserialize_option(OptVisitor {});
  }

  struct OptVisitor {}

  impl<'de> Visitor<'de> for OptVisitor {
    type Value = Option<Vec<u8>>;
  
    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        return write!(formatter, "Some(base64-value) or None.");
    }

    fn visit_none<E>(self) -> Result<Self::Value, E>
        where
            E: serde::de::Error, {
        return Ok(None);
    }

    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
        where
            D: Deserializer<'de>, {
        let result = base64_vec_u8::deserialize(deserializer)?;
        return Ok(Some(result));
    }
  }
}