// It's Time To Calculate The Calculations With A Calculator !

#include "stdafx.h"

#include <iostream>
#include <fstream>
#include <string>
#include <cmath>
#include <iomanip>
#include <algorithm>

double a{ 0 };
double x;
double y;
char z;

int combine(int first, int second)
{
    if (second == 0)
    {
        return first * 10;
    }
    else
    {
        int times = 1;
        while (times <= second)
            times *= 10;
        return first * times + second;
    }
}

int abs()
{
    a = fabs(x);
    return a;
}

int subtract()
{
    a = x - y;
    return a;
}

int add()
{
    a = x + y;
    return a;
}

int divide()
{
    a = x / y;
    return a;
}

int multiply()
{
    a = x * y;
    return a;
}

int power()
{
    a = pow(x, y);
    return a;
}

unsigned long long factorial(double f) //Loops Until int f = 1
{                                   //Limit Is 64 Factorial
    if (f < 0)
    {
        std::cout << '\n' << "Cannot Accept A Negative Or Decimal Factorial" << '\n' << std::endl;
        return a = 0;
    }
    if (f > 20) //Only Accurate Up To 20 Factorial
    {
        std::cout << '\n' << "Factorial Too Big!" << '\n' << std::endl;
        return a = 0;
    }
    if (f == 1) return a = 1;
    if (f == 0) return a = 1;
    else return a = f * factorial(f - 1);

}

int main()
{
    std::cout << "Press / To Exit." << '\n'
        << "Symbols: (+)  (-)  (/)  (* (or) x)  (!)  (^)  (% (Remainder))  (s (User-Choosen Root))  (f (Absolute Value))"
        << '\n' << "Use 'a' To Symbolize Previous Value." << '\n' << "----------------------------------------" << '\n';

Equation:
    std::cout << "Type In Equation: ";

    std::string i;
    std::string o;
    std::string u;
    std::string b;
    char e;
    char q;
    char f;

    std::cin >> e;

    if (e == '/') // Entering "/" Stops Program
    {
        std::cout << '\n';
        return 0;
    }

    if (e == 'f')
    {
        char check;
        std::cin >> check;
        if (check == 'a')
        {
            x = a;
        }
        else
        {
            std::cin.putback(check);
            std::cin >> x;
        }
        if (std::cin.fail())
        {
            std::cout << '\n' << "Not A Number" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Buffer
            goto Equation;
        }
        else
        {
            abs();
            std::cout << "The Absolute Value Of " << x << " Is " << a << '\n' << '\n';
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n');
            goto Equation;
        }
    }

    i = std::cin.peek();

    if (i.find('\n') != std::string::npos)
    {
        if (e == 'a')
        {
            std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << a << '\n' << std::endl;
        }
        else
        {
            int j;
            std::cin.putback(e);
            std::cin >> j;
            if (std::cin.fail())
            {
                std::cout << '\n' << "Not A Number" << '\n' << std::endl;
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Buffer
                goto Equation;
            }
            std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << j << '\n' << std::endl;
            a = j;
        }
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n');
        goto Equation;
    }

    std::cin >> q;

    if ((((e == 'a') || (e == 'A')) && ((q != 'a') && (q != 'A') && (q != '+') && (q != '!') && (q != '-') && (q != '^') && (q != '*') && (q != 'x') && (q != '/') && (q != '%'))))
    {
        std::cout << '\n' << "Not A Valid Operation." << '\n' << std::endl;
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n');
        goto Equation;
    }
    if (((e == 'a') && (q == 'a')) || ((e == 'A') && (q == 'A') || ((e == 'a') && (q == 'A')) || ((e == 'A') && (q == 'a'))))
    {
        std::cout << '\n' << "Not Valid!" << '\n' << std::endl;
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
        goto Equation;
    }
    if (((e == 'a') || (e == 'A')) && ((q == 'a')|| (q == 'A')))
    {
        std::cout << '\n' << "Not A Valid Operation." << '\n' << std::endl;
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n');
        goto Equation;
    }
    if ((e != 's') && (e != 'S') && (q == 'a' || q == 'A'))
    {
        std::cout << '\n' << "Not A Valid Operation." << '\n' << std::endl;
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n');
        goto Equation;
    }
    if (q == '!') { goto Ifs; }
    if (e == 's') { goto Ifs; }
    if (e == 'S') { goto Ifs; }

    i = std::cin.peek();

    if (((q != 'a') && (q != 'A') && (q != '+') && (q != '!') && (q != '-') && (q != '^') && (q != '*') && (q != 'x') && (q != '/') && (q != '%')))
    {
        if (i.find('\n') != std::string::npos)
        {
            int pow = static_cast<double>(e - '0');
            if (std::cin.fail())
            {
                std::cout << '\n' << "Not A Number" << '\n' << std::endl;
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Buffer
                goto Equation;
            }
            int cat = static_cast<double>(q - '0');
            if (std::cin.fail())
            {
                std::cout << '\n' << "Not A Number" << '\n' << std::endl;
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Buffer
                goto Equation;
            }
            else
            {
                if (e == '-')
                {
                    int kop;
                    std::cin.putback(q);
                    std::cin >> kop;
                    if (std::cin.fail())
                    {
                        std::cout << '\n' << "Not A Number" << '\n' << std::endl;
                        std::cin.clear();
                        std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Buffer
                        goto Equation;
                    }
                    if (static_cast<double>(q - '0') == 0)
                    {
                        std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << static_cast<double>(q - '0') << '\n' << std::endl;
                    }
                    else
                    {
                        std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << "-" << static_cast<double>(q - '0') << '\n' << std::endl;
                    }

                    a = -static_cast<double>(q - '0');

                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<int>::max(), '\n');
                    goto Equation;

                }
                if (e == '+')
                {
                    int kop;
                    std::cin.putback(q);
                    std::cin >> kop;
                    if (std::cin.fail())
                    {
                        std::cout << '\n' << "Not A Number" << '\n' << std::endl;
                        std::cin.clear();
                        std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Buffer
                        goto Equation;
                    }
                    std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << static_cast<double>(q - '0') << '\n' << std::endl;

                    a = static_cast<double>(q - '0');

                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<int>::max(), '\n');
                    goto Equation;

                }
                int kop;
                std::cin.putback(e);
                std::cin >> kop;
                if (std::cin.fail())
                {
                    std::cout << '\n' << "Not A Number" << '\n' << std::endl;
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Buffer
                    goto Equation;
                }
                std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << static_cast<double>(e - '0')
                    << static_cast<double>(q - '0') << '\n' << std::endl;

                a = combine(static_cast<double>(e - '0'), static_cast<double>(q - '0'));

                std::cin.clear();
                std::cin.ignore(std::numeric_limits<int>::max(), '\n');
                goto Equation;
            }
        }
    }

    i = std::cin.peek();
    if (((e == 'a') || (e == 'A')) && ((q == 'a') || (q == '+') || (q == '!') || (q == '-') || (q == '^') || (q == '*') || (q == 'x') || (q == '/') || (q == '%')) && (i.find('\n') != std::string::npos))
    {
        std::cout << '\n' << "Not A Number" << '\n' << std::endl;
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
        goto Equation;
    }

    std::cin >> f;

