//server
#pragma comment(lib, "ws2_32.lib")
#include <WinSock2.h>
#include <iostream>
#include <WS2tcpip.h>
#include <fstream>
#include <vector>
#include <string>
#include <process.h> //biblioteka do watkow

using namespace std;

int IDInt = 0; //zmienna okreslajca ID klienta

//zamiana z dziesiętnego na binarny//
vector<bool> DecBin(int number, int size) {
    vector<bool> tab(size);  //
    int i = size - 1;
    while (number) {
        tab[i--] = number % 2;
        number /= 2;
    }
    return tab;
}

//zamiana z binarnego na dziesietny//
int BinDec(vector<bool> tab, int size) {
    int d = 0;
    for (int i = 0;i < size;i++) {
        int z = tab[i] * pow(2, size - i - 1);
        d += z;
    }
    return d;
}

//zamiana char na int//
char CharInt(int number) {
    char chx = static_cast<char>(number);
    return chx;
}

//zamiana int na char//
int IntChar(char c) {
    int n = static_cast<int>(c);
    return n;
}

//konwetownie vec bool na int//
vector<int> ToBin(vector<bool> buffor) {

    vector<int> bufInt;
    int w = buffor.size() / 8;
    for (int i = 0; i < w; i++) {
        int n = i * 8;
        vector<bool> pom(8);

        for (int j = 0; j < 8;j++) {
            pom[j] = buffor[n + j];

        }
        int zm = BinDec(pom, 8);//zmiana na int

        bufInt.push_back(zm);
    }

    return bufInt;
}

//konwertowanie bool na char//
vector<char> BinToChar(vector<bool> buffer) {
    vector<char> bufChar;
    vector<int> bufInt = ToBin(buffer); //zwraca wektor int
    int size = bufInt.size();
    char zm;
    for (int i = 0; i < size;i++) {
        zm = IntChar(bufInt[i]);
        bufChar.push_back(zm);
    }
    return bufChar;
}

//konwersja z char na int
vector<int> CharToInt(vector<char> buffer) {
    vector<int> bufInt;
    int size = buffer.size();
    int zm;
    for (int i = 0; i< size;i++) {
        zm = CharInt(buffer[i]);
        bufInt.push_back(zm);
    }
    return bufInt;
}

//konwersja z int na bool
vector<bool> IntToBin(vector<int> buffer) {
    vector<bool> bufBin;
    vector<bool>pom;
    int size = buffer.size();
    for (int i = 0; i < size;i++) {
        int n = i * 8;
        int zm = buffer[i];
        pom = DecBin(zm, 8);
        for (int j = 0; j < 8;j++) {
            bufBin.push_back(pom[j]);
        }
    }
    return bufBin;
}

//konwersja z char na bit
vector<bool> CharToBin(vector<char> buffer) {
    vector<int> bufInt = CharToInt(buffer); // z char na inty
    vector<bool> bufBit = IntToBin(bufInt); // z int na bool
    return bufBit;
}

//funkcje dzialan
int Sub(int a, int b, int c)
{
    int result;
    result = a - b - c;
    return result;
}

int Div(int a, int b, int c)
{
    int result;
    result = a / b / c;
    return result;
}

int whichMax(int a, int b, int c)
{
    if (a > b) {
        if (a > c) {
            return a;
        }
        else return c;
    }
    else if (b > c) {
        return b;
    }
    else return c;
}

int whichMin(int a, int b, int c)
{
    if (a < b) {
        if (a < c) {
            return a;
        }
        else return c;
    }
    else if (b < c) {
        return b;
    }
    else return c;
}

