package fractions;

import java.lang.ArithmeticException;

public class Fraction {
    private final int numerator;
    private final int denominator;

    public Fraction (int n, int d) throws ArithmeticException {
        if (d == 0) throw new ArithmeticException();

        if (n == 0) {
            numerator = 0;
            denominator = 1;

            return;
        }

        if (d < 0) {
            d *= -1;
            n *= -1;
        }

        int gcd = gcd (n, d);

        if (gcd != 0) {
            d = d / gcd;
            n = n / gcd;
        }

        numerator = n;
        denominator = d;
    }

    public static int gcd (int p, int q) {
        if (q == 0) return p;

        return gcd (q, p % q);
    }

    public int getNumerator () {
        return numerator;
    }

    public int getDenominator () {
        return denominator;
    }

    public boolean equals (Object obj) {
        if (!(obj instanceof Fraction)) return false;

        return (((Fraction) obj).getNumerator() == this.getNumerator() && ((Fraction) obj).getDenominator() == this.getDenominator());
    }

    public Fraction add (Fraction f) throws ArithmeticException {
        if (f == null) throw new NullPointerException ();

        int normalisedThisN, normalisedThisD, normalisedFN, normalisedFD;

        // normalise the two denominators, unless they're the same
        if (this.getDenominator() != f.getDenominator()) {
            // how many more times can this.d go into max_int?
            int d_times = (int) (Integer.MAX_VALUE / this.getDenominator());

            // are we going to multiply by more than that?
            if (d_times < f.getDenominator()) throw new ArithmeticException ("Unable to normalise 1");

            // how many times can this.n go into max_int?
            int n_times = (int) (Integer.MAX_VALUE / this.getNumerator());
            if (n_times < f.getDenominator()) throw new ArithmeticException ("Unable to normalise 2");

            // how many times can f.d go into max_int?
            int fd_times = (int) (Integer.MAX_VALUE / f.getDenominator());
            if (fd_times < this.getDenominator()) throw new ArithmeticException ("Unable to normalise 3");

            // how many times can f.n go into max_int?
            int fn_times = (int) (Integer.MAX_VALUE / f.getDenominator());
            if (fn_times < this.getDenominator()) throw new ArithmeticException ("Unable to normalise 4");

            normalisedThisN = this.getNumerator()*f.getDenominator();
            normalisedThisD = this.getDenominator()*f.getDenominator();

            normalisedFN = f.getNumerator()*this.getDenominator();
            normalisedFD = f.getDenominator()*this.getDenominator();
        } else {
            normalisedThisN = this.getNumerator();
            normalisedThisD = this.getDenominator();
            normalisedFN = f.getNumerator();
            normalisedFD = f.getDenominator();
        }

        // add them up.
        Fraction addedFraction;

        // will we be adding, or subtracting?
        if (normalisedThisN > 0) {
            // what's the most we can add to the n of this?
            int highest_n = Integer.MAX_VALUE - normalisedThisN;

            if (highest_n < normalisedFN) throw new ArithmeticException ("Numerator too big to be stored");
        } else {
            int lowest_n = Integer.MIN_VALUE + normalisedThisN;

            if (lowest_n > normalisedFN) throw new ArithmeticException ("Numerator too small to be stored");
        }

        // highest we can add to this.d?
        int highest_d = Integer.MAX_VALUE - normalisedThisD;

        if (highest_d < normalisedFD) throw new ArithmeticException ("Too big to store when added");

        addedFraction = new Fraction (normalisedFN + normalisedThisN, normalisedFD);

        return addedFraction;
    }
}