configuration.rs

use crate::errors::{ Error, Result };
use crate::math::{ Vector2 };

use kdl::{ KdlDocument, KdlValue };

use std::ffi::{ OsStr };
use std::path::{ Path };

pub trait KdlConfigurable {
  fn from_kdl_document(kdl: &KdlDocument) -> Result<Self>
    where Self: Sized;
}

#[derive(Debug, Default)]
pub struct ApplicationConfiguration {
  window: WindowConfiguration,
}

impl ApplicationConfiguration {
  pub fn is_configuration_file<P: AsRef<Path>>(path: P) -> bool {
    path
      .as_ref()
      .file_name()
      .and_then(OsStr::to_str)
      .map(|filename| filename == "crucible.kdl")
      .unwrap_or(false)
  }

  pub fn window(&self) -> &WindowConfiguration {
    &self.window
  }
}

impl KdlConfigurable for ApplicationConfiguration {
  fn from_kdl_document(kdl: &KdlDocument) -> Result<ApplicationConfiguration> {
    let window = kdl
      .get("window")
      .and_then(|node| node.children())
      .map(|children| WindowConfiguration::from_kdl_document(children))
      .unwrap_or(Ok(WindowConfiguration::default()))?;

    Ok(ApplicationConfiguration {
      window,
    })
  }
}

#[derive(Debug)]
pub struct WindowConfiguration {
  initial_title: String,
  initial_size: Vector2<u32>,
}

impl WindowConfiguration {
  pub fn initial_title(&self) -> &str {
    &self.initial_title
  }

  pub fn initial_size(&self) -> &Vector2<u32> {
    &self.initial_size
  }
}

impl KdlConfigurable for WindowConfiguration {
  fn from_kdl_document(kdl: &KdlDocument) -> Result<WindowConfiguration> {
    let initial_title = kdl
      .get("initial-title")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_string())
      .unwrap_or("Crucible Application")
      .to_string();

    let initial_size = kdl
      .get("initial-size")
      .and_then(|node| node.children())
      .map(|children| Vector2::from_kdl_document(children))
      .unwrap_or(Ok(Vector2::new(1280, 720)))?;

    Ok(WindowConfiguration {
      initial_title,
      initial_size,
    })
  }
}

impl Default for WindowConfiguration {
  fn default() -> WindowConfiguration {
    WindowConfiguration {
      initial_title: "Crucible Application".to_string(),
      initial_size: Vector2::new(1280, 720),
    }
  }
}

impl<T: TryFromKdlValue> KdlConfigurable for Vector2<T> {
  fn from_kdl_document(kdl: &KdlDocument) -> Result<Vector2<T>> {
    let x = kdl
      .get("x")
      .and_then(|node| node.get(0))
      .map(|value| TryFromKdlValue::try_from_kdl_value(value))
      .ok_or(Error::ConfigurationError("Expected a number".to_string()))
      .flatten()?;

    let y = kdl
      .get("y")
      .and_then(|node| node.get(0))
      .map(|value| TryFromKdlValue::try_from_kdl_value(value))
      .ok_or(Error::ConfigurationError("Expected a number".to_string()))
      .flatten()?;

    Ok(Vector2::new(x, y))
  }
}

pub trait TryFromKdlValue {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<Self>
    where Self: Sized;
}

impl TryFromKdlValue for u8 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<u8> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<u8>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a u8 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("u8 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for u16 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<u16> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<u16>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a u16 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("u16 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for u32 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<u32> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<u32>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a u32 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("u32 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for u64 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<u64> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<u64>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a u64 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("u64 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for u128 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<u128> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<u128>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a u128 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("u128 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for i8 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<i8> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<i8>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a i8 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("i8 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for i16 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<i16> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<i16>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a i16 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("i16 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for i32 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<i32> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<i32>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a i32 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("i32 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for i64 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<i64> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<i64>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a i64 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("i64 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for i128 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<i128> {
    let value = kdl
      .as_integer()
      .map(|value| TryInto::<i128>::try_into(value))
      .ok_or(Error::ConfigurationError("Expected a i128 value".to_string()))
      .map(|inner| inner.map_err(|_| Error::ConfigurationError("i128 value out of range".to_string())))
      .flatten()?;

    Ok(value)
  }
}

impl TryFromKdlValue for f32 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<f32> {
    let value = kdl
      .as_float()
      .map(|value| value as f32)
      .ok_or(Error::ConfigurationError("Expected a f32 value".to_string()))?;

    Ok(value)
  }
}

impl TryFromKdlValue for f64 {
  fn try_from_kdl_value(kdl: &KdlValue) -> Result<f64> {
    let value = kdl
      .as_float()
      .map(|value| value as f64)
      .ok_or(Error::ConfigurationError("Expected a f64 value".to_string()))?;

    Ok(value)
  }
}