use crate::float::Float;
use crate::int::{CastInto, Int};

fn trunc<F: Float, R: Float>(a: F) -> R
where
    F::Int: CastInto<u64>,
    F::Int: CastInto<u32>,
    u64: CastInto<F::Int>,
    u32: CastInto<F::Int>,

    R::Int: CastInto<u32>,
    u32: CastInto<R::Int>,
    F::Int: CastInto<R::Int>,
{
    let src_zero = F::Int::ZERO;
    let src_one = F::Int::ONE;
    let src_bits = F::BITS;
    let src_exp_bias = F::EXPONENT_BIAS;

    let src_min_normal = F::IMPLICIT_BIT;
    let src_significand_mask = F::SIGNIFICAND_MASK;
    let src_infinity = F::EXPONENT_MASK;
    let src_sign_mask = F::SIGN_MASK;
    let src_abs_mask = src_sign_mask - src_one;
    let round_mask = (src_one << (F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS)) - src_one;
    let halfway = src_one << (F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS - 1);
    let src_qnan = src_one << (F::SIGNIFICAND_BITS - 1);
    let src_nan_code = src_qnan - src_one;

    let dst_zero = R::Int::ZERO;
    let dst_one = R::Int::ONE;
    let dst_bits = R::BITS;
    let dst_inf_exp = R::EXPONENT_MAX;
    let dst_exp_bias = R::EXPONENT_BIAS;

    let underflow_exponent: F::Int = (src_exp_bias + 1 - dst_exp_bias).cast();
    let overflow_exponent: F::Int = (src_exp_bias + dst_inf_exp - dst_exp_bias).cast();
    let underflow: F::Int = underflow_exponent << F::SIGNIFICAND_BITS;
    let overflow: F::Int = overflow_exponent << F::SIGNIFICAND_BITS;

    let dst_qnan = R::Int::ONE << (R::SIGNIFICAND_BITS - 1);
    let dst_nan_code = dst_qnan - dst_one;

    let sign_bits_delta = F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS;
    // Break a into a sign and representation of the absolute value.
    let a_abs = a.repr() & src_abs_mask;
    let sign = a.repr() & src_sign_mask;
    let mut abs_result: R::Int;

    if a_abs.wrapping_sub(underflow) < a_abs.wrapping_sub(overflow) {
        // The exponent of a is within the range of normal numbers in the
        // destination format.  We can convert by simply right-shifting with
        // rounding and adjusting the exponent.
        abs_result = (a_abs >> sign_bits_delta).cast();
        let tmp = src_exp_bias.wrapping_sub(dst_exp_bias) << R::SIGNIFICAND_BITS;
        abs_result = abs_result.wrapping_sub(tmp.cast());

        let round_bits = a_abs & round_mask;
        if round_bits > halfway {
            // Round to nearest.
            abs_result += dst_one;
        } else if round_bits == halfway {
            // Tie to even.
            abs_result += abs_result & dst_one;
        };
    } else if a_abs > src_infinity {
        // a is NaN.
        // Conjure the result by beginning with infinity, setting the qNaN
        // bit and inserting the (truncated) trailing NaN field.
        abs_result = (dst_inf_exp << R::SIGNIFICAND_BITS).cast();
        abs_result |= dst_qnan;
        abs_result |= dst_nan_code
            & ((a_abs & src_nan_code) >> (F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS)).cast();
    } else if a_abs >= overflow {
        // a overflows to infinity.
        abs_result = (dst_inf_exp << R::SIGNIFICAND_BITS).cast();
    } else {
        // a underflows on conversion to the destination type or is an exact
        // zero.  The result may be a denormal or zero.  Extract the exponent
        // to get the shift amount for the denormalization.
        let a_exp: u32 = (a_abs >> F::SIGNIFICAND_BITS).cast();
        let shift = src_exp_bias - dst_exp_bias - a_exp + 1;

        let significand = (a.repr() & src_significand_mask) | src_min_normal;

        // Right shift by the denormalization amount with sticky.
        if shift > F::SIGNIFICAND_BITS {
            abs_result = dst_zero;
        } else {
            let sticky = if (significand << (src_bits - shift)) != src_zero {
                src_one
            } else {
                src_zero
            };
            let denormalized_significand: F::Int = significand >> shift | sticky;
            abs_result =
                (denormalized_significand >> (F::SIGNIFICAND_BITS - R::SIGNIFICAND_BITS)).cast();
            let round_bits = denormalized_significand & round_mask;
            // Round to nearest
            if round_bits > halfway {
                abs_result += dst_one;
            }
            // Ties to even
            else if round_bits == halfway {
                abs_result += abs_result & dst_one;
            };
        }
    }

    // Apply the signbit to the absolute value.
    R::from_repr(abs_result | sign.wrapping_shr(src_bits - dst_bits).cast())
}

intrinsics! {
    #[avr_skip]
    #[aapcs_on_arm]
    #[arm_aeabi_alias = __aeabi_d2f]
    pub extern "C" fn __truncdfsf2(a: f64) -> f32 {
        trunc(a)
    }

    #[cfg(target_arch = "arm")]
    pub extern "C" fn __truncdfsf2vfp(a: f64) -> f32 {
        a as f32
    }
}
