use crate::ScriptManager;

use super::LIBRARY_NAME;

fn abs_i32(n: i32) -> i32 {
	n.abs()
}

fn abs_i64(n: i64) -> i64 {
	n.abs()
}

fn mod_f32(x: f32, y: f32) -> f32 {
	libm::fmodf(x, y)
}

fn mod_f64(x: f64, y: f64) -> f64 {
	libm::fmod(x, y)
}

fn remainder_f32(x: f32, y: f32) -> f32 {
	libm::remainderf(x, y)
}

fn remainder_f64(x: f64, y: f64) -> f64 {
	libm::remainder(x, y)
}

fn mul_add_f32(x: f32, y: f32, z: f32) -> f32 {
	x.mul_add(y, z)
}

fn mul_add_f64(x: f64, y: f64, z: f64) -> f64 {
	x.mul_add(y, z)
}

fn fdim_f32(x: f32, y: f32) -> f32 {
	libm::fdimf(x, y)
}

fn fdim_f64(x: f64, y: f64) -> f64 {
	libm::fdim(x, y)
}

fn exp_f32(x: f32) -> f32 {
	x.exp()
}

fn exp_f64(x: f64) -> f64 {
	x.exp()
}

fn exp2_f32(x: f32) -> f32 {
	x.exp2()
}

fn exp2_f64(x: f64) -> f64 {
	x.exp2()
}

fn expm1_f32(x: f32) -> f32 {
	x.exp_m1()
}

fn expm1_f64(x: f64) -> f64 {
	x.exp_m1()
}

fn ln_f32(x: f32) -> f32 {
	x.ln()
}

fn ln_f64(x: f64) -> f64 {
	x.ln()
}

fn log10_f32(x: f32) -> f32 {
	x.log10()
}

fn log10_f64(x: f64) -> f64 {
	x.log10()
}

fn log2_f32(x: f32) -> f32 {
	x.log2()
}

fn log2_f64(x: f64) -> f64 {
	x.log2()
}

fn ln1p_f32(x: f32) -> f32 {
	x.ln_1p()
}

fn ln1p_f64(x: f64) -> f64 {
	x.ln_1p()
}

fn pow_f32(base: f32, exponent: f32) -> f32 {
	base.powf(exponent)
}

fn pow_f64(base: f64, exponent: f64) -> f64 {
	base.powf(exponent)
}

fn cbrt_f32(x: f32) -> f32 {
	x.cbrt()
}

fn cbrt_f64(x: f64) -> f64 {
	x.cbrt()
}

fn hypotenuse_f32(x: f32, y: f32) -> f32 {
	x.hypot(y)
}

fn hypotenuse_f64(x: f64, y: f64) -> f64 {
	x.hypot(y)
}

fn sin_f32(x: f32) -> f32 {
	x.sin()
}

fn sin_f64(x: f64) -> f64 {
	x.sin()
}

fn cos_f32(x: f32) -> f32 {
	x.cos()
}

fn cos_f64(x: f64) -> f64 {
	x.cos()
}

fn tan_f32(x: f32) -> f32 {
	x.tan()
}

fn tan_f64(x: f64) -> f64 {
	x.tan()
}

fn asin_f32(x: f32) -> f32 {
	x.asin()
}

fn asin_f64(x: f64) -> f64 {
	x.asin()
}

fn acos_f32(x: f32) -> f32 {
	x.acos()
}

fn acos_f64(x: f64) -> f64 {
	x.acos()
}

fn atan_f32(x: f32) -> f32 {
	x.atan()
}

fn atan_f64(x: f64) -> f64 {
	x.atan()
}

fn sinh_f32(x: f32) -> f32 {
	x.sinh()
}

fn sinh_f64(x: f64) -> f64 {
	x.sinh()
}

fn cosh_f32(x: f32) -> f32 {
	x.cosh()
}

fn cosh_f64(x: f64) -> f64 {
	x.cosh()
}

fn tanh_f32(x: f32) -> f32 {
	x.tanh()
}

fn tanh_f64(x: f64) -> f64 {
	x.tanh()
}

fn asinh_f32(x: f32) -> f32 {
	x.asinh()
}

fn asinh_f64(x: f64) -> f64 {
	x.asinh()
}

fn acosh_f32(x: f32) -> f32 {
	x.acosh()
}

fn acosh_f64(x: f64) -> f64 {
	x.acosh()
}

fn atanh_f32(x: f32) -> f32 {
	x.atanh()
}

fn atanh_f64(x: f64) -> f64 {
	x.atanh()
}

fn erf_f32(x: f32) -> f32 {
	libm::erff(x)
}

