advotracker/crates/advotracker_client/src/main.rs

/*
 * advotracker - Hotline tackingtool for Advocats
 *
 * Copyright 2020 Ralf Zerres <ralf.zerres@networkx.de>
 * SPDX-License-Identifier: (0BSD or MIT)
 */

// suppress creation of a new console window on window
#![windows_subsystem = "windows"]

//use chrono::{Local, DateTime};
use dotenv::dotenv;
use cfg_if::cfg_if;
use serde::Deserialize;
use std::env;
//use std::process;
use substring::Substring;
use tracing::{info, trace, Level};
use twine::t;

use orbtk::{
    prelude::*,
    theme_default::{THEME_DEFAULT, THEME_DEFAULT_COLORS_DARK, THEME_DEFAULT_FONTS},
    theming::config::ThemeConfig,
};

#[cfg(target_os = "windows")]
use orbtk::theme_fluent::{THEME_FLUENT, THEME_FLUENT_COLORS_DARK, THEME_FLUENT_FONTS};

// The Main view
use advotracker_client::widgets::main_view;

mod parse_args;

/// define valid environment variables provided via .env files
/// located in the current call directory
/// this is primarily used in testing scenarios (eg. debugging)
#[derive(Debug, Deserialize)]
struct Environment {
    lang: String,
    test_lang: String,
    rust_log: String,
}

// Style extension
static DEFAULT_DARK_EXT: &str = include_str!("../assets/advotracker/default_dark.ron");
cfg_if! {
    if #[cfg(windows)] {
	static FLUENT_DARK_EXT: &str = include_str!("../assets/advotracker/fluent_dark.ron");
	static FLUENT_LIGHT_EXT: &str = include_str!("../assets/advotracker/fluent_light.ron");
    }
}

// German localization file.
static ADVOTRACKER_DE_DE: &str = include_str!("../assets/advotracker/advotracker_de_DE.ron");

/// Get the active language environment.
fn get_lang() -> String {
    // get system environment
    let mut lang = env::var("LANG").unwrap_or_else(|_| "en".to_string());
    lang = lang.substring(0,2).to_string();   // "de_DE.UTF-8" -> "de"
    info!("GUI-Language: preset to {:?}", lang);

    // testing environment: read from .env file
    dotenv().ok();
    match envy::from_env::<Environment>() {
	Ok(environment) => {
	    if environment.test_lang != lang { lang = environment.test_lang; }
	},
	Err(e) => { info!(target: "advotracker", "{}", e) }
    }
    trace!(target: "advotracker", lang = ?lang);

    // return the active language
    lang
}