Ifs:


    if (e == 'a') // Input "a" Will Give You You're Previous Answer To Work With
    {
        x = a;

        if (f == 'a') // Input "a" Will Give You You're Previous Answer To Work With
        {
            y = a;

            std::cin.putback(q);
            std::cin >> z;

            goto Operation; // Since Already Got "x", "z", and "y" value

        }
        if (f == 'A') // Input "A" Will Give You You're Previous Answer To Work With
        {
            y = a;

            std::cin.putback(q);
            std::cin >> z;

            goto Operation;
        }
        std::cin.putback(f);
        std::cin.putback(q);
        std::cin.putback(e);
        std::cin.ignore(10, 'a');
        goto Op; // Since We Already Got Our "x" Value
    }
    if (e == 'A') // Input "a" Will Give You You're Previous Answer To Work With
    {
        x = a;

        if (f == 'a') // Input "a" Will Give You You're Previous Answer To Work With
        {
            y = a;

            std::cin.putback(q);
            std::cin >> z;

            goto Operation; // Since Already Got "x", "z", and "y" value

        }
        if (f == 'A') // Input "A" Will Give You You're Previous Answer To Work With
        {
            y = a;

            std::cin.putback(q);
            std::cin >> z;

            goto Operation;
        }
        std::cin.putback(f);
        std::cin.putback(q);
        std::cin.putback(e);
        std::cin.ignore(10, 'A');
        goto Op; // Since We Already Got Our "x" Value
    }
    if (e == 's')
    {
        if (q == 'a') { goto Wow; }
        if (q == 'A') { goto Wow; }
        if (q == '-')
        {
            std::cout << '\n' << "Can't Have A Negative Root!" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }

        z = 's';

        std::cin.putback(q);
        std::cin.putback(e);
        std::cin.ignore(10, 's');
        std::cin >> x;
        if (std::cin.fail())
        {
            std::cout << '\n' << "Not A Number" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }
        std::cout << "Calculate " << x << " To The Root Of: ";
        char test;
        std::cin >> test;
        if (test == 'a' || test == 'A')
        {
            y = a;
        }
        else
        {
            std::cin.putback(test);
            std::cin >> y;
        }

        if (std::cin.fail())
        {
            std::cout << '\n' << "Not A Number" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }
        goto Operation;
    }
    if (e == 'S')
    {
        if (q == 'a') { goto Wow; }
        if (q == 'A') { goto Wow; }
        if (q == '-')
        {
            std::cout << '\n' << "Can't Have A Negative Root!" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }

        z = 's';

        std::cin.putback(f);
        std::cin.putback(q);
        std::cin.putback(e);
        std::cin.ignore(10, 'S');
        std::cin >> x;
        if (std::cin.fail())
        {
            std::cout << '\n' << "Not A Number" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }
        goto Operation;
    }
    if (f == 'a') // Input "a" Will Give You You're Previous Answer To Work With
    {
        if ((q != 'a') && (q != 'A') && (q != '+') && (q != '!') && (q != '-') && (q != '^') && (q != '*') && (q != 'x') && (q != '/') && (q != '%'))
        {
            std::cout << '\n' << "Not Valid!" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }

        y = a;

        std::cin.putback(q);
        std::cin.putback(e);
        std::cin >> x;
        std::cin >> z;
        goto Operation;

    }
    if (f == 'A') // Input "A" Will Give You You're Previous Answer To Work With
    {
        if ((q != 'a') && (q != 'A') && (q != '+') && (q != '!') && (q != '-') && (q != '^') && (q != '*') && (q != 'x') && (q != '/') && (q != '%'))
        {
            std::cout << '\n' << "Not Valid!" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }

        y = a;

        std::cin.putback(q);
        std::cin.putback(e);
        std::cin >> x;
        std::cin >> z;
        goto Operation;
    }
    if (e == '<')
    {
        Wow:
        z = 's';
        x = a;
        std::cout << "Calculate " << x << " To The Root Of: ";
        char test;
        std::cin >> test;
        if (test == 'a' || test == 'A')
        {
            y = a;
        }
        else
        {
            std::cin.putback(test);
            std::cin >> y;
        }

        if (std::cin.fail())
        {
            std::cout << '\n' << "Not A Number" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }

        goto Operation;
    }

        std::cin.putback(f);
        std::cin.putback(q);
        std::cin.putback(e);


    std::cin >> x;

    i = std::cin.peek();

    if (i.find('\n') != std::string::npos)
    {

        std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << x << '\n' << std::endl;

        a = x;

        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n');
        goto Equation;
    }

    if (std::cin.fail())
    {
        std::cout << '\n' << "Not A Number" << '\n' << std::endl;
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
        goto Equation;
    }

    Op:
    std::cin >> z;
    if (z == 'a' || z == 'A')
    {
        std::cout << '\n' << "Not A Valid Operation." << '\n' << std::endl;
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n');
        goto Equation;
    }
    if (z == '!') // To Skip Getting A "y" Value For Factorials
    {
        goto Operation;
    }
    if (z == 's')
    {
        goto Operation;
    }

    u = std::cin.peek();

    if (u.find(' ') != std::string::npos)
    {
        std::cin.ignore(std::numeric_limits<int>::max(), ' ');
    }

    o = std::cin.peek();

    if ((o.find('a') != std::string::npos) || (o.find('A') != std::string::npos))
     {
         y = a;
         goto Operation;
     }

    std::cin >> y;

    if (std::cin.fail())
    {
        std::cout << '\n' << "Not A Number" << '\n' << std::endl;
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
        goto Equation;
    }


