#![allow(dead_code)]

pub const BUFFER_SIZE: usize = 4096;

mod bytes;
mod ext;
pub use ext::*;
mod error;
mod hash;
mod container;
#[macro_use]
mod log;
mod config;
mod arg;
mod proc;


#[cfg(test)]
mod test {
    use super::*;
    use std::{
	path::Path,
    };

    #[test]
    pub fn args() -> Result<(), arg::Error>
    {
	macro_rules! string_literal {
	    ($($strings:expr),*) => {
		vec![$(
		    format!($strings),
		)*]
	    }
	}
	let args = string_literal!["-lsd", "--load-file", "hello", "--load-save", "load-save!", "--", "test-input", "test-input", "test-input-3", "test-input-2"];
	println!("{:?}", arg::parse(args)?);
	Ok(())
    }
    
    #[test]
    pub fn test() -> Result<(), error::Error>
    {
	let mut cont = container::DupeMap::new();
	let mode = config::Mode::default();
	let path = Path::new("test-input");

	assert_eq!(proc::DupeCount{total:4, dupes:2}, proc::do_dir(path, 0, &mut cont, &mode)?);

	Ok(())
    }

    #[cfg(feature="threads")]
    pub async fn _test_async() -> Result<(), error::Error>
    {
	use std::sync::Arc;
	use tokio::{
	    sync::Mutex,
	};
	let cont = Arc::new(Mutex::new(container::DupeMap::new()));
	let mode = config::Mode::default();
	let path = Path::new("test-input");

	assert_eq!(proc::DupeCount{total:4, dupes:2}, proc::do_dir_async(path, 0, cont, mode).await?);

	Ok(())
    }
    #[cfg(feature="threads")]
    #[test]
    pub fn test_async() -> Result<(), error::Error>
    {
	tokio_test::block_on(_test_async())
    }
}

fn parse_args() -> Result<config::Config, error::Error>
{
    match  arg::parse_args()? {
	arg::Output::Normal(conf) => Ok(conf),
	_ => arg::usage(),
    }
}

#[cfg_attr(feature="threads", tokio::main)]
#[cfg(feature="threads")]
async fn main() -> Result<(), error::Error>
{
    let args = parse_args()?;
    let lmode = &args.mode.logging_mode;

    log!(Debug, lmode => "Args parsed: {:?}", args);

    
    
    Ok(())
}

#[cfg(not(feature="threads"))]
fn main() -> Result<(), error::Error>
{
    let args = parse_args()?;
    
    log!(Fatal, log::Mode::Error => "{:?}", args);
    Ok(())
}