//Client
#pragma comment(lib,"ws2_32.lib")
#include <WS2tcpip.h>
#include <iostream>
#include <string>
#include <minwinbase.h>
#include <bitset>
#include <sstream>

std::string zamianaBNS(std::string data)
{
    std::stringstream sstream(data);
    std::string output;
    while (sstream.good())
    {
        std::bitset<8> bits;
        sstream >> bits;
        char c = char(bits.to_ulong());
        output += c;
    }

    return output;
}

int convertBinaryToDecimal(long long n)
{
    int decimalNumber = 0, i = 0, remainder;
    while (n != 0)
    {
        remainder = n % 10;
        n /= 10;
        decimalNumber += remainder*pow(2, i);
        ++i;
    }
    return decimalNumber;
}
// Done ale brzydko V
std::string zamianaBND(std::string x)
{
    int n = stoi(x);
    n = convertBinaryToDecimal(n);
    x = std::to_string(n);
    return x;
}
std::string zamianaDNB(std::string x)
{
    int number = stoi(x);

    std::bitset<16> mySet(number);
    x = mySet.to_string();
    x.erase(0, min(x.find_first_not_of('0'), x.size() - 1));
    return x;
}


std::string zamianaSNB(std::string x) //string
{
    std::string wynik;

    for (std::size_t i = 0; i < x.size(); ++i)
    {
        std::stringstream stream;
        stream << std::bitset<8>(x[i]);
        wynik += stream.str();
    }


    return wynik;
}

std::string encodeBitsToBaits(std::string inputDatagramInBits)
{
    // Dopelnienie zerami, jesli jest taka potrzeba
    while (inputDatagramInBits.size() % 8 != 0)
    {
        inputDatagramInBits.push_back('0');
    }

    // Po uzupelnieniu pakiet jest gotowy do zamiany na bajty

    int datagramLength = inputDatagramInBits.size();

    char bait = 0; // Zmienna bait bedzie zapisywala kolejne osemki bitow
    std::string datagramInBaits; // PakietBajtow to gotowy lancuch bajtow
    int operationIndex = 0; // Zmienna OperationIndeks jest niezbedna przy operacjach na bitach

                            // Zmienna i wskazuje na pierwszy bit z danej osemki bitow
    for (int i = 0; i < datagramLength; i += 8)
    {
        bait = 0;
        operationIndex = 0;

        // Zmienna j iteruje po osmiu kolejnych bitach zaczynajac od bitu i. Jesli bit jest jedynka, to jedynka zostaje przesunieta na odpowiednia pozycje
        for (int j = i; j < i + 8; ++j)
        {
            if (inputDatagramInBits[j] == '1')
            {
                bait = bait | 1 << (7 - operationIndex);
            }
            operationIndex++;
        }

        // Dopisanie gotowego bajtu danych do zmiennej datagramInBaits
        datagramInBaits.push_back(bait);
    }

    // Zwrocenie datagramu, w ktorym kazdy znak zapisuje 8 bitow
    return datagramInBaits;
}

std::string decodeBaitsToBits(std::string inputDatagramInBaits)
{
    std::string datagramInBits;
    std::string bits;
    // Zmienna i iteruje po kolejnych bajtach az do konca lancucha znakow
    for (int i = 0; i < inputDatagramInBaits.size(); i++)
    {
        bits.clear();
        // Zapisanie danego znaku jako liczby i zapisanie tej liczby do bitset
        int charAsInteger = inputDatagramInBaits[i];
        std::bitset<8> mySet(charAsInteger);

        // Zapisanie danego bajtu jako ciagu zer i jedynek o dlugosci 8 do zmiennej bits
        bits = mySet.to_string();

        //Dopisanie osmiu zer i jedynek do wynikowego datagramu
        datagramInBits += bits;
    }

    //Zwrocenie datagramu, w ktorym kazdy znak ma wartosc 1 lub 0
    return datagramInBits;
}

std::string poprawnyOdbior(char input[4096])
{
    std::string temp;
    std::string odpowiedz;
    std::string rozmiarBin;
    std::string jedynaslusznaodpowiedz;
    int rozmiarDec;
    for (int i = 0; i < 9; i++)
    {
        temp += input[i];
    }

    temp = decodeBaitsToBits(temp);
    for (int i = 5; i < 69; i++)
    {
        rozmiarBin += temp[i];
    }

    rozmiarDec = stoi(zamianaBND(rozmiarBin));

    int rozmiarCalegoPakietuWBajtach = ((68 + rozmiarDec) / 8);

    if (((68 + rozmiarDec) % 8) > 0) rozmiarCalegoPakietuWBajtach += 1;

    for (int i = 0; i <= rozmiarCalegoPakietuWBajtach; i++)
    {
        odpowiedz += input[i];
    }

    jedynaslusznaodpowiedz = decodeBaitsToBits(odpowiedz);

    while (jedynaslusznaodpowiedz.size() > (69 + rozmiarDec))
    {
        jedynaslusznaodpowiedz.pop_back();
    }

    return jedynaslusznaodpowiedz;
}