Operation:
    switch (z)
    {
    case '-':
        subtract();
        std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << a << std::endl;
        break;
    case '+':
        add();
        std::cout << '\n' << "The Sum Is: " << std::setprecision(7) << a << std::endl;
        break;
    case '/':
        if (y == 0)
        {
            std::cout << '\n' << "Not Possible" << std::endl;
            break;
        }
        divide();
        std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << a << std::endl;
        break;
    case '*':
        multiply();
        std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << a << std::endl;
        break;
    case 'x':
        multiply();
        std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << a << std::endl;
        break;
    case '^':
        power();
        std::cout << '\n' << "The Answer Is: " << std::setprecision(7) << a << std::endl;
        break;
    case '%':
        if (y == 0)
        {
            std::cout << '\n' << "Can't Divide By Zero !" << std::endl;
            break;
        }
        if ((x < y) && (x > 0))
        {
            std::cout << '\n' << "Not Applicable" << std::endl;
            break;
        }
        else
        {   // Won't Work If Not Placed Here. Can't Perform % With Anything But Integers.
            int b = x;
            int c = y;
            a = b % c;
            std::cout << '\n' << "The Remainder is: " << a << std::endl;
            break;
        }
        break;
    case '!':
    {
        factorial(x);
        if (a == 0)
        {
            break;
        }
        std::cout << '\n' << "The Factorial Is: " << a << std::endl;
        break;
    }
    case 's':
    {
        if (x < 0)
        {
            std::cout << '\n' << "Can't Have A Negative Root!" << std::endl;
            break;
        }
        if (y < 0)
        {
            std::cout << '\n' << "Only Input A Positive Number!" << '\n' << std::endl;
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<int>::max(), '\n'); // Used When Code Returns To Equation To Clear Cin Errors/Clear Cin Values
            goto Equation;
        }
        a = pow(x, (1.0 / y));
        if (y == 2)
        {
            std::cout << '\n' << "The SquareRoot Of " << x << " Is: " << a << std::endl;
            break;
        }
        if (y == 3)
        {
            std::cout << '\n' << "The CubeRoot Of " << x << " Is: " << a << std::endl;
            break;
        }
        std::cout << '\n' << "The " << y << " Root Of " << x << " Is: " << a << std::endl;
        break;
    }
    default:
        std::cout << '\n' << "Unknown Operation: '" << z << "'" << '\n' << '\n';
    }

    std::cin.clear();
    std::cin.ignore(std::numeric_limits<int>::max(), '\n');

    std::cout << '\n';

    goto Equation;

    return 0;
}