#![allow(unused_features)]
#![cfg_attr(not(test), no_std)]
#![feature(asm)]
#![feature(core_intrinsics)]
#![feature(naked_functions)]
// TODO(rust-lang/rust#35021) uncomment when that PR lands
// #![feature(rustc_builtins)]

#[cfg(test)]
extern crate core;
#[cfg(test)]
#[macro_use]
extern crate quickcheck;

#[cfg(target_arch = "arm")]
pub mod arm;

#[cfg(test)]
mod test;

use core::mem;

/// Trait for some basic operations on integers
trait Int {
    fn bits() -> usize;
}

// TODO: Once i128/u128 support lands, we'll want to add impls for those as well
impl Int for u32 {
    fn bits() -> usize { 32 }
}
impl Int for i32 {
    fn bits() -> usize { 32 }
}
impl Int for u64 {
    fn bits() -> usize { 64 }
}
impl Int for i64 {
    fn bits() -> usize { 64 }
}

/// Trait to convert an integer to/from smaller parts
trait LargeInt {
    type LowHalf;
    type HighHalf;

    fn low(self) -> Self::LowHalf;
    fn high(self) -> Self::HighHalf;
    fn from_parts(low: Self::LowHalf, high: Self::HighHalf) -> Self;
}

// TODO: Once i128/u128 support lands, we'll want to add impls for those as well
impl LargeInt for u64 {
    type LowHalf = u32;
    type HighHalf = u32;

    fn low(self) -> u32 {
        self as u32
    }
    fn high(self) -> u32 {
        (self >> 32) as u32
    }
    fn from_parts(low: u32, high: u32) -> u64 {
        low as u64 | ((high as u64) << 32)
    }
}
impl LargeInt for i64 {
    type LowHalf = u32;
    type HighHalf = i32;

    fn low(self) -> u32 {
        self as u32
    }
    fn high(self) -> i32 {
        (self >> 32) as i32
    }
    fn from_parts(low: u32, high: i32) -> i64 {
        low as i64 | ((high as i64) << 32)
    }
}

macro_rules! absv_i2 {
    ($intrinsic:ident : $ty:ty) => {
        #[no_mangle]
        pub extern "C" fn $intrinsic(x: $ty) -> $ty {
            let n = <$ty>::bits();
            if x == 1 << (n - 1) {
                panic!();
            }
            let y = x >> (n - 1);
            (x ^ y) - y
        }

    }
}

absv_i2!(__absvsi2: i32);
absv_i2!(__absvdi2: i64);
// TODO(rust-lang/35118)?
// absv_i2!(__absvti2, i128);

