#pragma once
#include <iostream>

class Exception {

private:
    std::string m_error;

public:
    Exception(std::string error)
        :m_error(error)
    {
    }
    const char* getError() {
        return m_error.c_str();
    }
};



template <class T>
class Rational
{
private:
    T numenator;
    T denominator;

public:
    Rational(T num = 0, T denom = 1){
        numenator = num;
        denominator = denom;

        if (denom ==  0) {
            throw Exception("Division by zero exception");
        }

        if (typeid(denom).name() == "float" || "double" || "char") {
            throw Exception("types of float, char and double are not allowed");
        }

        if (denominator <  0) {
            denominator = -denominator;
            numenator = -numenator;
        }

    }

    T getNumenator() const {
        return numenator;
    }

    T getDenominator() const {
        return denominator;
    }

    void setNumenator(T a) {
        numenator = a;
    }

    void setDenominator(T a) {
        denominator = a;
    }

    double getDouble() const {
        return static_cast<double> (numenator) / denominator;
    }


    template <class T>friend std::ostream& operator<< (std::ostream & out, const Rational<T> &rational);
    template <class T>friend std::istream& operator>> (std::istream& in, Rational<T> &rational);
};

template<typename T>
T gcd(T a, T b) {

    while (b) {
        a %= b;
        T z = a;
        a = b;
        b = z;
    }

    if (a < 0) {
        a = -a;
    }

    return a;
}

template<typename T>
T NOK(T a, T b)
{
    return a * b / gcd(a, b);
}

template<typename T>
void FractionReduction(Rational<T>& r) {
    T num = r.getNumenator();
    T denom = r.getDenominator();
    T c = gcd(num, denom);

    num /= c;
    denom /= c;
    r.setNumenator(num);
    r.setDenominator(denom);
}



template <typename T>
std::ostream& operator<< (std::ostream& out, const Rational<T> &rational) {
    out << rational.numenator << "/" << rational.denominator << std::endl;
    return out;
}



template <typename T>
std::istream& operator>> (std::istream& in, Rational<T> &rational) {
    in >> rational.numenator;
    in >> rational.denominator;
    rational = Rational<T>(rational.numenator, rational.denominator);
    return in;
}



template <typename T>
Rational<T>& operator*= (Rational<T>& r1, const  Rational<T> r2) {
    T a = r1.getNumenator() * r2.getNumenator();
    T b = r1.getDenominator() * r2.getDenominator();
    r1.setNumenator(a);
    r1.setDenominator(b);
    FractionReduction(r1);
    return r1;
}

template <typename T>
bool operator== (const Rational<T>& lhs, const Rational<T>& rhs) {
    if (lhs.getDouble() == rhs.getDouble()) {
        return true;
    }

    else {
        return false;
    }
}

template <typename T>
bool operator> (const Rational<T>& lhs, const Rational<T>& rhs) {
    if (lhs.getDouble() > rhs.getDouble()) {
        return true;
    }

    else {
        return false;
    }
}

template <typename T>
Rational<T>& operator- (Rational<T>& r) {
    T a = r.getNumenator() * -1;

    r.setNumenator(a);

    return r;
}


template <typename T>
Rational<T>& operator+(Rational<T>& r1, const Rational<T>& r2) {
    Rational<T> r;
    T denom1 = r1.getDenominator();
    T denom2 = r2.getDenominator();
    T nok = NOK(denom1, denom2);

    denom1 = nok / denom1;
    denom2 = nok / denom2;

    T num = denom1 * r1.getNumenator() + denom2 * r2.getNumenator();
    r.setNumenator(num);
    r.setDenominator(nok);

    FractionReduction(r);

    return r;
}

template <typename T>
Rational<T> operator*(const Rational<T>& r1, const Rational<T>& r2) {
        Rational<T> r;

        int a = r1.getNumenator() * r2.getNumenator();
        int b = r1.getDenominator() * r2.getDenominator();

        r.setNumenator(a);
        r.setDenominator(b);

        FractionReduction(r);

        return r;
}

template<typename T>
Rational<T>& operator+=(Rational<T>& r1, const Rational<T>& r2) {
    T denom1 = r1.getDenominator();
    T denom2 = r2.getDenominator();
    T nok = NOK(denom1, denom2);

    denom1 = nok / denom1;
    denom2 = nok / denom2;

    T num = denom1 * r1.getNumenator() + denom2 * r2.getNumenator();

    r1.setNumenator(num);
    r1.setDenominator(nok);

    FractionReduction(r1);

    return r1;
}