Supreme Calculator

#include <iostream>
#include <cstdlib>
#include <string>
#include <math.h>
#include <sstream>
#include <vector>

using namespace std;

void info()
{
    cout <<"\n======================================================"<< endl;
    cout <<"Wpisz ca\210e dzia\210anie w jednej linii, u\276ywaj\245c informatycznych znak\242w dzia\210a\344\nnp.4*2 lub 45/9"<< endl;
    cout <<"Gdy podajesz u\210amki dziesi\251tne, zamiast przecinka wpisuj kropk\251 np. 2.5"<< endl;
    cout <<"\nDozwolone dzia\210ania:\ndodawanie\nodejmowanie\nmno\276enie\ndzielenie\npot\251gowanie\npierwiastki dowolnego stopnia\nlogarytmy"<< endl;
    cout <<"funkcje trygonometryczne (warto\230\206 k\245ta podaj\nw stopniach, w ulamku dziesietnym a nie w minutach i sekundach)\ndzielenie z reszt\245"<< endl;
    cout <<"\nProgram obs\210uguje tylko pojedy\344cze dzia\210ania."<< endl;
    cout <<"\nDodawanie: + np. 2+2"<< endl;
    cout <<"Odejmowanie: - np. 6-4"<< endl;
    cout <<"Mno\276enie: * np. 6*6"<< endl;
    cout <<"Dzielenie: / np. 45/9"<< endl;
    cout <<"Pot\251gowanie: ^ np. 2^4 (2 do pot\251gi czwartej)"<< endl;
    cout <<"Pierwiastki: rt np. 3rt9 (pierwiastek trzeciego stopnia z 9)"<< endl;
    cout <<"Logarytmy: 2log4 (logarytm z 4 przy podstawie 2)"<< endl;
    cout <<"Funkcje trygonometryczne: sin, cos, tan, ctg, np. sin30 (sinus z 30)"<< endl;
    cout <<"Dzielenie z reszt\245: %, np. 20%9 (20 dzielone z reszt\245 na 9)"<< endl;
    cout <<"\n======================================================\n"<< endl;
}

string podajDzialanie()
{
    string dzialanie;
    do
    {
        cout <<"Podaj dzia\210anie matematyczne."<< endl;
        cout <<"Napisz info, \276eby wy\230wietli\206 pomoc."<< endl;
        cout <<"Napisz clear, \276eby wyczy\230ci\206 okno."<< endl;
        cout <<"Napisz exit, \276eby wyj\230\206 z programu."<< endl;
        getline( cin, dzialanie);
        cin.clear();
        cin.sync();

        if(dzialanie == "info")
        {
            info();
        }

        if(dzialanie == "clear")
        {
            system("cls");
        }
    }while(dzialanie == "info" || dzialanie == "clear");

    return dzialanie;
}

void szukanieZnaku(string dzialanie, string znak, string & operacja, int & isGood, size_t & miejsce, int & isGoodPoz)
{
    int ileZnakow = 0;
    bool znPozGood = false;
    size_t pozycja = dzialanie.find(znak);
    if(pozycja == 0 && (znak != "sin" && znak != "cos" && znak != "tan" && znak != "ctg"))
    {
        znPozGood = true;//bo nie moge zreturnowac tutaj bo by nie zwiekszylo zmiennej ileZnakow
    }
    if(pozycja == dzialanie.size() - 1 && (znak != "sin" && znak != "cos" && znak != "tan" && znak != "ctg"))
    {
        znPozGood = true;
    }
    if(isGoodPoz == 0 && pozycja != string::npos)
    {
        miejsce = pozycja;
        isGoodPoz++;
    }
    if(pozycja != string::npos)
    {
        do
        {
            pozycja = dzialanie.find(znak, pozycja + znak.size());
            if(pozycja != string::npos);
            {
                ileZnakow++;
            }
        }while(pozycja != string::npos);
    }


    if(ileZnakow != 1)
    {
        return;
    }

    if(znPozGood == true)
    {
        return;
    }

    operacja = znak;
    isGood ++;
}

