#ifndef ARRAY_H
#define ARRAY_H

#include <iostream>

template <typename Integer>
struct Fraction {
  Integer numerator;  // fields -> attributes
  Integer denominator;  // member = attributes | method
};

template <typename Integer>
const Integer& gcd(const Integer& a, const Integer& b) {
  // TODO(any): verify behvaior with a or b negatives
  if (b == 0) {
    return a;
  } else {
    return gcd(b, a % b);
  }
}

template <typename Integer>
void fraction_simplify(Fraction<Integer>* fraction) {
  assert(fraction);
  const Integer& fraction_gcd = gcd(fraction->numerator, fraction->denominator);
  fraction->numerator /= fraction_gcd;
  fraction->denominator /= fraction_gcd;
  if (fraction->denominator < 0) {
    fraction->numerator = -fraction->numerator;
    fraction->denominator = -fraction->denominator;
  }
}

template <typename Integer>
void fraction_init(Fraction<Integer>* fraction, const Integer& numerator = 0,
  const Integer& denominator = 1) {  // default arguments
  assert(fraction);
  fraction->numerator = numerator;
  fraction->denominator = denominator;
  fraction->fraction_simplify();
}

template <typename Integer>
std::ostream& fraction_print(std::ostream& output
  , const Fraction<Integer>& fraction) {
  return output << fraction.numerator << '/' << fraction.denominator;
}

template <typename Integer>
std::ostream& operator<<(std::ostream& output
  , const Fraction<Integer>& fraction) {
  return output << fraction.numerator << '/' << fraction.denominator;
}

template <typename Integer>
std::istream& operator>>(std::istream& input, Fraction<Integer>& fraction) {
  input >> fraction.numerator >> fraction.denominator;
  // fraction_simplify(&fraction);
  fraction.fraction_simplify();
  return input;
}

template <typename Integer>
Fraction<Integer> add(const Fraction<Integer>& fr1
  , const Fraction<Integer>& fr2) {
  Fraction<Integer> result;
  // a/b + c/d = (ad + bc)/(bd)
  result.numerator = fr1.numerator * fr2.denominator
    + fr1.denominator * fr2.numerator;
  result.denominator = fr1.denominator * fr2.denominator;
  // fraction_simplify(&result);
  result.fraction_simplify();
  return result;
}

template <typename Integer>
Fraction<Integer> operator+(const Fraction<Integer>& fr1
  , const Fraction<Integer>& fr2) {
  Fraction<Integer> result;
  // a/b + c/d = (ad + bc)/(bd)
  fraction_init(&result
    , fr1.numerator * fr2.denominator + fr1.denominator * fr2.numerator
    , fr1.denominator * fr2.denominator);
  return result;
}

#endif  // ARRAY_H