using System;
using static System.Console;


////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: zad1
//
// summary:	.Zadanie 1 z listy 7. Zawiera zdefiniowaną strukturę Fraction oraz klasę Solution
// prezentującom działanie struktury.
////////////////////////////////////////////////////////////////////////////////////////////////////

namespace zad1
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>  Struktura Fraction. Udostępnia typowe działania na ułamkach. </summary>
    ///
    /// <remarks>   Ayane, 2017-11-24. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    struct Fraction
    {

        /// <summary>  Licznik ułamka. </summary>
        int licznik;

        /// <summary> Mianownik ułamka. </summary>
        int mianownik;

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Niejawna konwersja zmieniająca podaną liczbę całkowitą na ułamek w postaci (liczba/1) </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="x"> Liczba całkowita. </param>
        ///
        /// <returns> Ułamek z podanej liczby całkowitej w postaci (liczba/1) - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static implicit operator Fraction(int x)=> new Fraction(x,1);

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Jawna konwersja zmieniająca ułamek na liczbę całkowitą. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f"> Ułamek. </param>
        ///
        /// <returns> Liczba całkowita z podanego ułamka - int.  </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static explicit operator int(Fraction f)=>f.licznik/f.mianownik;

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Konstruktor ułamka. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="l">  Licznik ułamka. </param>
        /// <param name="m"> Mianownik ułamka. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public Fraction(int l, int m)
        {
            if ((l < 0 && m < 0) || (l > 0 && m < 0))
            {
                l *= -1;
                m *= -1;
            }
            licznik = l;
            mianownik = m;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Funkcja zwraca skrócony ułamek. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <returns> Ułamek. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public Fraction simplifyFraction()
        {
            Fraction f;
            if (licznik > 0)
            {
                int l = licznik;
                int m = mianownik;
                int nwd = findNWD(l, m);
                if (l % nwd == 0)
                {
                    int newLicznik = l / nwd;
                    int newMianownik = m / nwd;
                    f = new Fraction(newLicznik, newMianownik);
                }
                else
                {
                    f = new Fraction(licznik, mianownik);
                }
            }
            else if(licznik < 0)
            {
                int l = Math.Abs(licznik);
                int m = mianownik;
                int nwd = findNWD(l, m);
                if (l % nwd == 0)
                {
                    int newLicznik = (l / nwd)*-1;
                    int newMianownik = m / nwd;
                    f = new Fraction(newLicznik, newMianownik);
                }
                else
                {
                    f = new Fraction(licznik, mianownik);
                }
            }
            else
            {
                f = new Fraction(licznik, mianownik);
            }
            return f;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Przeciążony operator dodawania (+) dla dwóch ułamków. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Suma ułamków - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator+(Fraction f1, Fraction f2)
        {
            int newLicznik = f1.licznik*f2.mianownik + f2.licznik*f1.mianownik;
            int newMianownik = f1.mianownik*f2.mianownik;
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Przeciążony operator dodawania (+) dla ułamka oraz liczby całkowitej. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Ułamek. </param>
        /// <param name="n"> Liczba całkowita. </param>
        ///
        /// <returns> Suma - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator+(Fraction f1, int n)
        {
            Fraction f = n;
            return f + f1;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Przeciążony operator odejmowania (-) dla dwóch ułamków. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Różnica ułamków - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator-(Fraction f1, Fraction f2)
        {
            int newLicznik = f1.licznik * f2.mianownik - f2.licznik * f1.mianownik;
            int newMianownik = f1.mianownik * f2.mianownik;
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Przeciążony operator odejmowania (-) dla ułamka oraz liczby całkowitej. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Ułamek. </param>
        /// <param name="n"> Liczba całkowita. </param>
        ///
        /// <returns> Różnica - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator-(Fraction f1, int n)
        {
            Fraction f = n;
            return f1 - f;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Przeciążony operator mnożenia (*) dla dwóch ułamków. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Iloczyn ułamków - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator*(Fraction f1, Fraction f2)
        {
            int newLicznik = f1.licznik * f2.licznik;
            int newMianownik = f1.mianownik * f2.mianownik;
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Przeciążony operator mnożenia (*) dla ułamka oraz liczby całkowitej. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Ułamek. </param>
        /// <param name="n"> Liczba całkowita. </param>
        ///
        /// <returns> Iloczyn - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator*(Fraction f1, int n)
        {
            int newLicznik = f1.licznik * n;
            int newMianownik = f1.mianownik;
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Przeciążony operator dzielenia (/) dla dwóch ułamków. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek - dzielna. </param>
        /// <param name="f2"> Drugi ułamek - dzielnik. </param>
        ///
        /// <returns> Iloraz ułamków - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator/(Fraction f1, Fraction f2)
        {
            int newLicznik = f1.licznik * f2.mianownik;
            int newMianownik = f1.mianownik * f2.licznik;
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Przeciążony operator dzielenia (/) dla ułamka oraz liczby całkowitej. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Ułamek - dzielna. </param>
        /// <param name="n"> Liczba całkowita - dzielnik. </param>
        ///
        /// <returns> Iloraz - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator/(Fraction f1, int n)
        {
            int newLicznik = f1.licznik;
            int newMianownik = f1.mianownik * n;
            return new Fraction(newLicznik, newMianownik);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Operator podnoszący ułamek do podanej potęgi. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f">  Ułamek. </param>
        /// <param name="pow"> Potęga w postaci liczby całkowitej. </param>
        ///
        /// <returns> Ułamek podniesiony do potęgi - Fraction. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Fraction operator^(Fraction f, int pow)
        {
            if (pow > 0)
            {
                int l = f.licznik;
                int m = f.mianownik;
                f.licznik = (int)Math.Pow(l,pow);
                f.mianownik = (int)Math.Pow(m, pow);
            }
            else if( pow < 0)
            {
                pow *= -1;
                int l = f.licznik;
                int m = f.mianownik;
                f.licznik = (int)Math.Pow(m, pow);
                f.mianownik = (int)Math.Pow(l, pow);
            }
            else
            {
                f.licznik = 1;
                f.mianownik = 1;
            }
            return f;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Opreator porównania 'większy niż' (>) dwóch ułamków - F1  > F2. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Wartość bool wynikająca z porównania ułamków - bool. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator>(Fraction f1, Fraction f2) {
            int licznik1 = f1.licznik * f2.mianownik;
            int licznik2 = f2.licznik * f1.mianownik;
            return licznik1 > licznik2;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Opreator porównania 'większy niż' (<) dwóch ułamków - F1  < F2. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Wartość bool wynikająca z porównania ułamków - bool. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator<(Fraction f1, Fraction f2) {
            int licznik1 = f1.licznik * f2.mianownik;
            int licznik2 = f2.licznik * f1.mianownik;
            return licznik1 < licznik2;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Opreator porównania 'większy niż lub równy' (>=) dwóch ułamków - F1 >= F2. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Wartość bool wynikająca z porównania ułamków - bool. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator>=(Fraction f1, Fraction f2) {
            int licznik1 = f1.licznik * f2.mianownik;
            int licznik2 = f2.licznik * f1.mianownik;
            return licznik1 >= licznik2;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Opreator porównania 'większy niż lub równy' (<=) dwóch ułamków - F1 <= F2. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Wartość bool wynikająca z porównania ułamków - bool. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator <=(Fraction f1, Fraction f2) {
            int licznik1 = f1.licznik * f2.mianownik;
            int licznik2 = f2.licznik * f1.mianownik;
            return licznik1 <= licznik2;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>  Operator sprawdzający równość dwóch ułamków - F1 == F2. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Wartość bool wynikająca z porównania ułamków - bool. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator==(Fraction f1, Fraction f2) {
            bool answer = false;
            if (f1.licznik == f2.licznik && f1.mianownik == f2.mianownik)
            {
                answer = true;
            }
            return answer;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>  Operator sprawdzający nierówność dwóch ułamków - F1 != F2. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="f1"> Pierwszy ułamek. </param>
        /// <param name="f2"> Drugi ułamek. </param>
        ///
        /// <returns> Wartość bool wynikająca z porównania ułamków - bool. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator!=(Fraction f1, Fraction f2) {
            bool answer = false;
            if (f1.licznik != f2.licznik || f1.mianownik != f2.mianownik)
            {
                answer = true;
            }
            return answer;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Funkcja szukająca Największy Wspólny Dzielnik dwóch licz całkowitych. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="l"> Liczba całkowita. </param>
        /// <param name="m"> Liczba całkowita. </param>
        ///
        /// <returns> NWD - int. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int findNWD(int l, int m)
        {
            while (l != m)
            {
                if (l > m)
                {
                    l -= m;
                }
                else
                {
                    m -= l;
                }
            }
            return l;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Funkcja tworząca tekst o ułamku.
        /// 1) Jeżeli licznik > mianownika - pokaże ułamek w postaci liczby
        /// całkowitej z ułamkiem właściwym.
        /// 2) W przeciwnym przypadku pokaże go jako ułamek niewłaściwy.
        /// </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <returns> Napis - string. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public string printFraction()
        {
            string fraction;
            if((Math.Abs(licznik) > Math.Abs(mianownik)) || (licznik == 0))
            {
                int stalaPrzed = (int)(licznik / mianownik);
                int l = licznik - mianownik * stalaPrzed;
                if(stalaPrzed < 0 && l < 0)
                {
                    l *= -1;
                }
                fraction = $"{stalaPrzed} ( {l} / {FracMianownik} )";
                if (l%mianownik == 0)
                {
                    fraction = $"{stalaPrzed}";
                }
                if (licznik == 0)
                {
                    fraction = "0";
                }
            }
            else
            {
                if (Math.Abs(licznik) == Math.Abs(mianownik))
                {
                    if (licznik > 0)
                    {
                        fraction = "1";
                    }
                    else
                    {
                        fraction = "-1";
                    }
                }
                else {
                    fraction = $"{FracLicznik} / {FracMianownik}";
                }
            }

            return fraction;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Napis ułamka w postaci niewłaściwej. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <returns> Napis - string. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public string simplyPrint()
        {
            string fraction = $"{FracLicznik} / {FracMianownik}";
            return fraction;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Getter mianownika. </summary>
        ///
        /// <value> Mianownik ułamka. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int FracMianownik => mianownik;

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary> Getter licznika. </summary>
        ///
        /// <value> Licznik ułamka. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int FracLicznik => licznik;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary> Klasa Solution przedstawiająca użytkownikowi działanie struktury Fraction. </summary>
    ///
    /// <remarks>   Ayane, 2017-11-24. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    class Solution
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Metoda w klasie Solution. Główny punkt wejścia dla aplikacji. </summary>
        ///
        /// <remarks>   Ayane, 2017-11-24. </remarks>
        ///
        /// <param name="args"> Tablica ciągów argumentów z wiersza poleceń. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        static void Main(string[] args)
        {
            int l1, l2, m1, m2;
            Fraction f1, f2, f3, f4, f5, f6;
            int n;
            string input;

            WriteLine();
            WriteLine("TWORZENIE PIERWSZEGO UŁAMKA - F1");
            WriteLine("Wpisz licznik:");
            input = ReadLine();
            if(input == "")
            {
                l1 = 1;
            }
            else
            {
                l1 = Int32.Parse(input);
            }
            WriteLine("Wpisz mianownik:");
            input = ReadLine();
            if (input == "")
            {
                m1 = 1;
            }
            else
            {
                m1 = Int32.Parse(input);
            }

            WriteLine("TWORZENIE DRUGIEGO UŁAMKA - F2");
            WriteLine("Wpisz licznik:");
            input = ReadLine();
            if (input == "")
            {
                l2 = 1;
            }
            else
            {
                l2 = Int32.Parse(input);
            }
            WriteLine("Wpisz mianownik:");
            input = ReadLine();
            if (input == "")
            {
                m2 = 1;
            }
            else
            {
                m2 = Int32.Parse(input);
            }

            WriteLine("LICZBA CAŁKOWITA DO TESTÓW");
            WriteLine("Wpisz liczbę całkowitą:");
            input = ReadLine();
            if (input == "")
            {
                n = 1;
            }
            else
            {
                n = Int32.Parse(input);
            }

            Write($"{"Skrócone F1:",30}");
            f1 = new Fraction(l1, m1);
            f6 = f1.simplifyFraction();
            string F1 = f1.simplyPrint();
            WriteLine($"{f6.simplyPrint(),9}");

            Write($"{"Skrócone F2:",30}");
            f2 = new Fraction(l2, m2);
            f6 = f2.simplifyFraction();
            string F2 = f2.simplyPrint();
            WriteLine($"{f6.simplyPrint(),9}");

            WriteLine($"{$"Liczba n = {n}",39}");
            WriteLine();

            WriteLine("PRZYKŁADY DZIAŁANIA OPERATORÓW");
            WriteLine();

            f3 = f1 + f2;
            Write($"{$"{F1} + {F2} = {f3.printFraction()}", 10}");

            f3 = f1 + n;
            WriteLine($"{$"{F1} + {n} = {f3.simplyPrint()}",40}");

            f3 = f1 - f2;
            Write($"{$"{F1} - {F2} = {f3.printFraction()}",10}");

            f3 = f1 - n;
            WriteLine($"{$"{F1} - {n} = {f3.simplyPrint()}",40}");

            f3 = f1 * f2;
            Write($"{$"{F1} * {F2} = {f3.printFraction()}",10}");

            f3 = f1 * n;
            WriteLine($"{$"{F1} * {n} = {f3.simplyPrint()}",40}");

            f3 = f1 / f2;
            Write($"{$"{F1} / {F2} = {f3.printFraction()}",10}");

            f3 = f1 / n;
            WriteLine($"{$"{F1} / {n} = {f3.simplyPrint()}",40}");

            f3 = f1 ^ n;
            Write($"{$"{F1} ^ {n} = {f3.simplyPrint()}",10}");

            f3 = f2 ^ n;
            WriteLine($"{$"{F2} ^ {n} = {f3.simplyPrint()}",40}");

            WriteLine();
            WriteLine("OPERATORY RELACJI");
            f4 = new Fraction(l1,m1);
            string F4 = f4.simplyPrint();
            WriteLine($"F4: {F4}");
            WriteLine();

            Write($"{$"{F1} > {F2} ? {f1 > f2}",10}");
            WriteLine($"{$"{F2} < {F1} ? {f2 < f1}",40}");
            Write($"{$"{F1} >= {F2} ? {f1 >= f2}",10}");
            WriteLine($"{$"{F1} <= {F4} ? {f1 <= 42}",40}");
            Write($"{$"{F1} == {F2} ? {f1 == f2}",10}");
            WriteLine($"{$"{F1} == {F4} ? {f1 == f4}",40}");
            Write($"{$"{F1} != {F2} ? {f1 != f2}",10}");
            WriteLine($"{$"{F1} != {F4} ? {f1 != f4}",40}");

            WriteLine();
            WriteLine("INNE PRZYŁADY");

            f5 = n;
            WriteLine($"Ułamek z liczby {n} => {f5.simplyPrint()}");
            int i = (int)f1;
            WriteLine($"Liczba z ułamka {F1} => {i}");
            i = (int)f2;
            WriteLine($"Liczba z ułamka {F2} => {i}");
            WriteLine();
            WriteLine("KONIEC");
        }
    }
}