#include<iostream>
#include "stdafx.h"
#include "Symbol.h"
using namespace std;


/**********************/
/** DEFINICJE TABLIC **/
/**********************/
Symbol TablicaDodawania[5][5] = { { e,a,b,c,d },
{ a,d,e,b,c },
{ b,e,c,d,a },
{ c,b,d,a,e },
{ d,c,a,e,b } };

Symbol TablicaMnozen[5][5] = { { e,e,e,e,e },
{ e,a,b,c,d },
{ e,b,a,d,c },
{ e,c,d,b,a },
{ e,d,c,a,b } };
/***************/
/** DODAWANIE **/
/***************/
Symbol Dodaj(Symbol y, Symbol x) //Funkcja typu symbol obsługująca dodawanie symboli
{
    return TablicaDodawania[y][x];
}
Symbol operator + (Symbol y, Symbol x) //przeciazenie operator dodawania
{
    return TablicaDodawania[y][x];
}
/**************/
/** MNOZENIE **/
/**************/
Symbol Mnoz(Symbol y, Symbol x) //Funkcja typu symbol obsługująca mnozenie symboli
{
    return TablicaMnozen[y][x];
}
Symbol operator * (Symbol y, Symbol x) //przeciazenie operator mnozenia
{
    return TablicaMnozen[y][x];
}
/*****************/
/** ODEJMOWANIE **/
/*****************/
Symbol Odejmij(Symbol y, Symbol x) //Funkcja typu symbol obsługująca odejmowanie symboli
{
    x = Przeciwny(x);
    return TablicaDodawania[y][x];
}

Symbol operator - (Symbol y, Symbol x) //przeciazenie operator odejmowania
{
    x = Przeciwny(x);
    return TablicaDodawania[y][x];
}

/***************/
/** DZIELENIE **/
/***************/
Symbol Dziel(Symbol y, Symbol x) //Funkcja typu symbol obsługująca dzielenie symboli
{
    if (x != e) // drugi argument musi byc rozny od 0
    {
        x = Przeciwny(x);
        return TablicaMnozen[y][x];
    }
    else
    {
        cerr << "Nie dzielimy przez 0" << endl;
        return e;
    }
}

Symbol operator / (Symbol y, Symbol x) //przeciazenie operator dzielenia
{
    if (x != e) // drugi argument musibyc rozny od 0
    {
        x = Przeciwny(x);
        return TablicaMnozen[y][x];
    }
    else
        cerr << "Nie dzielimy przez 0" << endl;
    return e;
}

/*****************/
/** POTEGOWANIE **/
/*****************/
Symbol Poteguj(Symbol y, int n) //Funkcja typu symbol obsługująca potegowanie symboli
{
    Symbol wynik = y;
    if (n <= 0)
    {
        cerr << "Bledna wartosc potegi" << endl;
        return e;
    }
    else
    {
        for (int i = 1; i<n; i++)
        {
            wynik = Mnoz(y, wynik);
        }
    }
    return wynik;
}

Symbol operator ^ (Symbol y, int n) //przeciazenie operator potegowania
{
    return Poteguj(y, n);
}

/********************************/
/** ZAMIANA NA PRZECIWY SYMBOL **/
/********************************/
Symbol Przeciwny(Symbol y)  // algorytm zamieniania znaku na przeciwny ( to działa tak wysylamy Znak do funkcji i szukamy drugiego znaku dla ktorego ich suma rowna sie 0, i zwracamy drugi znak )
{
    Symbol tymczasowy; //tworzy tymczasowa zmienna do porownywania wartosci
    for (int i = 0; i<5; i++) //wykonaj sie 5 razy
    {
        tymczasowy = Dodaj(y, TabSymboli[i]); //Jezeli Suma znaku wprowadzonego i ktoregokolwiek z tablicy bedzie rowna E=0 to znaczy ze ten znak jest znakiem przeciwnym
        if (tymczasowy == e) // e = 0 bo jest pierwsze w tablity typu wyliczeniowego enum Symbol { e, a, b, c, d, }; domyslnie pierwszy argument ma wartosc 0 kolejny 1 itp..
            return TabSymboli[i]; //zwraca symbol przeciwny
    }
    return e;
}

/********************************************************/
/**  Definicje przeciazen operatorow Wyjscia i Wejscia **/ // ten kawalek kodu sluzy do obslugi wpisywania i wyswietlania obiektow typu Symbol
/********************************************************/

ostream & operator << (ostream & Wyjscie , const Symbol & s) // pozwala na operacje Symbol x;  cout << x
{
char znak;
znak = TabCharow[s];
Wyjscie << znak;
return Wyjscie;
}

istream & operator >> (istream &Wejscie, Symbol &s)  // pozwala na operacje Symbol x;  cin >> x
{
    char znak;
    Wejscie >> znak;
    switch (znak)
    {
        case 'a':
        {
            s = a;
            break;
        }
        case 'e':
        {
            s = e;
            break;
        }
        case 'b':
        {
            s = b;
            break;
        }
        case 'c':
        {
            s = c;
            break;
        }
        case 'd':
        {
            s = d;
            break;
        }
        default:
        {
        Wejscie.setstate(ios::failbit);
        return Wejscie;
    }
}
return Wejscie;
}