use std::{fs::File, os::unix::prelude::*, path::Path};

use nix::{
	fcntl::{self, FcntlArg, FdFlag, OFlag},
	sched,
	unistd::Pid,
};

use common::error::*;

use super::fs;

pub fn set_blocking(fd: RawFd, blocking: bool) -> Result<()> {
	let flags = unsafe {
		OFlag::from_bits_unchecked(fcntl::fcntl(fd, FcntlArg::F_GETFL).context("fcntl(F_GETFL)")?)
	};

	let new_flags = if blocking {
		flags & !OFlag::O_NONBLOCK
	} else {
		flags | OFlag::O_NONBLOCK
	};

	if new_flags != flags {
		fcntl::fcntl(fd, FcntlArg::F_SETFL(new_flags)).context("fcntl(F_SETFL)")?;
	}

	Ok(())
}

pub fn set_cloexec(fd: RawFd, cloexec: bool) -> Result<()> {
	let flags = unsafe {
		FdFlag::from_bits_unchecked(fcntl::fcntl(fd, FcntlArg::F_GETFD).context("fcntl(F_GETFD)")?)
	};

	let new_flags = if cloexec {
		flags | FdFlag::FD_CLOEXEC
	} else {
		flags & !FdFlag::FD_CLOEXEC
	};

	if new_flags != flags {
		fcntl::fcntl(fd, FcntlArg::F_SETFD(new_flags)).context("fcntl(F_SETFD)")?;
	}

	Ok(())
}

pub fn nproc() -> Result<usize> {
	const MAXCPU: usize = sched::CpuSet::count();

	let affinity = sched::sched_getaffinity(Pid::from_raw(0)).context("sched_getaffinity()")?;

	let mut count = 0;

	for cpu in 0..MAXCPU {
		if affinity.is_set(cpu).unwrap() {
			count += 1;
		}
	}

	Ok(count)
}

pub fn lock<P: AsRef<Path>>(path: P, exclusive: bool, blocking: bool) -> Result<File> {
	use fcntl::FlockArg::*;

	if let Some(parent) = path.as_ref().parent() {
		fs::mkdir(parent)?;
	}

	let arg = match (exclusive, blocking) {
		(true, true) => LockExclusive,
		(true, false) => LockExclusiveNonblock,
		(false, true) => LockShared,
		(false, false) => LockSharedNonblock,
	};

	let file = fs::create(path.as_ref())?;
	fcntl::flock(file.as_raw_fd(), arg)
		.with_context(|| format!("flock failed on {:?}", path.as_ref()))?;

	Ok(file)
}