void szukanieZnakuMinus(string dzialanie, string znak, string & operacja, int & isGood, size_t & miejsce, int & isGoodPoz)
{
    vector < unsigned int > minusy;

    int ileZnakow = 0;
    size_t pozycja = dzialanie.find(znak);
    if(isGoodPoz == 0 && pozycja != string::npos)
    {
        isGoodPoz++;
    }
    if(pozycja != string::npos)
    {
        minusy.push_back(pozycja);
        do
        {
            pozycja = dzialanie.find(znak, pozycja + znak.size());
            if(pozycja != string::npos);
            {
                minusy.push_back(pozycja);
                ileZnakow++;
            }
        }while(pozycja != string::npos);
    }

    if(ileZnakow == 0 || ileZnakow > 3)
    {
        return;
    }

    if(dzialanie[dzialanie.size() - 1] == 45)
    {
        return;
    }

    if(minusy[0] == 0 && isGood == 0)
    {
        if(ileZnakow == 1)//naprawiam buga, dziffko!
        {
            return;
        }
        miejsce = minusy[1];
        operacja = znak;
        isGood++;
    }
    if(minusy[0] != 0 && isGood == 0)
    {
        miejsce = minusy[0];
        operacja = znak;
        isGood++;
    }
}

void rozdzielenie(string dzialanie, string element[], size_t pozycja, string operacja)
{
    element[0].clear();
    element[1].clear();//czyszczenie, potrzebne w razie gdy wywali error przy sprawdzaniu czy to liczba, zeby nie bylo pozostalosci z wczesniejszej petli
    element[0].insert(0, dzialanie);
    element[1].insert(0, dzialanie);
    element[0].erase(pozycja);
    element[1].erase(0, element[0].size() + operacja.size());
}

bool sprawdzenieCzyLiczba(string tekst)
{
    int ilekropek = 0;

    for(unsigned int a = 0; a < tekst.size(); a++)
    {
        if(tekst[a] == 45 && a != 0)
        {
            return false;
        }
        if(tekst[a] == 46)
        {
            ilekropek++;
        }
        if(tekst[a] == 46 && a == 0)
        {
            return false;
        }
        if(tekst[a] == 46 && a > 0)
        {
            if(tekst[a - 1] < 48 || tekst[a - 1] > 57)
            {
                return false;
            }
        }
        if((tekst[a] < 48 || tekst[a] > 57) && tekst[a] != 45 && tekst[a] != 46)
        {
            return false;
        }
    }

    if(ilekropek > 1)
    {
        return false;
    }

    return true;
}

float konwersja(string strLiczba)
{
    stringstream ss;
    float liczba;
    ss << strLiczba;
    ss >> liczba;
    return liczba;
}

void trygonometria(float wartoscKata, string operacja)
{
    wartoscKata = wartoscKata * M_PI/180;//zamiana stopni na radiany, bo komputer liczy funkcje trygonometryczne w radianach

    if(operacja == "sin")
    {
        wartoscKata = sin(wartoscKata);
    }
    if(operacja == "cos")
    {
        wartoscKata = cos(wartoscKata);
    }
    if(operacja == "tan")
    {
        wartoscKata = tan(wartoscKata);
    }
    if(operacja == "ctg")
    {
        wartoscKata = 1/tan(wartoscKata);
    }

    cout << "Wynik: " << wartoscKata << endl;
}

void pierwiastkiLiczbUjemnych(float liczba[])
{
    int intliczba[2];
    for(int a = 0; a < 2; a++)
    {
        intliczba[a] = liczba[a];
    }

    if(intliczba[0] % 2 == 0)
    {
        cout <<"Taki pierwiastek nie istnieje."<< endl;
    }
    else
    {
        cout <<"Wynik: " << -(pow(-(liczba[1]), (1 / liczba[0]))) << endl;
    }
}

