/***************************************************************************
 *   Copyright (C) 1980-2005 Artur Wiebe                                   *
 *   artur@wiebenet.de                                                     *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "networkplayer.h"
#include "serversocket.h"
#include "clientsocket.h"
//#include "config.h"


// clientside->serverside
#define N_GETRULES	"get_rules"	// data: -
#define N_GETSERVERNAME	"get_servername"// data: -
#define N_GETNAME	"get_name"	// data: own name
#define N_GETPLAY	"get_play"	// data: -
// clientside<->serverside
#define N_RULES		"rules"		// data: rules int
#define N_SERVERNAME	"servername"	// data: servername
#define N_NAME		"name"		// data: player's name
#define N_MOVE		"move"		// data: board string
#define N_MSG		"msg"		// data: actual message
#define N_PLAY		"play"		// data: empty for ok, else deny reason
#define N_NEXTROUND	"nextround"	// data: empty for white, else black

#define SEP		'|'


myNetworkPlayer::myNetworkPlayer(bool white, int rules, bool server,
	const QString& ip, int port)
    : myPlayer(white, rules)
{
    if(server) {
	m_server = new myServerSocket(port);
    } else
	m_server = 0;

    m_client = new myClientSocket(ip, port);

    connect(m_client, SIGNAL(discInd()), this, SIGNAL(stopped()));
    connect(m_client, SIGNAL(dataInd(const QString&)),
	    this, SLOT(slotReceived(const QString&)));
    connect(m_client, SIGNAL(connInd()), this, SLOT(slotJoinOrCreate()));
    connect(m_client, SIGNAL(joc(bool)), this, SLOT(slotReady(bool)));
}


myNetworkPlayer::~myNetworkPlayer()
{
    if(m_server)
	delete m_server;
    if(m_client)
	delete m_client;
}


void myNetworkPlayer::yourTurn(Checkers* g)
{
    game = g;

    if(!m_client->isConnected()) {
	return;
    }
}


void myNetworkPlayer::parseMove(const QString& str)
{
    if(!game->fromString(str))
	qDebug("\n\nmyNetworkPlayer::parseMove: BUG!\n");
}


void myNetworkPlayer::sendMove(const QString& data)
{
    if(!data.isEmpty())
	send(N_MOVE, data);
}


void myNetworkPlayer::slotReceived(const QString& text)
{
    QString kw = text.section(SEP, 0, 0);
    QString data = text.section(SEP, 1);


    // SERVER
    if(kw==N_GETRULES) {
	send(N_RULES, QString::number(opponent()->rules()));

    } else if(kw==N_GETSERVERNAME) {
	send(N_SERVERNAME, site());

    } else if(kw==N_GETNAME) {
	setName(data);
	send(N_NAME, opponent()->name());

    } else if(kw==N_GETPLAY) {
	emit steady(true);

    // CLIENT
    } else if(kw==N_NAME) {
	setName(data);

    } else if(kw==N_RULES) {
	setRules(data.toInt());
	emit ready(true);
	send(N_GETPLAY, "");

    } else if(kw==N_SERVERNAME) {
	setSite(data);

    } else if(kw==N_PLAY) {
	emit steady(data.isEmpty());

    } else if(kw==N_NEXTROUND) {
	setWhite(data.isEmpty());
	opponent()->setWhite(!isWhite());
	emit nextRound();

    // BOTH: CLIENT AND SERVER
    } else if(kw==N_MOVE) {
	parseMove(data);
	emit moveDone(game->toString(false));

    } else if(kw==N_MSG) {
	emit message(data);

    } else {
	qDebug("myNetworkPlayer::slotReceived::Client unknown command(%s).",
		kw.latin1());
    }
}


void myNetworkPlayer::send(const QString& kw, const QString& data)
{
    if(!m_client->sendText(QString("%1%2%3").arg(kw).arg(SEP).arg(data)))
	qDebug("myNetworkPlayer::send: failed.");
}


void myNetworkPlayer::slotJoinOrCreate()
{
    m_client->joinOrCreate(m_server ? CLIENT_CREATE : CLIENT_JOIN);
}


/*aw??????????ßß

    game = g;

    if(m_client->isConnected()) {
	if(m_server)
	    send(CMD_NEXTROUND, game->toString(true));
	else
	    emit readyToPlay();
    }

//emit message(MSG_SYSTEM, tr("Waiting for network player to connect..."));
}
*/


void myNetworkPlayer::sendMessage(const QString& text)
{
    send(N_MSG, text);
}


void myNetworkPlayer::stop()
{
    m_client->disc();
}


void myNetworkPlayer::slotReady(bool really)
{
    if(!isServer() && really) {
      	send(N_GETSERVERNAME, "");
	send(N_GETNAME, opponent()->name());
	send(N_GETRULES, "");
    } else
	emit ready(really);
}


void myNetworkPlayer::acceptPlay(bool accept)
{
    if(accept)
	send(N_PLAY, "");
    else
	send(N_PLAY, "You stink.");	// aw???
}


void myNetworkPlayer::sendNextRound()
{
    if(isServer())
	send(N_NEXTROUND, (!isWhite() ? "black" : "" ));
}