// #![doc(html_logo_url = "https://rin.rs/logo.svg")]
// #![doc(html_favicon_url = "https://rin.rs/favicon.ico")]

pub use self::lazy_value::{Lazy, LazyUpdate};
pub use self::value_cache::*;
pub use self::error::Error;
pub use self::error::Result;
pub use self::error::LogErr;
pub use self::enum_set::{EnumSet,CLike};

#[cfg(not(target_os="unknown"))]
pub use self::autoloader::AutoLoader;

use std::{path::{Path, PathBuf}, time::Instant};

#[cfg(not(target_os="unknown"))]
mod autoloader;

mod lazy_value;
mod value_cache;
mod error;
#[cfg(feature="async")]
pub mod async_fs;
mod enum_set;
use chrono::prelude::*;

/// fps from time interval and frames passed
pub fn calc_fps(curr_time: Instant, prev_time: Instant, frames: u64) -> f64{
    frames as f64 / (curr_time - prev_time).as_secs_f64()
}

#[macro_export]
/// quick macro to log times that a section of code takes to run
///
/// ```
/// rin::util::timed!("some operation", {
///     // do something
/// });
/// ```
/// will run the code inside the curly braces and at the end print the time it took to run
macro_rules! timed{
    ($descr: expr, $func: block) => (
        {
            use time;
            let then = time::precise_time_ns() as f32/1000000f32;
            let ret = $func;
            let now = time::precise_time_ns() as f32/1000000f32;
            println!("{} time: {}ms", $descr, now - then);
            ret
        }
    );
}


//TODO: this is really hacky and probably slow but seems the only way to find out the real
// path when a project is inside a workspace
#[cfg(feature = "debug_paths")]
pub fn workspace_dir() -> std::path::PathBuf {
    let cargo = std::process::Command::new("cargo")
        .args(&["locate-project", "--workspace", "--message-format", "plain",])
        .output()
        .unwrap()
        .stdout;
    let cargo = String::from_utf8(cargo).unwrap();
    std::path::Path::new(&cargo).parent().unwrap().to_owned()
}

#[cfg(not(feature = "debug_paths"))]
pub fn workspace_dir() -> std::path::PathBuf {
    std::path::PathBuf::new()
}

lazy_static::lazy_static! {
    pub static ref WORKSPACE_DIR: std::path::PathBuf = workspace_dir();
}


pub fn timestamp_string_tz<TZ: chrono::TimeZone>(prefix: &str, timestamp: chrono::DateTime<TZ>, suffix: &str) -> String{
    format!("{}{}_{}_{}_{}_{}_{}_{}{}",
        prefix,
        timestamp.year(),
        timestamp.month(),
        timestamp.day(),
        timestamp.hour(),
        timestamp.minute(),
        timestamp.second(),
        timestamp.nanosecond() / 1_000_000,
        suffix,
    )
}

pub fn timestamp_string<T: Into<chrono::DateTime<Local>>>(prefix: &str, timestamp: T, suffix: &str) -> String{
    let timestamp = timestamp.into();
    format!("{}{:02}_{:02}_{:02}_{:02}_{:02}_{:02}_{:03}{}",
        prefix,
        timestamp.year(),
        timestamp.month(),
        timestamp.day(),
        timestamp.hour(),
        timestamp.minute(),
        timestamp.second(),
        timestamp.nanosecond() / 1_000_000,
        suffix,
    )
}

pub fn timestamp_path_tz<P,TZ>(folder: P, prefix: &str, timestamp: chrono::DateTime<TZ>, suffix: &str, extension: &str) -> PathBuf
where
    P: AsRef<Path>,
    TZ: chrono::TimeZone
{
    let string = timestamp_string_tz(prefix, timestamp, suffix);
    let mut path = folder.as_ref().join(string);
    path.set_extension(extension);
    path
}

pub fn timestamp_path<P,T>(folder: P, prefix: &str, timestamp: T, suffix: &str, extension: &str) -> PathBuf
where
    P: AsRef<Path>,
    T: Into<chrono::DateTime<Local>>
{
    let string = timestamp_string(prefix, timestamp, suffix);
    let mut path = folder.as_ref().join(string);
    path.set_extension(extension);
    path
}