void prepare(std::string &komunikacja, std::string size, std::string dane)
{
    //komunikacja.erase(komunikacja.begin() + 77, komunikacja.end());
    for (int i = 0; i <64; i++)
    {
        komunikacja[5 + i] = size[i];
    }
    for (int i = 0; i<dane.size(); i++)
    {
        komunikacja.push_back(dane[i]);
    }

    std::string temporary = encodeBitsToBaits(komunikacja);
    komunikacja = temporary;
}

void prepareS(std::string &komunikacja, std::string size, std::string dane)
{
    komunikacja.erase(komunikacja.begin() + 75, komunikacja.end());
    for (int i = 0; i <64; i++)
    {
        komunikacja[5 + i] = size[i];
    }
    for (int i = 0; i<dane.size(); i++)
    {
        komunikacja.push_back(dane[i]);
    }

    std::string temporary = encodeBitsToBaits(komunikacja);
    komunikacja = temporary;
}

void main()
{
    //dane serwera
    std::string ipAddres = "127.0.0.1";
    int port = 8888;
    //Winsock Startup
    WSAData wsaData;
    WORD DllVersion = MAKEWORD(2, 1);
    if (WSAStartup(DllVersion, &wsaData) != 0)
    {
        std::cout << "Nie mozna uruchomic Winsock" << std::endl;
        return;
    }

    // Create socket
    SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock == INVALID_SOCKET)
    {
        std::cout << "Nie mozna stworzyc Wincosk" << std::endl;
        return;
    }

    // Bind the ip address and port to a socket

    sockaddr_in hint;
    hint.sin_family = AF_INET;//IPv4
    hint.sin_port = htons(port);//host to network short - rozwiazuje problemy z big i little indian, port
    inet_pton(AF_INET, ipAddres.c_str(), &hint.sin_addr);

    //connect

    /*int connectionResult = connect(sock, (sockaddr*)&hint, sizeof(hint));
    if (connectionResult == SOCKET_ERROR)
    {
    std::cout << "nie mozna polaczyc" << std::endl;
    closesocket(sock);
    WSACleanup();
    return;
    }*/
    //while loop
    int operacja, liczba1, liczba2;
    char buff[4096];
    std::string Input;
    std::string komunikacja(69, '0');//tym sie komunikujemy, inicjalizacja jako 000 status 00 operacja, ktora jest pomijalna, i rozmiar danych rowniez = 0 oo i jeszcze nr sesji trzeba

    do {
        operacja = 0;
        //Inicjalizacja
        if (komunikacja[0] == '0' && komunikacja[1] == '0' && komunikacja[2] == '0'&& komunikacja[3] == '0' && komunikacja[4] == '0') // jezeli jeszcze nie mamy nr sesji
        {
            std::string temporary;
            temporary = encodeBitsToBaits(komunikacja);
            komunikacja = temporary;

            sendto(sock, komunikacja.c_str(), komunikacja.size(), 0, (struct sockaddr *) &hint, sizeof(hint));
            recv(sock, buff, 4096, 0);

            komunikacja = poprawnyOdbior(buff);
            std::cout << "komunikacja3 : " << komunikacja << std::endl;

            operacja = 666; // zeby mi pentli nie przerwalo lol
        }
        else {

            std::cin >> operacja;// tu wybieramy operacje wg klucza 1 2 3 4 5 6 zgodnie z kolejnoscia na serwerze, 0 zamyka
            if (operacja < 5 && operacja >0)
            {
                std::cin >> liczba1;
                std::cin >> liczba2; // podajemy 2 liczby np do dodania, rowniez jakis tekst by sie przydal chyba
            }
            if (operacja == 5) { std::cin >> liczba1; } // tu tekst o liczbie do silniowania
            if (operacja == 6) { /*tu nic nie musi byc bo sprawdzamy tylko nasza sesje*/ }
            if (operacja == 7)
            {
                do {
                    std::cin >> liczba1;
                } while (liczba1 < 0 || liczba1 >4);

            } // tu wpisujemy liczbe oznaczajaca operacje matematyczna ktorej historie chcemy sprawdzic (kody jak serwer i klient 1 2 3 4)
            else if (operacja >6 || operacja <0) { std::cout << "nie denerwuj mnie ok?"; }

            komunikacja.erase(komunikacja.begin() + 75, komunikacja.end());
            if (operacja > 0 && operacja <7)
            {
                std::string dane_do_wyslania = "";
                if (operacja == 1)
                {
                    komunikacja[0] = '1';
                    komunikacja[1] = '0';
                    komunikacja[2] = '1';
                    komunikacja[3] = '1';
                    komunikacja[4] = '0'; // operacja i flagi
                    komunikacja.push_back('0');
                    komunikacja.push_back('0');
                    dane_do_wyslania = std::to_string(liczba1) + " " + std::to_string(liczba2);

                }

                if (operacja == 2)
                {
                    komunikacja[0] = '1';
                    komunikacja[1] = '0';
                    komunikacja[2] = '1';
                    komunikacja[3] = '1';
                    komunikacja[4] = '0'; // operacja i flagi
                    komunikacja.push_back('0');
                    komunikacja.push_back('1');
                    dane_do_wyslania = std::to_string(liczba1) + " " + std::to_string(liczba2);
                }

                if (operacja == 3)
                {

                    komunikacja[0] = '1';
                    komunikacja[1] = '0';
                    komunikacja[2] = '1';
                    komunikacja[3] = '1';
                    komunikacja[4] = '0'; // operacja i flagi
                    komunikacja.push_back('1');
                    komunikacja.push_back('0');
                    dane_do_wyslania = std::to_string(liczba1) + " " + std::to_string(liczba2);
                }

                if (operacja == 4)
                {
                    komunikacja[0] = '1';
                    komunikacja[1] = '0';
                    komunikacja[2] = '1';
                    komunikacja[3] = '1';
                    komunikacja[4] = '0'; // operacja i flagi
                    komunikacja.push_back('1');
                    komunikacja.push_back('1');
                    dane_do_wyslania = std::to_string(liczba1) + " " + std::to_string(liczba2);

                }

                if (operacja == 5)
                {
                    komunikacja[0] = '0';
                    komunikacja[1] = '1';
                    komunikacja[2] = '1';
                    komunikacja[3] = '1';
                    komunikacja[4] = '0'; // operacja i flagi
                    dane_do_wyslania = std::to_string(liczba1);

                }

                if (operacja == 6)
                {
                    komunikacja[0] = '0';
                    komunikacja[1] = '0';
                    komunikacja[2] = '1';
                    komunikacja[3] = '0';
                    komunikacja[4] = '0'; // operacja i flagi
                }
                if (operacja != 6) {
                    dane_do_wyslania = zamianaSNB(dane_do_wyslania); //dane sa jako binarne juz
                }
                else
                {
                    switch (liczba1)
                    {
                    case 1: dane_do_wyslania = "00"; break;
                    case 2: dane_do_wyslania = "01"; break;
                    case 3: dane_do_wyslania = "10"; break;
                    case 4: dane_do_wyslania = "11"; break;
                    }

                }
                int number;

                if (operacja == 1 || operacja == 2 || operacja == 3 || operacja == 4)
                {
                    number = dane_do_wyslania.size() + 8;  // ====================================== dodalem + 6
                }
                else if (operacja == 5)
                {
                    number = dane_do_wyslania.size() + 6;  // ====================================== dodalem + 6
                }

                std::string rozmiar = std::to_string(number);
                std::bitset<64> mySet(number);
                rozmiar = mySet.to_string(); //rozmiar jako binarny  64

                prepare(komunikacja, rozmiar, dane_do_wyslania);

                int sendResult = sendto(sock, komunikacja.c_str(), komunikacja.size(), 0, (struct sockaddr *) &hint, sizeof(hint));
                if (sendResult != SOCKET_ERROR)
                {
                    ZeroMemory(buff, 4096);
                    int hintSize = sizeof(hint); // &(sizeof(hint))
                    int Recieved = recvfrom(sock, buff, 4096, 0, (struct sockaddr *) &hint, &hintSize);


                    if (Recieved > 0)
                    {
                        komunikacja = poprawnyOdbior(buff);// teraz mamy odpowiedz w komunikacji

                        std::string op, flg, dldan, ses, odp, dzial;
                        op.push_back(komunikacja[0]); op.push_back(komunikacja[1]);
                        flg.push_back(komunikacja[2]); flg.push_back(komunikacja[3]); flg.push_back(komunikacja[4]);
                        for (int i = 5; i < 69; i++) { dldan.push_back(komunikacja[i]); }
                        dldan = zamianaBND(dldan);
                        for (int i = 69; i < 75; i++)
                        {
                            ses.push_back(komunikacja[i]);
                        }
                        ses = zamianaBND(ses);
                        for (int i = 75; i< 77; i++)
                        {
                            dzial.push_back(komunikacja[i]);
                        }
                        dzial = zamianaBND(dzial);
                        for (int i = 77; i< komunikacja.size(); i++)
                        {
                            odp.push_back(komunikacja[i]);
                        }
                        if (operacja < 5) {
                            odp = zamianaBND(odp);
                        }
                        else odp = zamianaBNS(odp);

                        std::cout << std::endl << std::endl << std::endl << op << std::endl << flg << std::endl << dldan << std::endl << ses << std::endl << odp << std::endl;
                        // TO DO CO Z TYM ZROBIC DALEJ MAMY ( PEWNIE JAKIES ODPOWIEDZI W ZALEZNOSCI OD STATUSU ODPOWIEDZI I OPERACJI CZY COS

                        std::cout << "uff";

                    }
                }
            }
        }
    } while (operacja != 0);


    closesocket(sock);
    WSACleanup();
}