#include "Network.h"
#ifndef WIN32
#    include <iostream>
#    include <netdb.h>
#    include <signal.h>
#endif
#include <Logging.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <Text.h>

// Starte Netzwerk
void Network::Start(int maxClients)
{
#ifdef WIN32
    WSADATA lpwd;
    lpwd.iMaxSockets = maxClients;
    int fehler = WSAStartup(MAKEWORD(2, 0), &lpwd);
    if (fehler != 0)
        Framework::Logging::error()
            << "Could not initialize Win Sock 2.0 WSAStartup: " << fehler;
#else
    signal(SIGPIPE, SIG_IGN);
#endif
    SSL_library_init();
    SSL_load_error_strings();
    OpenSSL_add_ssl_algorithms();
}

void Network::getHostName(char* name, int bufferLen)
{
    gethostname(name, bufferLen);
}

char* Network::getHostAddresse()
{
    char* addresse;
    char name[255] = "";
    getHostName(name, 255);
    PHOSTENT hostinfo;
    hostinfo = gethostbyname(name);
    if (!hostinfo)
    {
        Framework::Logging::error()
            << "The ip address of host '" << name << "' could not be resolved";
        return 0;
    }
    addresse = inet_ntoa(*(struct in_addr*)*hostinfo->h_addr_list);
    return addresse;
}

// Beende Netzwerk
void Network::Exit()
{
#ifdef WIN32
    WSACleanup();
#endif
}

Network::NetworkReader::NetworkReader(Verbindung* v)
{
    verbindung = v;
}

Network::NetworkReader::~NetworkReader() {}

//! Ließt aus der Datei
//! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
//! \param len Wie viele Bytes aus der Resource gelesen werden sollen
void Network::NetworkReader::lese(char* bytes, int len)
{
    verbindung->getNachricht(bytes, len);
}

//! Ließt die nächste zeile der Resource ein
//! \return Die gelesene Zeile als Text mit zeilenumbruch
Framework::Text* Network::NetworkReader::leseZeile()
{
    int maxLength = 2048;
    char* buffer = new char[maxLength];
    char b;
    int index = 0;
    do
    {
        verbindung->getNachricht(&b, 1);
        buffer[index++] = b;
        if (index == maxLength)
        {
            maxLength += 2048;
            char* tmp = new char[maxLength];
            memcpy(tmp, buffer, (__int64)maxLength - 2048);
            delete[] buffer;
            buffer = tmp;
        }
    } while (b != '\n');
    buffer[index] = 0;
    Framework::Text* result = new Framework::Text(buffer);
    delete[] buffer;
    return result;
}

//! Prüft, ob die Resource vollständig gelesen wurde
//!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
bool Network::NetworkReader::istEnde() const
{
    return 0;
}

Network::NetworkWriter::NetworkWriter(Verbindung* v)
{
    verbindung = v;
}

Network::NetworkWriter::~NetworkWriter() {}

//! Schreibt in die Resource
//! \param bytes Ein Array, der die Bytes enthält, welche in die Resource
//! geschrieben werden soll \param len Wie viele Bytes in die Resource
//! geschrieben werden sollen
void Network::NetworkWriter::schreibe(const char* bytes, int len)
{
    verbindung->sende(bytes, len);
}

//! Prüft, ob die Resource vollständig geschrieben wurde
//!  return 1, wenn die Resource vollständig geschrieben wurde. 0, sonst
bool Network::NetworkWriter::istEnde() const
{
    return 0;
}

Network::EncryptedNetworkReader::EncryptedNetworkReader(EncryptedVerbindung* v)
{
    verbindung = v;
}

//! Ließt aus der Datei
//! \param bytes Ein Array, der mit Bytes aus der Resource gefüllt werden soll
//! \param len Wie viele Bytes aus der Resource gelesen werden sollen
void Network::EncryptedNetworkReader::lese(char* bytes, int len)
{
    verbindung->getNachrichtEncrypted(bytes, len);
}

//! Ließt die nächste zeile der Resource ein
//! \return Die gelesene Zeile als Text mit zeilenumbruch
Framework::Text* Network::EncryptedNetworkReader::leseZeile()
{
    int maxLength = 2048;
    char* buffer = new char[maxLength];
    char b;
    int index = 0;
    do
    {
        verbindung->getNachrichtEncrypted(&b, 1);
        buffer[index++] = b;
        if (index == maxLength)
        {
            maxLength += 2048;
            char* tmp = new char[maxLength];
            memcpy(tmp, buffer, (__int64)maxLength - 2048);
            delete[] buffer;
            buffer = tmp;
        }
    } while (b != '\n');
    buffer[index] = 0;
    Framework::Text* result = new Framework::Text(buffer);
    delete[] buffer;
    return result;
}

//! Prüft, ob die Resource vollständig gelesen wurde
//!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
bool Network::EncryptedNetworkReader::istEnde() const
{
    return 0;
}

Network::EncryptedNetworkWriter::EncryptedNetworkWriter(EncryptedVerbindung* v)
{
    verbindung = v;
}

//! Schreibt in die Resource
//! \param bytes Ein Array, der die Bytes enthält, welche in die Resource
//! geschrieben werden soll \param len Wie viele Bytes in die Resource
//! geschrieben werden sollen
void Network::EncryptedNetworkWriter::schreibe(const char* bytes, int len)
{
    verbindung->sendeEncrypted(bytes, len);
}

//! Prüft, ob die Resource vollständig geschrieben wurde
//!  return 1, wenn die Resource vollständig geschrieben wurde. 0, sonst
bool Network::EncryptedNetworkWriter::istEnde() const
{
    return 0;
}