cfg_if! {
    if #[cfg(windows)] {
	/// Extend and register theme assets.
	fn theme() -> Theme {
	    register_default_fonts(Theme::from_config(
		ThemeConfig::from(DEFAULT_DARK_EXT)
		    .extend(ThemeConfig::from(THEME_DEFAULT))
		    .extend(ThemeConfig::from(THEME_DEFAULT_COLORS_DARK))
		    .extend(ThemeConfig::from(THEME_DEFAULT_FONTS)),
	    ))
	}
	fn theme_fluent() -> Theme {
	    register_fluent_fonts(Theme::from_config(
		ThemeConfig::from(FLUENT_DARK_EXT)
		    .extend(ThemeConfig::from(THEME_FLUENT))
		    .extend(ThemeConfig::from(THEME_FLUENT_COLORS_DARK))
		    .extend(ThemeConfig::from(THEME_FLUENT_FONTS)),
	    ))
	    // register_fluent_fonts(Theme::from_config(
	    //     ThemeConfig::from(FLUENT_LIGHT_EXT)
	    //         .extend(ThemeConfig::from(THEME_FLUENT))
	    //         .extend(ThemeConfig::from(THEME_FLUENT_COLORS_DARK))
	    //         .extend(ThemeConfig::from(THEME_FLUENT_FONTS)),
	}
    } else {
	/// Extend and register theme assets.
	fn theme() -> Theme {
	    register_default_fonts(Theme::from_config(
		ThemeConfig::from(DEFAULT_DARK_EXT)
		    .extend(ThemeConfig::from(THEME_DEFAULT))
		    .extend(ThemeConfig::from(THEME_DEFAULT_COLORS_DARK))
		    .extend(ThemeConfig::from(THEME_DEFAULT_FONTS)),
	   ))
	}
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use parse_args::parse_args;
    use tracing_subscriber::fmt;
    use viperus::Viperus;

    let machine_kind = if cfg!(unix) {
	"unix"
    } else if cfg!(windows) {
	"windows"
    } else {
	"unknown/unsupported"
    };

    // respect dotenv environment (e.g for testing)
    // -> overwrites the preset default values
    let rust_log = dotenv::var("RUST_LOG").unwrap_or_else(|_| String::from("None"));

    // initialize the tracing subsystem
    // a drop in replacement for classical logging
    // reference: https://tokio.rs/blog/2019-08-tracing/
    let span = tracing::span!(Level::TRACE, "advotracker");
    let _enter = span.enter();
    let subscriber = fmt::Subscriber::builder()
	.with_env_filter(&rust_log)
	//.with_max_level(tracing::Level::DEBUG)
	.finish();

    tracing::subscriber::with_default(subscriber, || {
	// get system environment
	let lang = get_lang();

	// include localization strings
	include!(concat!(env!("OUTDIR"), "/i18n.rs"));

	let mut state = t!(state_started => lang);
	let mut res = t!(parse_environment => lang);
	trace!(target: "advotracker", process = ?res, state = ?state);
	trace!(target: "advotracker", environment = "system", lang = ?lang);
	trace!(target: "advotracker", machine = ?&machine_kind);

	// how to handle unimplemented lang resources??
	res = t!(parse_environment => lang);
	trace!(target: "advotracker", environment = "envy", lang = ?lang);
	state = t!(state_finished => lang);
	trace!(target: "advotracker", process = ?res, state = ?state);

	// initialize viperus structure
	let mut viperus = Viperus::new();

	// parse commandline arguments
	res = t!(parse_arguments => lang);
	state = t!(state_started => lang);
	trace!(target: "advotracker", process = ?res, state = ?state);

	let _ = parse_args(&mut viperus);
	state = t!(state_finished => lang);
	trace!(target: "advotracker", process = ?res, state = ?state);

	// type conversion (viperus String -> u64)
	let test_policy_number = viperus.get::<String>("test_policy_number").unwrap().parse::<u64>().unwrap();
	trace!(target: "advotracker", test_policy_number = ?test_policy_number);

	// main tasks
	res = t!(main_started => lang);
	state = t!(state_started => lang);
	trace!(target: "advotracker", process = ?res, state = ?state);

	// use this only if you want to run it as web application.
	orbtk::initialize();

	// Preset localization and language from given environment.
	// if no dictionary is set for the chosen default language
	// the content of the text property will be drawn.
	let localization = RonLocalization::create()
	    .language(&lang)
	    .dictionary("de_DE", ADVOTRACKER_DE_DE)
	    .build();

	Application::from_name("nwx.advotracker")
	    .localization(localization)
	    .theme(theme())
	    .window(|ctx| {
		Window::new()
		    .title("AdvoTracker - DirectCall")
		    .position((500.0, 100.0))
		    .size(800.0, 620.0)
		    //.min_width(460.0)
		    //.min_height(380.0)
		    .resizeable(true)
		    .child(main_view::MainView::new().build(ctx))
		    .build(ctx)
	    })
	    .run();

	state = t!(state_finished => lang);
	res = t!(main_finished => lang);
	trace!(target: "advotracker", process = ?res, state = ?state);
    });

    Ok(())
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
	assert_eq!(2 + 2, 4);
    }
}