//! # peach-web
//!
//! `peach-web` provides a web interface for monitoring and interacting with the
//! PeachCloud device. This allows administration of the single-board computer
//! (ie. Raspberry Pi) running PeachCloud, as well as the ssb-server and related
//! plugins.
//!
//! ## Design
//!
//! `peach-web` is written primarily in Rust and presents a web interface for
//! interacting with the device. The stack currently consists of Rocket (Rust
//! web framework), Tera (Rust template engine inspired by Jinja2 and the Django
//! template language), HTML, CSS and JavaScript. Additional functionality is
//! provided by JSON-RPC clients for the `peach-network` and `peach-stats`
//! microservices.
//!
//! HTML is rendered server-side. Request handlers call JSON-RPC microservices
//! and serve HTML and assets. A JSON API is exposed for remote calls and
//! dynamic client-side content updates via vanilla JavaScript following
//! unobstructive design principles. Each Tera template is passed a context
//! object. In the case of Rust, this object is a `struct` and must implement
//! `Serialize`. The fields of the context object are available in the context
//! of the template to be rendered.

#![feature(proc_macro_hygiene, decl_macro)]

mod context;
pub mod error;
mod router;
pub mod routes;
#[cfg(test)]
mod tests;
pub mod utils;

use std::{env, process};

use lazy_static::lazy_static;
use log::{error, info};
use rocket::{Build, Rocket};

pub type BoxError = Box<dyn std::error::Error>;

lazy_static! {
    // determine run-mode from env var; default to standalone mode (aka peachpub)
    static ref STANDALONE_MODE: bool = match env::var("PEACH_STANDALONE_MODE") {
        // parse the value to a boolean; default to true for any error
        Ok(val) => val.parse().unwrap_or(true),
        Err(_) => true
    };
}

static WLAN_IFACE: &str = "wlan0";
static AP_IFACE: &str = "ap0";

pub fn init_rocket() -> Rocket<Build> {
    info!("Initializing Rocket");
    if *STANDALONE_MODE {
        router::mount_peachpub_routes()
    } else {
        router::mount_peachcloud_routes()
    }
}

/// Launch the peach-web rocket server.
#[rocket::main]
async fn main() {
    // initialize logger
    env_logger::init();

    // initialize rocket
    let rocket = init_rocket();

    // launch rocket
    info!("Launching Rocket");
    if let Err(e) = rocket.launch().await {
        error!("Error in Rocket application: {}", e);
        process::exit(1);
    }
}