#![deny(overflowing_literals, const_err)]

type Num = i32;

const LOW: Num = 1;
const HIGH: Num = 1_000_000;

#[derive(Debug, PartialEq, Eq)]
enum Argument {
    First,
    Second,
}

#[derive(Debug, PartialEq, Eq)]
enum SolveError {
    OutOfBound(Argument),
    IncorrectRelation,
}

fn solve(a: Num, b: Num) -> Result<Num, SolveError> {
    const _ENSURE_NO_UNDERFLOW: Num = 2 * LOW - HIGH;

    let check_arg = |arg, val| {
        if val < LOW || val >= HIGH {
            return Err(SolveError::OutOfBound(arg));
        }
        Ok(())
    };

    check_arg(Argument::First, a)?;
    check_arg(Argument::Second, b)?;

    if a > b {
        return Err(SolveError::IncorrectRelation);
    }

    Ok(2 * a - b)
}

fn median(a: Num, b: Num, c: Num) -> Num {
    let mut triple = [a, b, c];
    triple.sort();
    triple[1]
}

fn avg(a: Num, b: Num, c: Num) -> Num {
    (a + b + c) / 3
}

extern crate rand;

#[test]
fn rand_tests() {
    use rand::distributions::{Distribution, Uniform};

    let range = Uniform::from(LOW..HIGH);
    let mut rng = rand::thread_rng();

    for _ in 0..80_000_000 {
        let (a, b) = (range.sample(&mut rng), range.sample(&mut rng));
        let (a, b) = if a < b { (a, b) } else { (b, a) };

        let c = solve(a, b).unwrap();
        let (mid, avg) = (median(a, b, c), avg(a, b, c));
        assert_eq!(mid, avg,
        "\nArgs: {}, {}\nAnswer: {}\nMedian: {}\nAverage: {}\n",
        a, b, c, mid, avg);
    }
}