void dzialania(float liczba[], string operacja)
{
    if(operacja == "+")
    {
        cout << "Wynik: "<< liczba[0] + liczba[1] << endl;
    }
    if(operacja == "-")
    {
        cout << "Wynik: "<< liczba[0] - liczba[1] << endl;
    }
    if(operacja == "*")
    {
        cout << "Wynik: "<< liczba[0] * liczba[1] << endl;
    }
    if(operacja == "/")
    {
        if(liczba[1] == 0)
        {
            cout <<"Pami\251taj cholero, nie dziel przez zero!"<< endl;
        }
        else
        {
            cout <<"Wynik: "<< liczba[0] / liczba[1] << endl;
        }
    }
    if(operacja == "^")
    {
        cout <<"Wynik: " << pow(liczba[0], liczba[1]) << endl;
    }
    if(operacja == "rt")
    {
        if(liczba[0] == 0)
        {
            cout <<"Nie ma pierwiastk\242w zerowego stopnia!"<< endl;
            return;
        }

        if(liczba[1] < 0)
        {
            pierwiastkiLiczbUjemnych(liczba);
            return;
        }

        cout <<"Wynik: " << pow(liczba[1], (1 / liczba[0])) << endl;
    }
    if(operacja == "log")
    {
        cout <<"Wynik: " << log(liczba[1])/log(liczba[0]) << endl;
    }
    if(operacja == "sin")
    {
        trygonometria(liczba[1], operacja);
    }
    if(operacja == "cos")
    {
        trygonometria(liczba[1], operacja);
    }
    if(operacja == "tan")
    {
        trygonometria(liczba[1], operacja);
    }
    if(operacja == "ctg")
    {
        trygonometria(liczba[1], operacja);
    }
    if(operacja == "%")
    {
        if(liczba[1] == 0)
        {
            cout <<"Pami\251taj cholero, nie dziel przez zero!"<< endl;
        }
        else
        {
            int intliczba[2];
            for(int a = 0; a < 2; a++)
            {
                intliczba[a] = liczba[a];
            }
            cout <<"Wynik: " << intliczba[0] / intliczba[1] << " r " << intliczba[0] % intliczba[1] << endl;
        }
    }
}

int main()
{
    do
    {
        bool sprCzyLiczbaGood;
        string operacja;
        string element[2];//to piszemy przed petla do...while zeby wszystko dzialalo
        size_t pozycja;
        string dzialanie;
        do
        {
            do
            {
                operacja = "BRAK";
                dzialanie = podajDzialanie();
                if(dzialanie == "exit")
                {
                    return 0;
                }

                int isGood = 0;
                int isGoodPoz = 0;

                szukanieZnaku(dzialanie, "+", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "*", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "/", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "^", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "rt", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "log", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "sin", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "cos", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "tan", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "ctg", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnaku(dzialanie, "%", operacja, isGood, pozycja, isGoodPoz);
                szukanieZnakuMinus(dzialanie, "-", operacja, isGood, pozycja, isGoodPoz);
                if(isGood != 1)
                {
                    operacja = "BRAK";
                }

                if(operacja == "BRAK")
                {
                    cout <<"ERROR! Nieprawid\210owe dane. Wprowad\253 prawid\210owe.\n"<< endl;
                }
            }while(operacja == "BRAK");

            rozdzielenie(dzialanie, element, pozycja, operacja);

            for(int a = 0; a < 2; a++)
            {
                sprCzyLiczbaGood = sprawdzenieCzyLiczba(element[a]);
                if(sprCzyLiczbaGood == false)
                {
                    cout <<"ERROR! Nieprawid\210owe dane. Wprowad\253 prawid\210owe.\n"<< endl;
                    break;//to break jest po to, ze jak pierwsza liczba jest zla a druga dobra, to zeby potem wartosc true przy drugiej liczbie nie nadpisala tej pierwszej
                }
            }
        }while(sprCzyLiczbaGood == false);

        float liczba[2];

        for(int a = 0; a < 2; a++)
        {
            liczba[a] = konwersja(element[a]);
        }

        dzialania(liczba, operacja);
        cout <<""<<endl;
    }while(0==0);//petla nieskonczona, bitch!

    //TO DO:
    //no i w ogole sprawdzic wszystkie dzialania jakie wyniki daje gdy jedna z liczb jest 0 - sa to logarytmy, obczaic to!
    //cos z 90 jest chujowy i w ogole sprawdzic to

    return 0;
}