#![allow(clippy::too_many_arguments, clippy::to_string_trait_impl)]
mod cli;
mod gui;
mod lang;
mod media;
mod metadata;
mod path;
mod prelude;
mod resource;
#[cfg(test)]
mod testing;
use crate::{
gui::Flags,
prelude::{app_dir, CONFIG_DIR, VERSION},
};
fn prepare_logging() -> Result<flexi_logger::LoggerHandle, flexi_logger::FlexiLoggerError> {
flexi_logger::Logger::try_with_env_or_str("madamiru=warn")
.unwrap()
.log_to_file(flexi_logger::FileSpec::default().directory(app_dir().as_std_path_buf().unwrap()))
.write_mode(flexi_logger::WriteMode::BufferAndFlush)
.rotate(
flexi_logger::Criterion::Size(1024 * 1024 * 10),
flexi_logger::Naming::Timestamps,
flexi_logger::Cleanup::KeepLogFiles(4),
)
.use_utc()
.format_for_files(|w, now, record| {
write!(
w,
"[{}] {} [{}] {}",
now.format("%Y-%m-%dT%H:%M:%S%.3fZ"),
record.level(),
record.module_path().unwrap_or("<unnamed>"),
&record.args(),
)
})
.start()
}
fn prepare_panic_hook(handle: Option<flexi_logger::LoggerHandle>) {
let original_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
let thread_name = std::thread::current().name().unwrap_or("<unnamed thread>").to_owned();
let location = if let Some(panic_location) = info.location() {
format!(
"{}:{}:{}",
panic_location.file(),
panic_location.line(),
panic_location.column()
)
} else {
"<unknown location>".to_owned()
};
let message = info.payload().downcast_ref::<&str>().unwrap_or(&"");
let backtrace = std::backtrace::Backtrace::force_capture();
log::error!("thread '{thread_name}' panicked at {location}:\n{message}\nstack backtrace:\n{backtrace}");
if let Some(handle) = handle.clone() {
handle.flush();
}
original_hook(info);
}));
}
#[cfg(target_os = "windows")]
unsafe fn detach_console() {
use windows::Win32::{
Foundation::HANDLE,
System::Console::{FreeConsole, SetStdHandle, STD_ERROR_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE},
};
fn tell(msg: &str) {
eprintln!("{}", msg);
log::error!("{}", msg);
}
if FreeConsole().is_err() {
tell("Unable to detach the console");
std::process::exit(1);
}
if SetStdHandle(STD_INPUT_HANDLE, HANDLE::default()).is_err() {
tell("Unable to reset stdin handle");
std::process::exit(1);
}
if SetStdHandle(STD_OUTPUT_HANDLE, HANDLE::default()).is_err() {
tell("Unable to reset stdout handle");
std::process::exit(1);
}
if SetStdHandle(STD_ERROR_HANDLE, HANDLE::default()).is_err() {
tell("Unable to reset stderr handle");
std::process::exit(1);
}
}
fn main() {
let mut failed = false;
let args = cli::parse();
if let Some(config_dir) = args.as_ref().ok().and_then(|args| args.config.as_ref()) {
*CONFIG_DIR.lock().unwrap() = Some(config_dir.clone());
}
let logger = prepare_logging();
#[allow(clippy::useless_asref)]
prepare_panic_hook(logger.as_ref().map(|x| x.clone()).ok());
let flush_logger = || {
if let Ok(logger) = &logger {
logger.flush();
}
};
log::debug!("Version: {}", *VERSION);
log::debug!("Invocation: {:?}", std::env::args());
let args = match args {
Ok(x) => x,
Err(e) => {
match e.kind() {
clap::error::ErrorKind::DisplayHelp | clap::error::ErrorKind::DisplayVersion => {}
_ => {
log::error!("CLI failed to parse: {e}");
}
}
flush_logger();
e.exit()
}
};
match args.sub {
None => {
let mut sources = cli::parse_sources(args.sources);
sources.extend(args.glob.into_iter().map(media::Source::new_glob));
#[cfg(target_os = "windows")]
if std::env::var(crate::prelude::ENV_DEBUG).is_err() {
unsafe {
detach_console();
}
}
let flags = Flags { sources };
gui::run(flags);
}
Some(sub) => {
if let Err(e) = cli::run(sub) {
failed = true;
eprintln!("{}", lang::handle_error(&e));
}
}
};
flush_logger();
if failed {
std::process::exit(1);
}
}