//! Fixed point math helpers that are specific to TrueType hinting.
//!
//! These are implemented in terms of font-types types when possible. It
//! likely makes sense to use more strongly typed fixed point values
//! in the future.

use read_fonts::types::{Fixed, Point};

pub fn floor(x: i32) -> i32 {
    x & !63
}

pub fn round(x: i32) -> i32 {
    floor(x + 32)
}

pub fn ceil(x: i32) -> i32 {
    floor(x + 63)
}

fn floor_pad(x: i32, n: i32) -> i32 {
    x & !(n - 1)
}

pub fn round_pad(x: i32, n: i32) -> i32 {
    floor_pad(x + n / 2, n)
}

#[inline(always)]
pub fn mul(a: i32, b: i32) -> i32 {
    (Fixed::from_bits(a) * Fixed::from_bits(b)).to_bits()
}

pub fn div(a: i32, b: i32) -> i32 {
    (Fixed::from_bits(a) / Fixed::from_bits(b)).to_bits()
}

/// Fixed point multiply and divide: a * b / c
pub fn mul_div(a: i32, b: i32, c: i32) -> i32 {
    Fixed::from_bits(a)
        .mul_div(Fixed::from_bits(b), Fixed::from_bits(c))
        .to_bits()
}

/// Fixed point multiply and divide without rounding: a * b / c
///
/// Based on <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/base/ftcalc.c#L200>
pub fn mul_div_no_round(mut a: i32, mut b: i32, mut c: i32) -> i32 {
    let mut s = 1;
    if a < 0 {
        a = -a;
        s = -1;
    }
    if b < 0 {
        b = -b;
        s = -s;
    }
    if c < 0 {
        c = -c;
        s = -s;
    }
    let d = if c > 0 {
        ((a as i64) * (b as i64)) / c as i64
    } else {
        0x7FFFFFFF
    };
    if s < 0 {
        -(d as i32)
    } else {
        d as i32
    }
}

/// Multiplication for 2.14 fixed point.
///
/// Based on <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/truetype/ttinterp.c#L1234>
pub fn mul14(a: i32, b: i32) -> i32 {
    let mut v = a as i64 * b as i64;
    v += 0x2000 + (v >> 63);
    (v >> 14) as i32
}

/// Normalize a vector in 2.14 fixed point.
///
/// Direct port of <https://gitlab.freedesktop.org/freetype/freetype/-/blob/57617782464411201ce7bbc93b086c1b4d7d84a5/src/base/ftcalc.c#L800>
pub fn normalize14(x: i32, y: i32) -> Point<i32> {
    use core::num::Wrapping;
    let (mut sx, mut sy) = (Wrapping(1i32), Wrapping(1i32));
    let mut ux = Wrapping(x as u32);
    let mut uy = Wrapping(y as u32);
    const ZERO: Wrapping<u32> = Wrapping(0);
    let mut result = Point::default();
    if x < 0 {
        ux = ZERO - ux;
        sx = -sx;
    }
    if y < 0 {
        uy = ZERO - uy;
        sy = -sy;
    }
    if ux == ZERO {
        result.x = x / 4;
        if uy.0 > 0 {
            result.y = (sy * Wrapping(0x10000) / Wrapping(4)).0;
        }
        return result;
    }
    if uy == ZERO {
        result.y = y / 4;
        if ux.0 > 0 {
            result.x = (sx * Wrapping(0x10000) / Wrapping(4)).0;
        }
        return result;
    }
    let mut len = if ux > uy {
        ux + (uy >> 1)
    } else {
        uy + (ux >> 1)
    };
    let mut shift = Wrapping(len.0.leading_zeros() as i32);
    shift -= Wrapping(15)
        + if len >= (Wrapping(0xAAAAAAAAu32) >> shift.0 as usize) {
            Wrapping(1)
        } else {
            Wrapping(0)
        };
    if shift.0 > 0 {
        let s = shift.0 as usize;
        ux <<= s;
        uy <<= s;
        len = if ux > uy {
            ux + (uy >> 1)
        } else {
            uy + (ux >> 1)
        };
    } else {
        let s = -shift.0 as usize;
        ux >>= s;
        uy >>= s;
        len >>= s;
    }
    let mut b = Wrapping(0x10000) - Wrapping(len.0 as i32);
    let x = Wrapping(ux.0 as i32);
    let y = Wrapping(uy.0 as i32);
    let mut z;
    let mut u;
    let mut v;
    loop {
        u = Wrapping((x + ((x * b) >> 16)).0 as u32);
        v = Wrapping((y + ((y * b) >> 16)).0 as u32);
        z = Wrapping(-((u * u + v * v).0 as i32)) / Wrapping(0x200);
        z = z * ((Wrapping(0x10000) + b) >> 8) / Wrapping(0x10000);
        b += z;
        if z <= Wrapping(0) {
            break;
        }
    }
    Point::new(
        (Wrapping(u.0 as i32) * sx / Wrapping(4)).0,
        (Wrapping(v.0 as i32) * sy / Wrapping(4)).0,
    )
}

