strval 0.5.0

use std::{fmt, marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};

use crate::{AnyU64, Controller, StrVal, err::Error};

/// A `u64` value that supports suffixes, like `1kb`, `2.5kb`, etc.
///
/// This variant treats k as 1000.  See [`BinU64Size`](super::BinU64Size) for a
/// binary variant.
#[derive(Debug, Clone)]
pub struct DecU64Size<C = AnyU64> {
  sval: String,
  val: u64,
  _marker: PhantomData<C>
}

impl<C> Default for DecU64Size<C> {
  fn default() -> Self {
    Self {
      sval: "0".into(),
      val: 0,
      _marker: PhantomData
    }
  }
}

impl<C> StrVal for DecU64Size<C>
where
  C: Controller<Type = u64>
{
  type Type = u64;

  fn set(&mut self, sval: &str) -> Result<Self::Type, Error> {
    let dv = sval.parse::<Self>()?;

    C::validate(&dv.val)?;

    self.sval = sval.to_string();
    self.val = dv.val;
    Ok(dv.val)
  }

  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for DecU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecU64Size<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecU64Size<C>
where
  C: Controller<Type = u64>
{
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
      .with_byte_suffix(ByteSuffix::Require)
      .parse_size(s)
      .map_err(|e| Error::Invalid(e.to_string()))?;
    C::validate(&val)?;
    Ok(Self {
      sval: s.to_string(),
      val,
      _marker: PhantomData
    })
  }
}

#[cfg(feature = "rusqlite")]
#[cfg_attr(docsrs, doc(cfg(feature = "rusqlite")))]
impl<C> ToSql for DecU64Size<C> {
  fn to_sql(&self) -> Result<ToSqlOutput<'_>, rusqlite::Error> {
    self.sval.to_sql()
  }
}

#[cfg(feature = "rusqlite")]
#[cfg_attr(docsrs, doc(cfg(feature = "rusqlite")))]
impl<C> FromSql for DecU64Size<C>
where
  C: Controller<Type = u64>
{
  #[inline]
  fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
    let s = String::column_result(value)?;
    s.parse::<Self>()
      .map_err(|e| FromSqlError::Other(Box::new(e)))
  }
}

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

  #[cfg(feature = "rusqlite")]
  use rusqlite::{Connection, params};

  struct SomeU64Bound {}

  impl Controller for SomeU64Bound {
    type Type = u64;
    fn def() -> String {
      String::from("10")
    }
    fn validate(val: &Self::Type) -> Result<(), Error> {
      if *val < 10 || *val > 256 * 1024 {
        Err(Error::OutOfBounds("Must be 10 - 256K".into()))
      } else {
        Ok(())
      }
    }
  }

  #[test]
  fn default1() {
    #[allow(clippy::default_trait_access)]
    let mut val: DecU64Size = Default::default();

    let v = val.set("64kb").unwrap();
    assert_eq!(v, 64000);
    assert_eq!(val.get(), 64000);
  }

  #[test]
  fn default2() {
    let mut val = <DecU64Size>::default();

    let v = val.set("64kb").unwrap();
    assert_eq!(v, 64000);
    assert_eq!(val.get(), 64000);
  }

  #[test]
  fn set_get() {
    let mut val = DecU64Size::<SomeU64Bound>::default();

    let v = val.set("64kb").unwrap();
    assert_eq!(v, 64000);
    assert_eq!(val.get(), 64000);
  }

  #[test]
  #[should_panic(expected = "OutOfBounds(\"Must be 10 - 256K\")")]
  fn oob() {
    let mut val = DecU64Size::<SomeU64Bound>::default();

    let _v = val.set("512kb").unwrap();
  }

  #[test]
  #[should_panic(expected = "OutOfBounds(\"Must be 10 - 256K\")")]
  fn oob_parsed() {
    let _val = "512kb".parse::<DecU64Size<SomeU64Bound>>().unwrap();
  }

  #[cfg(feature = "rusqlite")]
  fn memdb() -> Result<Connection, rusqlite::Error> {
    let conn = Connection::open_in_memory()?;
    conn.execute_batch(
      "CREATE TABLE tbl (id INTEGER PRIMARY KEY, txtval TEXT)"
    )?;
    Ok(conn)
  }

  #[cfg(feature = "rusqlite")]
  #[test]
  fn insert_query() {
    let conn = memdb().unwrap();

    let v = "10kb".parse::<DecU64Size>().unwrap();
    conn
      .execute("INSERT INTO tbl (id, txtval) VALUES (?, ?);", params![1, v])
      .unwrap();

    let v = "256b".parse::<DecU64Size>().unwrap();
    conn
      .execute("INSERT INTO tbl (id, txtval) VALUES (?, ?);", params![2, v])
      .unwrap();

    let mut stmt = conn.prepare("SELECT txtval FROM tbl WHERE id=?;").unwrap();

    let v: DecU64Size = stmt.query_one([1], |row| row.get(0)).unwrap();
    assert_eq!(v.get(), 10_000);

    let v: DecU64Size = stmt.query_one([2], |row| row.get(0)).unwrap();
    assert_eq!(v.get(), 256);
  }

  #[cfg(feature = "rusqlite")]
  #[test]
  #[should_panic(expected = "FromSqlConversionFailure(0, Text, \
                             Invalid(\"invalid digit found in string\"))")]
  fn bad_query() {
    let conn = memdb().unwrap();

    conn
      .execute(
        "INSERT INTO tbl (id, txtval) VALUES (?, ?);",
        params![1, "notanumber"]
      )
      .unwrap();

    let mut stmt = conn.prepare("SELECT txtval FROM tbl WHERE id=?;").unwrap();

    let _v: DecU64Size = stmt.query_one([1], |row| row.get(0)).unwrap();
  }
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :