configuration.rs

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

use kdl::{ KdlNode };

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

pub trait KdlConfigurable {
  fn from_kdl_node(node: &KdlNode) -> Result<Self>
    where Self: Sized;
}

#[derive(Debug, Default)]
pub struct ApplicationConfiguration {
  name: String,
  desktop: DesktopConfiguration,
  mobile: MobileConfiguration,
  browser: BrowserConfiguration,
}

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 name(&self) -> &str {
    &self.name
  }

  pub fn desktop(&self) -> &DesktopConfiguration {
    &self.desktop
  }

  pub fn mobile(&self) -> &MobileConfiguration {
    &self.mobile
  }

  pub fn browser(&self) -> &BrowserConfiguration {
    &self.browser
  }
}

impl KdlConfigurable for ApplicationConfiguration {
  fn from_kdl_node(node: &KdlNode) -> Result<ApplicationConfiguration> {
    let Some(children) = node.children() else {
      return Ok(ApplicationConfiguration::default());
    };

    let name = children
      .get("name")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_string())
      .unwrap_or("Crucible Application")
      .to_string();

    let desktop = children
      .get("desktop")
      .map(|node| DesktopConfiguration::from_kdl_node(node))
      .unwrap_or(Ok(DesktopConfiguration::default()))?;

    let mobile = children
      .get("mobile")
      .map(|node| MobileConfiguration::from_kdl_node(node))
      .unwrap_or(Ok(MobileConfiguration::default()))?;

    let browser = children
      .get("browser")
      .map(|node| BrowserConfiguration::from_kdl_node(node))
      .unwrap_or(Ok(BrowserConfiguration::default()))?;

    Ok(ApplicationConfiguration {
      name,
      desktop,
      mobile,
      browser,
    })
  }
}

#[derive(Debug)]
pub struct DesktopConfiguration {
  main_window: WindowConfiguration,
}

impl DesktopConfiguration {
  pub fn main_window(&self) -> &WindowConfiguration {
    &self.main_window
  }
}

impl Default for DesktopConfiguration {
  fn default() -> DesktopConfiguration {
    DesktopConfiguration {
      main_window: WindowConfiguration::default(),
    }
  }
}

impl KdlConfigurable for DesktopConfiguration {
  fn from_kdl_node(node: &KdlNode) -> Result<DesktopConfiguration> {
    let Some(children) = node.children() else {
      return Ok(DesktopConfiguration::default());
    };

    let main_window = children
      .get("main-window")
      .map(|node| WindowConfiguration::from_kdl_node(node))
      .unwrap_or(Ok(WindowConfiguration::default()))?;

    Ok(DesktopConfiguration {
      main_window,
    })
  }
}

#[derive(Debug)]
pub struct MobileConfiguration {
  is_decorated: bool,
  is_reorientable: bool,
  orientation: Orientation,
}

impl MobileConfiguration {
  pub fn is_decorated(&self) -> bool {
    self.is_decorated
  }

  pub fn is_reorientable(&self) -> bool {
    self.is_reorientable
  }

  pub fn orientation(&self) -> Orientation {
    self.orientation
  }
}

impl KdlConfigurable for MobileConfiguration {
  fn from_kdl_node(node: &KdlNode) -> Result<MobileConfiguration> {
    let Some(children) = node.children() else {
      return Ok(MobileConfiguration::default());
    };

    let is_decorated = children
      .get("is-decorated")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_bool())
      .unwrap_or(true);

    let is_reorientable = children
      .get("is-reorientable")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_bool())
      .unwrap_or(true);

    let orientation = children
      .get("orientation")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_string())
      .map(|keyword| {
        match keyword {
          "portrait" => Ok(Orientation::Portrait),
          "landscape" => Ok(Orientation::Landscape),
          _ => Err(Error::ConfigurationError(format!("Unrecognized orientation: `{}`", keyword))),
        }
      })
      .unwrap_or(Ok(Orientation::Portrait))?;

    Ok(MobileConfiguration {
      is_decorated,
      is_reorientable,
      orientation,
    })
  }
}

impl Default for MobileConfiguration {
  fn default() -> MobileConfiguration {
    MobileConfiguration {
      is_decorated: true,
      is_reorientable: true,
      orientation: Orientation::Portrait,
    }
  }
}

#[derive(Debug)]
pub struct BrowserConfiguration {
  main_canvas: String,
}

impl BrowserConfiguration {
  pub fn main_canvas(&self) -> &str {
    &self.main_canvas
  }
}

impl KdlConfigurable for BrowserConfiguration {
  fn from_kdl_node(node: &KdlNode) -> Result<BrowserConfiguration> {
    let Some(children) = node.children() else {
      return Ok(BrowserConfiguration::default());
    };

    let main_canvas = children
      .get("main-canvas")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_string())
      .unwrap_or("")
      .to_string();

    Ok(BrowserConfiguration {
      main_canvas
    })
  }
}

impl Default for BrowserConfiguration {
  fn default() -> BrowserConfiguration {
    BrowserConfiguration {
      main_canvas: String::new(),
    }
  }
}

#[derive(Debug)]
pub struct WindowConfiguration {
  is_decorated: bool,
  is_fullscreen: bool,
  is_resizable: bool,
  resolution: ResolutionConfiguration,
  title: String,
}

impl WindowConfiguration {
  pub fn is_decorated(&self) -> bool {
    self.is_decorated
  }

  pub fn is_fullscreen(&self) -> bool {
    self.is_fullscreen
  }

  pub fn is_resizable(&self) -> bool {
    self.is_resizable
  }

  pub fn title(&self) -> &str {
    &self.title
  }

  pub fn resolution(&self) -> &ResolutionConfiguration {
    &self.resolution
  }
}

impl KdlConfigurable for WindowConfiguration {
  fn from_kdl_node(node: &KdlNode) -> Result<WindowConfiguration> {
    let Some(children) = node.children() else {
      return Ok(WindowConfiguration::default());
    };

    let is_decorated = children
      .get("is-decorated")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_bool())
      .unwrap_or(true);

    let is_fullscreen = children
      .get("is-fullscreen")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_bool())
      .unwrap_or(false);

    let is_resizable = children
      .get("is-resizable")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_bool())
      .unwrap_or(true);

    let title = children
      .get("title")
      .and_then(|node| node.get(0))
      .and_then(|value| value.as_string())
      .unwrap_or("Crucible Application")
      .to_string();

    let resolution = children
      .get("resolution")
      .map(|node| ResolutionConfiguration::from_kdl_node(node))
      .unwrap_or(Ok(ResolutionConfiguration::default()))?;

    Ok(WindowConfiguration {
      is_decorated,
      is_fullscreen,
      is_resizable,
      title,
      resolution,
    })
  }
}

impl Default for WindowConfiguration {
  fn default() -> WindowConfiguration {
    WindowConfiguration {
      is_decorated: true,
      is_fullscreen: false,
      is_resizable: true,
      title: "Crucible Application".to_string(),
      resolution: ResolutionConfiguration::default(),
    }
  }
}

#[derive(Debug)]
pub struct ResolutionConfiguration {
  width: u32,
  height: u32,
}

impl ResolutionConfiguration {
  pub fn width(&self) -> u32 {
    self.width
  }

  pub fn height(&self) -> u32 {
    self.height
  }
}

impl KdlConfigurable for ResolutionConfiguration {
  fn from_kdl_node(node: &KdlNode) -> Result<ResolutionConfiguration> {
    let width: u32 = node
      .get("width")
      .and_then(|value| value.as_integer())
      .unwrap_or(1280)
      .try_into()
      .map_err(|_| Error::ConfigurationError("Resolution width out of range".to_string()))?;

    let height: u32 = node
      .get("height")
      .and_then(|value| value.as_integer())
      .unwrap_or(720)
      .try_into()
      .map_err(|_| Error::ConfigurationError("Resolution height out of range".to_string()))?;

    Ok(ResolutionConfiguration {
      width,
      height,
    })
  }
}

impl Default for ResolutionConfiguration {
  fn default() -> ResolutionConfiguration {
    ResolutionConfiguration {
      width: 1280,
      height: 720,
    }
  }
}

#[derive(Clone, Copy, Debug)]
pub enum Orientation {
  Portrait,
  Landscape,
}

impl fmt::Display for Orientation {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match *self {
      Orientation::Portrait => write!(f, "portrait"),
      Orientation::Landscape => write!(f, "landscape"),
    }
  }
}