fn erf_f64(x: f64) -> f64 {
	libm::erf(x)
}

fn erfc_f32(x: f32) -> f32 {
	libm::erfcf(x)
}

fn erfc_f64(x: f64) -> f64 {
	libm::erfc(x)
}

fn gamma_f32(x: f32) -> f32 {
	libm::tgammaf(x)
}

fn gamma_f64(x: f64) -> f64 {
	libm::tgamma(x)
}

fn ln_gamma_f32(x: f32) -> f32 {
	libm::lgammaf(x)
}

fn ln_gamma_f64(x: f64) -> f64 {
	libm::lgamma(x)
}

fn round_f32_i32(x: f32) -> i32 {
	x.round() as i32
}

fn round_f64_i32(x: f64) -> i32 {
	x.round() as i32
}

fn round_f32_i64(x: f32) -> i64 {
	x.round() as i64
}

fn round_f64_i64(x: f64) -> i64 {
	x.round() as i64
}

fn frexp_f32(x: f32) -> (f32, i32) {
	libm::frexpf(x)
}

fn frexp_f64(x: f64) -> (f64, i32) {
	libm::frexp(x)
}

fn ldexp_f32(x: f32, exp: i32) -> f32 {
	libm::ldexpf(x, exp)
}

fn ldexp_f64(x: f64, exp: i32) -> f64 {
	libm::ldexp(x, exp)
}

fn modf_f32(x: f32) -> (f32, f32) {
	libm::modff(x)
}

fn modf_f64(x: f64) -> (f64, f64) {
	libm::modf(x)
}

fn logb_f32(x: f32) -> i32 {
	libm::ilogbf(x)
}

fn logb_f64(x: f64) -> i32 {
	libm::ilogb(x)
}

fn next_after_f32(from: f32, to: f32) -> f32 {
	libm::nextafterf(from, to)
}

fn next_after_f64(from: f64, to: f64) -> f64 {
	libm::nextafter(from, to)
}

fn copy_sign_f32(x: f32, y: f32) -> f32 {
	libm::copysignf(x, y)
}

fn copy_sign_f64(x: f64, y: f64) -> f64 {
	libm::copysign(x, y)
}