#[cfg(test)]
mod tests {
    use raw::types::{F2Dot14, Fixed};

    /// Tolerance value for floating point sanity checks.
    /// Tests with large sets of values show this is the best we can
    /// expect from the fixed point implementations.
    const FLOAT_TOLERANCE: f32 = 1e-4;

    #[test]
    fn mul_div_no_round() {
        let cases = [
            // computed with FT_MulDiv_NoRound():
            // ((a, b, c), result) where result = a * b / c
            ((-326, -11474, 9942), 376),
            ((-6781, 13948, 11973), -7899),
            ((3517, 15622, 8075), 6804),
            ((-6127, 15026, 2276), -40450),
            ((11257, 14828, 2542), 65664),
            ((-12797, -16280, -9086), -22929),
            ((-7994, -3340, 9583), 2786),
            ((-16101, -13780, -1427), -155481),
            ((10304, -16331, 15480), -10870),
            ((-15879, 11912, -4650), 40677),
            ((-5015, 6382, -15977), 2003),
            ((2080, -11930, -15457), 1605),
            ((-11071, 13350, 16138), -9158),
            ((16084, -13564, -770), 283329),
            ((14304, -10377, -21), 7068219),
            ((-14056, -8853, -5488), -22674),
            ((-10319, 14797, 8554), -17850),
            ((-7820, 6826, 10555), -5057),
            ((7257, 15928, 8159), 14167),
            ((14929, 11579, -13204), -13091),
            ((2808, 12070, -14697), -2306),
            ((-13818, 8544, -1649), 71595),
            ((3265, 7325, -1373), -17418),
            ((14832, 10586, -6440), -24380),
            ((4123, 8274, -2022), -16871),
            ((4645, -4149, -7242), 2661),
            ((-3891, 8366, 5771), -5640),
            ((-15447, -3428, -9335), -5672),
            ((13670, -14311, -11122), 17589),
            ((12590, -6592, 13159), -6306),
            ((-8369, -10193, 5051), 16888),
            ((-9539, 5167, 2595), -18993),
        ];
        for ((a, b, c), expected_result) in cases {
            let result = super::mul_div_no_round(a, b, c);
            assert_eq!(result, expected_result);
            let fa = Fixed::from_bits(a as _).to_f32();
            let fb = Fixed::from_bits(b as _).to_f32();
            let fc = Fixed::from_bits(c as _).to_f32();
            let fresult = fa * fb / fc;
            let fexpected_result = Fixed::from_bits(expected_result as _).to_f32();
            assert!((fresult - fexpected_result).abs() < FLOAT_TOLERANCE);
        }
    }

