use super::funejson::Value;
use super::math_big_integer::BigInt;
use super::math_fractional_power::{fixed_scale, fractional_power_fixed};
use super::money_amount::{money_from_value, Money};

/// The largest integer every language holds exactly (2^53 − 1).
const MAX_SAFE: i64 = 9007199254740991;

fn check_years(name: &str, value: i64) {
    if value < 1 || value > 100000 {
        panic!("{} must be a whole number from 1 to 100000, received {}", name, value);
    }
}

/// n / d rounded half away from zero; d > 0.
fn round_half_away(n: &BigInt, d: &BigInt) -> BigInt {
    let two = BigInt::from_i64(2);
    let magnitude = n.abs().mul(&two).add(d).div(&two.mul(d));
    if n.is_negative() {
        magnitude.neg()
    } else {
        magnitude
    }
}

/// Compound annual growth rate, (end / start)^(1 / years) − 1, in basis
/// points rounded half away from zero. Years are years_numerator /
/// years_denominator so no float ever enters the power.
///
/// # Panics
/// Panics on a start of zero or less, a negative end, mixed currencies, years
/// out of range, or a rate too large to express.
pub fn cagr(start_value: &Money, end_value: &Money, years_numerator: i64, years_denominator: i64) -> i64 {
    if start_value.currency != end_value.currency {
        panic!("currency mismatch: {} and {}", start_value.currency, end_value.currency);
    }
    check_years("yearsNumerator", years_numerator);
    check_years("yearsDenominator", years_denominator);
    if start_value.minor <= 0 {
        panic!("startValue must be greater than zero, received {}", start_value.minor);
    }
    if end_value.minor < 0 {
        panic!("endValue must not be negative, received {}", end_value.minor);
    }
    if end_value.minor == 0 {
        return -10000;
    }
    let scale = fixed_scale();
    let ratio = BigInt::from_i64(end_value.minor).mul(&scale).div(&BigInt::from_i64(start_value.minor));
    // Exponent 1 / years = years_denominator / years_numerator.
    let growth = fractional_power_fixed(&ratio, years_denominator, years_numerator);
    let bp = round_half_away(&growth.sub(&scale).mul(&BigInt::from_i64(10000)), &scale);
    if bp > BigInt::from_i64(MAX_SAFE) {
        panic!("the growth rate is too large to express in basis points");
    }
    bp.to_i64()
}

fn whole(v: &Value, what: &str) {
    if let Value::Float(f) = v {
        if f.fract() != 0.0 {
            panic!("{}, received {}", what, f);
        }
    }
}

pub fn fune_vector(args: &[Value]) -> Value {
    // Refuse what the typed signature cannot hold, with the wording TypeScript
    // and Python use, rather than let the conversion quietly truncate it.
    whole(args[0].get("minor"), "amounts must be whole minor units");
    whole(args[1].get("minor"), "amounts must be whole minor units");
    whole(&args[2], "yearsNumerator must be a whole number from 1 to 100000");
    whole(&args[3], "yearsDenominator must be a whole number from 1 to 100000");
    Value::Int(cagr(&money_from_value(&args[0]), &money_from_value(&args[1]), args[2].as_i64(), args[3].as_i64()))
}