#[no_mangle]
pub extern "C" fn __udivmoddi4(a: u64, b: u64, rem: Option<&mut u64>) -> u64 {
    #[cfg(target_endian = "little")]
    #[repr(C)]
    #[derive(Debug)]
    struct words {
        low: u32,
        high: u32,
    }

    #[cfg(target_endian = "big")]
    #[repr(C)]
    #[derive(Debug)]
    struct words {
        high: u32,
        low: u32,
    }

    impl words {
        fn all(&mut self) -> &mut u64 {
            unsafe { mem::transmute(self) }
        }

        fn u64(&self) -> u64 {
            unsafe { *(self as *const _ as *const u64) }
        }
    }

    impl From<u64> for words {
        fn from(x: u64) -> words {
            unsafe { mem::transmute(x) }
        }
    }

    let u32_bits = u32::bits() as u32;
    let u64_bits = u64::bits() as u32;

    let n = words::from(a);
    let d = words::from(b);

    // NOTE X is unknown, K != 0
    if n.high == 0 {
        return if d.high == 0 {
            // 0 X
            // ---
            // 0 X

            if let Some(rem) = rem {
                *rem = u64::from(n.low % d.low);
            }
            u64::from(n.low / d.low)
        } else
               // d.high != 0
               {
            // 0 X
            // ---
            // K X

            if let Some(rem) = rem {
                *rem = u64::from(n.low);
            }
            0
        };
    }

    let mut sr;
    // NOTE IMO it should be possible to leave these "uninitialized" (just declare them here)
    // because these variables get initialized below, but if I do that the compiler complains about
    // them being used before being initialized.
    let mut q = words { low: 0, high: 0 };
    let mut r = words { low: 0, high: 0 };

    // n.high != 0
    if d.low == 0 {
        if d.high == 0 {
            // K X
            // ---
            // 0 0

            // NOTE copied verbatim from compiler-rt, but does division by zero even make sense?
            if let Some(rem) = rem {
                *rem = u64::from(n.high % d.low);
            }
            return u64::from(n.high / d.low);
        }

        // d.high != 0
        if n.low == 0 {
            // K 0
            // ---
            // K 0

            if let Some(rem) = rem {
                *rem = words {
                        low: 0,
                        high: n.high % d.high,
                    }
                    .u64();
            }
            return u64::from(n.high / d.high);
        }

        // n.low != 0
        // K K
        // ---
        // K 0

        if d.high.is_power_of_two() {
            if let Some(rem) = rem {
                *rem = words {
                        low: n.low,
                        high: n.high & (d.high - 1),
                    }
                    .u64()
            }

            return u64::from(n.high >> d.high.trailing_zeros());
        }

        sr = d.high.leading_zeros().wrapping_sub(n.high.leading_zeros());

        // D > N
        if sr > u32_bits - 2 {
            if let Some(rem) = rem {
                *rem = n.u64();
            }
            return 0;
        }

        sr = sr + 1;

        // 1 <= sr <= u32_bits - 1
        // *q.all() = n.u64() << (u64_bits - sr);
        q.low = 0;
        q.high = n.low << (u32_bits - sr);
        // *r.all() = n.u64() >> sr
        r.high = n.high >> sr;
        r.low = (n.high << (u32_bits - sr)) | (n.low >> sr);
    } else
    // d.low != 0
    {
        if d.high == 0 {
            // K X
            // ---
            // 0 K
            if d.low.is_power_of_two() {
                if let Some(rem) = rem {
                    *rem = u64::from(n.low & (d.low - 1));
                }

                return if d.low == 1 {
                    n.u64()
                } else {
                    let sr = d.low.trailing_zeros();
                    words {
                            low: (n.high << (u32_bits - sr)) | (n.low >> sr),
                            high: n.high >> sr,
                        }
                        .u64()
                };
            }

            sr = 1 + u32_bits + d.low.leading_zeros() - n.high.leading_zeros();

            // 2 <= sr <= u64_bits - 1
            // *q.all() = n.u64() << (u64_bits - sr)
            // *r.all() = n.u64() >> sr;
            if sr == u32_bits {
                q.low = 0;
                q.high = n.low;
                r.high = 0;
                r.low = n.high;
            } else if sr < u32_bits
            // 2 <= sr <= u32_bits - 1
            {
                q.low = 0;
                q.high = n.low << (u32_bits - sr);
                r.high = n.high >> sr;
                r.low = (n.high << (u32_bits - sr)) | (n.low >> sr);
            } else
            // u32_bits + 1 <= sr <= u64_bits - 1
            {
                q.low = n.low << (u64_bits - sr);
                q.high = (n.high << (u64_bits - sr)) | (n.low >> (sr - u32_bits));
                r.high = 0;
                r.low = n.high >> (sr - u32_bits);
            }

        } else
        // d.high != 0
        {
            // K X
            // ---
            // K K

            sr = d.high.leading_zeros().wrapping_sub(n.high.leading_zeros());

            // D > N
            if sr > u32_bits - 1 {
                if let Some(rem) = rem {
                    *rem = a;
                    return 0;
                }
            }

            sr += 1;

            // 1 <= sr <= u32_bits
            // *q.all() = n.u64() << (u64_bits - sr)
            q.low = 0;
            if sr == u32_bits {
                q.high = n.low;
                r.high = 0;
                r.low = n.high;
            } else {
                q.high = n.low << (u32_bits - sr);
                r.high = n.high >> sr;
                r.low = (n.high << (u32_bits - sr)) | (n.low >> sr);
            }
        }
    }

    // Not a special case
    // q and r are initialized with
    // *q.all() = n.u64() << (u64_bits - sr)
    // *.r.all() = n.u64() >> sr
    // 1 <= sr <= u64_bits - 1
    let mut carry = 0;

    for _ in 0..sr {
        // r:q = ((r:q) << 1) | carry
        r.high = (r.high << 1) | (r.low >> (u32_bits - 1));
        r.low = (r.low << 1) | (q.high >> (u32_bits - 1));
        q.high = (q.high << 1) | (q.low >> (u32_bits - 1));
        q.low = (q.low << 1) | carry;

        // carry = 0
        // if r.u64() >= d.u64() {
        //     *r.all() -= d.u64();
        //     carry = 1;
        // }

        let s = (d.u64().wrapping_sub(r.u64()).wrapping_sub(1)) as i64 >> (u64_bits - 1);
        carry = (s & 1) as u32;
        *r.all() -= d.u64() & s as u64;
    }

    *q.all() = (q.u64() << 1) | carry as u64;
    if let Some(rem) = rem {
        *rem = r.u64();
    }
    q.u64()
}

#[no_mangle]
pub extern "C" fn __udivmodsi4(a: u32, b: u32, rem: Option<&mut u32>) -> u32 {
    let d = __udivsi3(a, b);
    if let Some(rem) = rem {
        *rem = a - (d*b);
    }
    return d;
}

#[no_mangle]
pub extern "C" fn __udivsi3(n: u32, d: u32) -> u32 {
    let u32_bits = u32::bits() as u32;

    // Special cases
    if d == 0 {
        return 0; // ?!
    }

    if n == 0 {
        return 0;
    }

    let mut sr = d.leading_zeros().wrapping_sub(n.leading_zeros());

    // d > n
    if sr > u32_bits - 1 {
        return 0;
    }

    // d == 1
    if sr == u32_bits - 1 {
        return n;
    }

    sr = sr + 1;

    // 1 <= sr <= u32_bits - 1
    let mut q = n << (u32_bits - sr);
    let mut r = n >> sr;

    let mut carry = 0;
    for _ in 0..sr {
        // r:q = ((r:q) << 1) | carry
        r = (r << 1) | (q >> (u32_bits - 1));
        q = (q << 1) | carry;

        // carry = 0;
        // if r > d {
        //     r -= d;
        //     carry = 1;
        // }

        let s = (d.wrapping_sub(r).wrapping_sub(1)) as i32 >> (u32_bits - 1);
        carry = (s & 1) as u32;
        r -= d & s as u32;
    }

    q = (q << 1) | carry;
    q
}