    #[test]
    fn mul14() {
        let cases = [
            // computed with TT_MulFix14():
            // ((a, b), result) where result = a * b
            ((6236, -10078), -3836),
            ((-6803, -5405), 2244),
            ((-10006, -12852), 7849),
            ((-15434, -4102), 3864),
            ((-8681, 9269), -4911),
            ((9449, -9130), -5265),
            ((12643, 2161), 1668),
            ((-6115, 9284), -3465),
            ((316, 3390), 65),
            ((15077, -12901), -11872),
            ((-12182, 11613), -8635),
            ((-7213, 8246), -3630),
            ((13482, 8096), 6662),
            ((5690, 15016), 5215),
            ((-5991, 12613), -4612),
            ((13112, -8404), -6726),
            ((13524, 6786), 5601),
            ((7156, 3291), 1437),
            ((-2978, 353), -64),
            ((-1755, 14626), -1567),
            ((14402, 7886), 6932),
            ((7124, 15730), 6840),
            ((-12679, 14830), -11476),
            ((-9374, -12999), 7437),
            ((12301, -4685), -3517),
            ((5324, 2066), 671),
            ((6783, -4946), -2048),
            ((12078, -968), -714),
            ((-10137, 14116), -8734),
            ((-13946, 11585), -9861),
            ((-678, -2205), 91),
            ((-2629, -3319), 533),
        ];
        for ((a, b), expected_result) in cases {
            let result = super::mul14(a, b);
            assert_eq!(result, expected_result);
            let fa = F2Dot14::from_bits(a as _).to_f32();
            let fb = F2Dot14::from_bits(b as _).to_f32();
            let fresult = fa * fb;
            let fexpected_result = F2Dot14::from_bits(expected_result as _).to_f32();
            assert!((fresult - fexpected_result).abs() < FLOAT_TOLERANCE);
        }
    }

    #[test]
    fn normalize14() {
        let cases = [
            // computed with FT_Vector_NormLen():
            // (input vector, expected normalized vector)
            ((-13660, 11807), (-12395, 10713)),
            ((-10763, 9293), (-12401, 10707)),
            ((-3673, 673), (-16115, 2952)),
            ((15886, -2964), (16106, -3005)),
            ((15442, -2871), (16108, -2994)),
            ((-6308, 5744), (-12114, 11031)),
            ((9410, -10415), (10983, -12156)),
            ((-10620, -14856), (-9528, -13328)),
            ((-9372, 12029), (-10069, 12924)),
            ((-1272, -1261), (-11635, -11534)),
            ((-7076, -5517), (-12920, -10074)),
            ((-10297, 179), (-16381, 284)),
            ((9256, -13235), (9389, -13426)),
            ((5315, -12449), (6433, -15068)),
            ((8064, 15213), (7673, 14476)),
            ((-8665, 41), (-16383, 77)),
            ((-3455, -4720), (-9677, -13220)),
            ((13449, -5152), (15299, -5861)),
            ((-15605, 8230), (-14492, 7643)),
            ((4716, -13690), (5336, -15490)),
            ((12904, -11422), (12268, -10859)),
            ((2825, -6396), (6619, -14987)),
            ((4654, 15245), (4783, 15670)),
            ((-14769, 15133), (-11443, 11725)),
            ((-8090, -9057), (-10914, -12219)),
            ((-472, 1953), (-3848, 15925)),
            ((-12563, 1040), (-16328, 1351)),
            ((-7938, 15587), (-7435, 14599)),
            ((-9701, 5356), (-14343, 7919)),
            ((-642, -14484), (-725, -16367)),
            ((12963, -9690), (13123, -9809)),
            ((7067, 5361), (13053, 9902)),
            ((0x4000, 0), (0x4000, 0)),
            ((0, 0x4000), (0, 0x4000)),
            ((-0x4000, 0), (-0x4000, 0)),
            ((0, -0x4000), (0, -0x4000)),
        ];
        for ((x, y), expected) in cases {
            let n = super::normalize14(x, y);
            assert_eq!((n.x, n.y), expected);
            // Ensure the length of the vector is nearly 1.0
            let fx = F2Dot14::from_bits(n.x as _).to_f32();
            let fy = F2Dot14::from_bits(n.y as _).to_f32();
            let flen = (fx * fx + fy * fy).sqrt();
            assert!((flen - 1.0).abs() <= FLOAT_TOLERANCE);
        }
    }
}