//! Hardcoded values for parking rewards

//use lazy_static::lazy_static;
use crate::FixedU128;
use core::ops::Range;

pub const UNIT: u128 = 1_000_000_000_000_000_000;

pub const BORDER_00: u128 = UNIT;
pub const BORDER_01: u128 = 50_000 * UNIT;
pub const BORDER_02: u128 = 100_000 * UNIT;
pub const BORDER_03: u128 = 150_000 * UNIT;
pub const BORDER_04: u128 = 200_000 * UNIT;
pub const BORDER_05: u128 = 250_000 * UNIT;
pub const BORDER_06: u128 = 300_000 * UNIT;
pub const BORDER_07: u128 = 400_000 * UNIT;
pub const BORDER_08: u128 = 500_000 * UNIT;
pub const BORDER_09: u128 = 600_000 * UNIT;
pub const BORDER_10: u128 = 700_000 * UNIT;
pub const BORDER_11: u128 = 800_000 * UNIT;
pub const BORDER_12: u128 = 900_000 * UNIT;
pub const BORDER_13: u128 = 1_000_000 * UNIT;

pub const RANGE_00: Range<u128> = BORDER_00..BORDER_01;
pub const RANGE_01: Range<u128> = BORDER_01..BORDER_02;
pub const RANGE_02: Range<u128> = BORDER_02..BORDER_03;
pub const RANGE_03: Range<u128> = BORDER_03..BORDER_04;
pub const RANGE_04: Range<u128> = BORDER_04..BORDER_05;
pub const RANGE_05: Range<u128> = BORDER_05..BORDER_06;
pub const RANGE_06: Range<u128> = BORDER_06..BORDER_07;
pub const RANGE_07: Range<u128> = BORDER_07..BORDER_08;
pub const RANGE_08: Range<u128> = BORDER_08..BORDER_09;
pub const RANGE_09: Range<u128> = BORDER_09..BORDER_10;
pub const RANGE_10: Range<u128> = BORDER_10..BORDER_11;
pub const RANGE_11: Range<u128> = BORDER_11..BORDER_12;
pub const RANGE_12: Range<u128> = BORDER_12..BORDER_13;

const RAT_00: u128 = 2682121877864762880;
const RAT_01: u128 = 2598393832873524736;
const RAT_02: u128 = 2514306399607147008;
const RAT_03: u128 = 2429856448999734272;
const RAT_04: u128 = 2345040810807885824;
const RAT_05: u128 = 2259856272882609920;
const RAT_06: u128 = 2174299580426808320;
const RAT_07: u128 = 2002056494917470208;
const RAT_08: u128 = 1828284633643040256;
const RAT_09: u128 = 1652956343169531648;
const RAT_10: u128 = 1476043210382638080;
const RAT_11: u128 = 1297516034356460800;
const RAT_12: u128 = 1117344796908170624;

// This was statically computed once; numerical errors are noticable, but are dwarfed by
// transaction commissions anyway
const PRP_00_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_00, 1000 * UNIT);
const PRP_01_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_01, 1000 * UNIT);
const PRP_02_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_02, 1000 * UNIT);
const PRP_03_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_03, 1000 * UNIT);
const PRP_04_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_04, 1000 * UNIT);
const PRP_05_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_05, 1000 * UNIT);
const PRP_06_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_06, 1000 * UNIT);
const PRP_07_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_07, 1000 * UNIT);
const PRP_08_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_08, 1000 * UNIT);
const PRP_09_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_09, 1000 * UNIT);
const PRP_10_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_10, 1000 * UNIT);
const PRP_11_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_11, 1000 * UNIT);
const PRP_12_WEEKLY: FixedU128 = FixedU128::from_rational(RAT_12, 1000 * UNIT);

/// Weekly PRP, not in %, but as fraction.
pub fn weekly_parking_reward_percentage(tokens_in_pool: u128) -> FixedU128 {
    match tokens_in_pool {
        a if RANGE_00.contains(&a) => PRP_00_WEEKLY,
        a if RANGE_01.contains(&a) => PRP_01_WEEKLY,
        a if RANGE_02.contains(&a) => PRP_02_WEEKLY,
        a if RANGE_03.contains(&a) => PRP_03_WEEKLY,
        a if RANGE_04.contains(&a) => PRP_04_WEEKLY,
        a if RANGE_05.contains(&a) => PRP_05_WEEKLY,
        a if RANGE_06.contains(&a) => PRP_06_WEEKLY,
        a if RANGE_07.contains(&a) => PRP_07_WEEKLY,
        a if RANGE_08.contains(&a) => PRP_08_WEEKLY,
        a if RANGE_09.contains(&a) => PRP_09_WEEKLY,
        a if RANGE_10.contains(&a) => PRP_10_WEEKLY,
        a if RANGE_11.contains(&a) => PRP_11_WEEKLY,
        a if RANGE_12.contains(&a) => PRP_12_WEEKLY,
        _ => 0.into(), //unreachable!("Unexpected token amount currently in parking. Code assumes parked tokens amount ranges 1..1_000_000"),
    }
}

#[cfg(test)]
#[cfg(feature = "std")]
mod tests {
    use super::*;

    const PRP_00: f64 = 15.0 / 100.;
    const PRP_01: f64 = 14.5 / 100.;
    const PRP_02: f64 = 14.0 / 100.;
    const PRP_03: f64 = 13.5 / 100.;
    const PRP_04: f64 = 13.0 / 100.;
    const PRP_05: f64 = 12.5 / 100.;
    const PRP_06: f64 = 12.0 / 100.;
    const PRP_07: f64 = 11.0 / 100.;
    const PRP_08: f64 = 10.0 / 100.;
    const PRP_09: f64 = 9.0 / 100.;
    const PRP_10: f64 = 8.0 / 100.;
    const PRP_11: f64 = 7.0 / 100.;
    const PRP_12: f64 = 6.0 / 100.;

    /// Inverse number of weeks in a year
    const PRP_POWER_YEARLY_TO_WEEKLY: f64 = 7.0 / 365.25;

    macro_rules! check_number {
        ($prp:tt, $rat:tt) => {
            assert_eq!(
                ((($prp + 1.).powf(PRP_POWER_YEARLY_TO_WEEKLY) - 1.)
                    * (1000 as f64)
                    * (UNIT as f64))
                    .round() as u128,
                $rat
            )
        };
    }

    #[test]
    fn numbers_correct() {
        check_number!(PRP_00, RAT_00);
        check_number!(PRP_01, RAT_01);
        check_number!(PRP_02, RAT_02);
        check_number!(PRP_03, RAT_03);
        check_number!(PRP_04, RAT_04);
        check_number!(PRP_05, RAT_05);
        check_number!(PRP_06, RAT_06);
        check_number!(PRP_07, RAT_07);
        check_number!(PRP_08, RAT_08);
        check_number!(PRP_09, RAT_09);
        check_number!(PRP_10, RAT_10);
        check_number!(PRP_11, RAT_11);
        check_number!(PRP_12, RAT_12);
    }
}