#![allow(dead_code)]

extern crate getrandom;

use getrandom::*;

mod r#impl;

fn get<T: Default>() -> Result<T, Error>
{
    let mut value: T = Default::default();
    unsafe {
	let mut slice = std::slice::from_raw_parts_mut(&mut value as *mut T as *mut u8, std::mem::size_of::<T>());
	populate(&mut slice)?;
    }
    
    Ok(value)
}

fn double() -> Result<f64, Error>
{
    let long: i64 = get::<i64>()?;

    Ok( ((long & ((1i64 << 53) - 1)) as f64) * (1_f64 / ((1_i64 << 53) as f64)))
}

fn populate(mut value: &mut [u8]) -> Result<(), Error>
{
    getrandom(&mut value)?;

    Ok(())
}

fn int(low: i32, high: i32) -> Result<i32, Error>
{
    let value = double()?;
    return Ok(low + (value * (high - low) as f64).floor() as i32);
}

fn usage()
{
    println!("Usage: rng --range <start> <end> [<repeat>]");
    println!("Usage: rng --floor <start> <end> [<repeat>]");
    println!("Usage: rng --round <start> <end> [<repeat>]");
    println!("Usage: rng --ceil <start> <end> [<repeat>]");
    println!("Usage: rng --of <opts...>");
    println!("Usage: rng --shuffle <opts...>");
}

fn range(args: &[String]) -> Result<(), Error>
{
    if args.len() < 2 {
	usage();
    } else {
	let start: f64 = args[0].parse().expect("Not a number (start).");
	let end: f64 = args[1].parse().expect("Not a number (end).");	
	if args.len() >= 3 {
	    let repeat: usize = args[2].parse().expect("Not a valid number (repeat).");

	    r#impl::range(start,end,repeat)?;
	} else {
	    r#impl::range(start,end,1)?;
	}
    }
    Ok(())
}

fn round(args: &[String]) -> Result<(), Error>
{
    if args.len() < 2 {
	usage();
    } else {
	let start: f64 = args[0].parse().expect("Not a number (start).");
	let end: f64 = args[1].parse().expect("Not a number (end).");	
	if args.len() >= 3 {
	    let repeat: usize = args[2].parse().expect("Not a valid number (repeat).");

	    r#impl::round(start,end,repeat)?;
	} else {
	    r#impl::round(start,end,1)?;
	}
    }
    Ok(())
}

fn ceil(args: &[String]) -> Result<(), Error>
{
    if args.len() < 2 {
	usage();
    } else {
	let start: f64 = args[0].parse().expect("Not a number (start).");
	let end: f64 = args[1].parse().expect("Not a number (end).");	
	if args.len() >= 3 {
	    let repeat: usize = args[2].parse().expect("Not a valid number (repeat).");

	    r#impl::ceil(start,end,repeat)?;
	} else {
	    r#impl::ceil(start,end,1)?;
	}
    }
    Ok(())
}

fn floor(args: &[String]) -> Result<(), Error>
{
    if args.len() < 2 {
	usage();
    } else {
	let start: f64 = args[0].parse().expect("Not a number (start).");
	let end: f64 = args[1].parse().expect("Not a number (end).");	
	if args.len() >= 3 {
	    let repeat: usize = args[2].parse().expect("Not a valid number (repeat).");

	    r#impl::floor(start,end,repeat)?;
	} else {
	    r#impl::floor(start,end,1)?;
	}
    }
    Ok(())
}

fn of(args: &[String]) -> Result<(), Error>
{
    let max = args.len();
    let int = int(0, max as i32)? as usize;

    println!("{}", args[int]);

    Ok(())
}

fn shuffle(args: &[String]) -> Result<(), Error>
{
    let mut values: Vec<String> = args.to_vec();

    for i in (1..args.len()).rev() {
	let  j = int(0, i as i32)? as usize;

	values.swap(i, j);
    }

    for a in values.iter() {
	println!("{}", a);
    }
    
    Ok(())
}

fn main() -> Result<(), Error> {    

    let args: Vec<String> = std::env::args().collect();
    
    if args.len() < 2 {
	usage();
	Ok(())
    } else  {
	match args[1].to_lowercase().as_str() {
	    "--range" => range(&args[2..])?,
	    "--round" => round(&args[2..])?,
	    "--ceil" => ceil(&args[2..])?,
	    "--floor" => floor(&args[2..])?,
	    "--of" => of(&args[2..])?,
	    "--shuffle" => shuffle(&args[2..])?,
	    _ => usage()
	};
	Ok(())
    }
}