#include "..\Global\Variablen.h"
#include <main.h>
#include <MausEreignis.h>
#include <TastaturEreignis.h>
#include <Maus.h>
#include <Punkt.h>
#include "..\Global\Render.h"
#include <Bild.h>
#include <DateiSystem.h>
#include <Globals.h>
#include <Text.h>
#include "..\Global\Initialisierung.h"
#include <Datei.h>
#include <iostream>
#include <vector>
#include <sstream>
#include <InitDatei.h>
#include <TexturList.h>

void fensterVS( void *p, void *f )
{
    PostQuitMessage( 0 );
}

bool fensterME( void *p, void *f, MausEreignis me )
{
    return 1;
}

bool fensterTE( void *p, void *f, TastaturEreignis te )
{
#ifdef _DEBUG
    std::cout.flush();
#endif
    return 1;
}

#ifdef _DEBUG
template<typename TChar, typename TTraits>
class OutputDebugStringBuf : public std::basic_stringbuf<TChar, TTraits>
{
public:
    explicit OutputDebugStringBuf() : _buffer( 256 )
    {
        setg( nullptr, nullptr, nullptr );
        setp( _buffer.data(), _buffer.data(), _buffer.data() + _buffer.size() );
    }

    ~OutputDebugStringBuf()
    {}

    static_assert( std::is_same<TChar, char>::value || std::is_same<TChar, wchar_t>::value, "OutputDebugStringBuf only supports char and wchar_t types" );

    int sync() try
    {
        MessageOutputer<TChar, TTraits>()( pbase(), pptr() );
        setp( _buffer.data(), _buffer.data(), _buffer.data() + _buffer.size() );
        return 0;
    }
    catch( ... )
    {
        return -1;
    }

    int overflow( int c = TTraits::eof() )
    {
        auto syncRet = sync();
        if( c != TTraits::eof() )
        {
            _buffer[ 0 ] = c;
            setp( _buffer.data(), _buffer.data() + 1, _buffer.data() + _buffer.size() );
        }
        return syncRet == -1 ? TTraits::eof() : 0;
    }


private:
    std::vector<TChar>		_buffer;

    template<typename TChar, typename TTraits>
    struct MessageOutputer;

    template<>
    struct MessageOutputer<char, std::char_traits<char>>
    {
        template<typename TIterator>
        void operator()( TIterator begin, TIterator end ) const
        {
            std::string s( begin, end );
            OutputDebugStringA( s.c_str() );
        }
    };

    template<>
    struct MessageOutputer<wchar_t, std::char_traits<wchar_t>>
    {
        template<typename TIterator>
        void operator()( TIterator begin, TIterator end ) const
        {
            std::wstring s( begin, end );
            OutputDebugStringW( s.c_str() );
        }
    };

};
#endif

int KSGStart Framework::Start( Startparam p )
{
#ifdef _DEBUG
    static OutputDebugStringBuf<char, std::char_traits<char>> charDebugOutput;
    std::cout.rdbuf( &charDebugOutput );
#endif
    Network::Start( 50 );

    InitDatei init( "data/optionen.ini" );
    init.laden();
    if( init.wertExistiert( "Log" ) )
        Framework::setLogEnabled( init.zWert( "Log" )->istGleich( "1" ) );
    Framework::logLine( "Anwendung wird gestartet..." );

    Punkt bildschirmGröße = BildschirmGröße();
    bildschirmGröße.x++;
    bildschirmGröße.y++;
    Framework::logLine( ( ( Text( "Ermittelte Bildschirmgroesse: " ) += ( bildschirmGröße.x - 1 ) ) += "x" ) += ( bildschirmGröße.y - 1 ) );

    WNDCLASS wc = F_Normal( p.hinst );
    wc.lpszClassName = "Game Client";

    Framework::logLine( "Grafische Benutzeroberflaeche wird erstellt..." );
    WFenster *fenster = new WFenster();
    fenster->erstellen( WS_POPUP, wc );
    fenster->setPosition( Punkt( 0, 0 ) );
    fenster->setSize( bildschirmGröße );
    fenster->setMausAktion( fensterME );
    fenster->setTastaturAktion( fensterTE );
    fenster->setVSchließAktion( fensterVS );

    Bildschirm *bildschirm = new Bildschirm3D( fenster->getThis() );
    fenster->setBildschirm( bildschirm->getThis() );
    fenster->setAnzeigeModus( 1 );
    fenster->setFokus();
    bildschirm->update();
    bildschirm->render();

    Framework::logLine( "Schrift wird geladen..." );
    LTDSDatei *schriftDatei = new LTDSDatei();
    schriftDatei->setPfad( new Text( "data/schriften/normal.ltds" ) );
    schriftDatei->leseDaten();
    Schrift *schrift = schriftDatei->ladeSchrift();
    schriftDatei = schriftDatei->release();

    Render *render = new Render( schrift->getThis() );
    render->setBildschirm( bildschirm->getThis() );

    Framework::logLine( "Globale Variablen werden initialisiert..." );
    initVariables( schrift, bildschirm );

    Framework::logLine( "Zeichen Thread wird gestartet..." );
    render->start();

    Framework::logLine( "Nachrichtenschleife wird ausgefuehrt..." );
    StartNachrichtenSchleife();

    Framework::logLine( "Zeichen Thread wird beendet..." );
    render->beenden();
    render = render->release();

    bildschirm->removeMember( vorLogin->zFenster() );
    bildschirm->removeMember( nachLogin );

    Framework::logLine( "Speicher wird freigegeben..." );
    releaseVariables();
    schrift = schrift->release();

    Framework::zTexturRegister()->leeren();
    bildschirm = bildschirm->release();
    fenster->setBildschirm( 0 );
    fenster->zerstören();
    fenster = fenster->release();

    Network::Exit();

    DateiPfadErstellen( new Text( "data/tmp/keinabsturz" ) );

    Framework::logLine( "Programm wurde ordnungsgemaess beendet." );

    return 0;
}