pub fn library(manager: &mut ScriptManager) -> Option<()> {
	manager.add_library_function(LIBRARY_NAME, "abs", abs_i32)?;
	manager.add_library_function(LIBRARY_NAME, "labs", abs_i64)?;
	manager.add_library_function(LIBRARY_NAME, "modf", mod_f32)?;
	manager.add_library_function(LIBRARY_NAME, "mod", mod_f64)?;
	manager.add_library_function(LIBRARY_NAME, "remf", remainder_f32)?;
	manager.add_library_function(LIBRARY_NAME, "rem", remainder_f64)?;
	manager.add_library_function(LIBRARY_NAME, "fmaf", mul_add_f32)?;
	manager.add_library_function(LIBRARY_NAME, "fma", mul_add_f64)?;
	manager.add_library_function(LIBRARY_NAME, "fdimf", fdim_f32)?;
	manager.add_library_function(LIBRARY_NAME, "fdim", fdim_f64)?;
	manager.add_library_function(LIBRARY_NAME, "expf", exp_f32)?;
	manager.add_library_function(LIBRARY_NAME, "exp", exp_f64)?;
	manager.add_library_function(LIBRARY_NAME, "exp2f", exp2_f32)?;
	manager.add_library_function(LIBRARY_NAME, "exp2", exp2_f64)?;
	manager.add_library_function(LIBRARY_NAME, "expm1f", expm1_f32)?;
	manager.add_library_function(LIBRARY_NAME, "expm1", expm1_f64)?;
	manager.add_library_function(LIBRARY_NAME, "lnf", ln_f32)?;
	manager.add_library_function(LIBRARY_NAME, "ln", ln_f64)?;
	manager.add_library_function(LIBRARY_NAME, "log2f", log2_f32)?;
	manager.add_library_function(LIBRARY_NAME, "log2", log2_f64)?;
	manager.add_library_function(LIBRARY_NAME, "log10f", log10_f32)?;
	manager.add_library_function(LIBRARY_NAME, "log10", log10_f64)?;
	manager.add_library_function(LIBRARY_NAME, "ln1pf", ln1p_f32)?;
	manager.add_library_function(LIBRARY_NAME, "ln1p", ln1p_f64)?;
	manager.add_library_function(LIBRARY_NAME, "powf", pow_f32)?;
	manager.add_library_function(LIBRARY_NAME, "pow", pow_f64)?;
	manager.add_library_function(LIBRARY_NAME, "cbrtf", cbrt_f32)?;
	manager.add_library_function(LIBRARY_NAME, "cbrt", cbrt_f64)?;
	manager.add_library_function(LIBRARY_NAME, "hypotf", hypotenuse_f32)?;
	manager.add_library_function(LIBRARY_NAME, "hypot", hypotenuse_f64)?;
	manager.add_library_function(LIBRARY_NAME, "sinf", sin_f32)?;
	manager.add_library_function(LIBRARY_NAME, "sin", sin_f64)?;
	manager.add_library_function(LIBRARY_NAME, "cosf", cos_f32)?;
	manager.add_library_function(LIBRARY_NAME, "cos", cos_f64)?;
	manager.add_library_function(LIBRARY_NAME, "tanf", tan_f32)?;
	manager.add_library_function(LIBRARY_NAME, "tan", tan_f64)?;
	manager.add_library_function(LIBRARY_NAME, "asinf", asin_f32)?;
	manager.add_library_function(LIBRARY_NAME, "asin", asin_f64)?;
	manager.add_library_function(LIBRARY_NAME, "acosf", acos_f32)?;
	manager.add_library_function(LIBRARY_NAME, "acos", acos_f64)?;
	manager.add_library_function(LIBRARY_NAME, "atanf", atan_f32)?;
	manager.add_library_function(LIBRARY_NAME, "atan", atan_f64)?;
	manager.add_library_function(LIBRARY_NAME, "sinhf", sinh_f32)?;
	manager.add_library_function(LIBRARY_NAME, "sinh", sinh_f64)?;
	manager.add_library_function(LIBRARY_NAME, "coshf", cosh_f32)?;
	manager.add_library_function(LIBRARY_NAME, "cosh", cosh_f64)?;
	manager.add_library_function(LIBRARY_NAME, "tanhf", tanh_f32)?;
	manager.add_library_function(LIBRARY_NAME, "tanh", tanh_f64)?;
	manager.add_library_function(LIBRARY_NAME, "asinhf", asinh_f32)?;
	manager.add_library_function(LIBRARY_NAME, "asinh", asinh_f64)?;
	manager.add_library_function(LIBRARY_NAME, "acoshf", acosh_f32)?;
	manager.add_library_function(LIBRARY_NAME, "acosh", acosh_f64)?;
	manager.add_library_function(LIBRARY_NAME, "atanhf", atanh_f32)?;
	manager.add_library_function(LIBRARY_NAME, "atanh", atanh_f64)?;
	manager.add_library_function(LIBRARY_NAME, "erff", erf_f32)?;
	manager.add_library_function(LIBRARY_NAME, "erf", erf_f64)?;
	manager.add_library_function(LIBRARY_NAME, "erfcf", erfc_f32)?;
	manager.add_library_function(LIBRARY_NAME, "erfc", erfc_f64)?;
	manager.add_library_function(LIBRARY_NAME, "gammaf", gamma_f32)?;
	manager.add_library_function(LIBRARY_NAME, "gamma", gamma_f64)?;
	manager.add_library_function(LIBRARY_NAME, "lgammaf", ln_gamma_f32)?;
	manager.add_library_function(LIBRARY_NAME, "lgamma", ln_gamma_f64)?;
	manager.add_library_function(LIBRARY_NAME, "lroundf", round_f32_i32)?;
	manager.add_library_function(LIBRARY_NAME, "lround", round_f64_i32)?;
	manager.add_library_function(LIBRARY_NAME, "llroundf", round_f32_i64)?;
	manager.add_library_function(LIBRARY_NAME, "llround", round_f64_i64)?;
	manager.add_library_function(LIBRARY_NAME, "frexpf", frexp_f32)?;
	manager.add_library_function(LIBRARY_NAME, "frexp", frexp_f64)?;
	manager.add_library_function(LIBRARY_NAME, "ldexpf", ldexp_f32)?;
	manager.add_library_function(LIBRARY_NAME, "ldexp", ldexp_f64)?;
	manager.add_library_function(LIBRARY_NAME, "modff", modf_f32)?;
	manager.add_library_function(LIBRARY_NAME, "modf", modf_f64)?;
	manager.add_library_function(LIBRARY_NAME, "ilogbf", logb_f32)?;
	manager.add_library_function(LIBRARY_NAME, "ilogb", logb_f64)?;
	manager.add_library_function(LIBRARY_NAME, "nextafterf", next_after_f32)?;
	manager.add_library_function(LIBRARY_NAME, "nextafter", next_after_f64)?;
	manager.add_library_function(LIBRARY_NAME, "copysignf", copy_sign_f32)?;
	manager.add_library_function(LIBRARY_NAME, "copysign", copy_sign_f64)?;

	Some(())
}