//funkcja obslugujaca pojedynczego klienta
unsigned _stdcall ClientSN(void * data)
{
    SOCKET Connection = (SOCKET)data; //konwersja z void*, ktory byl przekonertowany z socket
    int ClientN;
    if (Connection == 0) { //sprawdzamy czy cos poszlo nie tak
        cout << "Blad akceptacji polaczenia.";
    }
    else {
        ClientN = IDInt;

        cout << endl << "Klient " << ClientN << " podlaczony." << endl;

        //tworzenie buffora
        vector<bool> HeaderBin(176);
        //domyslne wypełniane bufora zerami//
        for (int i = 0; i < 176;i++) {
            HeaderBin[i] = 0;
        }

        //ustawienie statusu 0 = POWSTAIE HEADERA
        vector<bool> status(4);
        for (int i = 0; i < 4; i++) {
            status[i] = 0;
        }

        //Nadawanie ID Klienta//
        vector<bool> ID = DecBin(IDInt, 6);

        IDInt++;

        //ustawienie statusu 1 = WYSŁANIE HEADERA Z DANYMI
        status[0] = 0;
        status[1] = 0;
        status[2] = 0;
        status[3] = 1;
        //wypelnianie HEADER BIN danymi//
        for (int i = 98; i < 102;i++) {
            HeaderBin[i] = status[i - 98]; //uzupelnianie statusu
        }
        for (int i = 102; i < 108;i++) {
            HeaderBin[i] = ID[i - 102]; //uzupelnianie ID
        }
        //tworzenie buforu char//
        vector<char> HeaderChar = BinToChar(HeaderBin);
        char Header[22];
        for (int i = 0; i < 22; i++) {
            Header[i] = HeaderChar[i];
        }

        //wysyłanie naglowka z danymi do klienta
        send(Connection, Header, 22, NULL);

    }

        //zamykanie polaczenia przez serwer

        cout << "Zamykanie polaczenia z klientem: " << ClientN << endl << endl;
        closesocket(Connection);

}

int main() {
    WSAData WsaDATA; //zmienna potrzebna do otworzenia socketa
    WORD DllVersion = MAKEWORD(2, 1); //zmienna potrzebna do otworzenia socketa
    if (WSAStartup(DllVersion, &WsaDATA) != 0) //warunek na sprawdzenie czy wszystko jest ok
    {
        MessageBoxA(NULL, "Start Winsocka zostal przerwany.", "Blad", MB_OK | MB_ICONERROR); //wyswietla okno dialogowe windowsa, do testow: MessageBoxA(NULL, "tekst", "tekst", MB_OK);
        exit(1); //wyjscie programu w przypadku bledu
    }

    SOCKADDR_IN addr; //struktura odpowiedzialna za adres IP
    int addrlen = sizeof(addr); //przypisujemy wielkosc zmiennej addr do zmiennej dlugos adresu
    inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr.s_addr); //inet_pton odpowiedzialne za konwersje adresu na postac binarna
    addr.sin_port = htons(1111); //port adresu
    addr.sin_family = AF_INET; //af_inet zawsze

    SOCKET sListen = socket(AF_INET, SOCK_STREAM, NULL); //nasluchujemy
    bind(sListen, (SOCKADDR*)&addr, sizeof(addr)); //przypisujemy adres do socketa
    listen(sListen, SOMAXCONN); //nasluchujemy - maksymalna ilosc klientow, nie robimy n bo problemem jest petla, zeby zakonczyc przyjmowanie klientow ctrl+c
    cout << "Serwer wlaczony. Oczekuje na polaczenia.  \nAby zamknac, wyslij kombinacje klawiszy CTRL+C." << endl << endl;
    SOCKET Connection; //nowe polaczenie (to na ktore oczekujemy musi sie polaczyc)

    while (Connection = accept(sListen, (SOCKADDR*)&addr, &addrlen)) {
        // Create a new thread for the accepted client (also pass the accepted client socket).
        unsigned threadID; //ID watku
        HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, &ClientSN, (void*)Connection, 0, &threadID); //funkcja ktora tworzy watek, pierwsze dwa parametry nie obchodza nas, ClientSN to funkcja zajmujaca sie danym klientem, Connection to socket z konwersją na void bo tak trzeba
    }


    return 0;
}