/***************************************************************************
 *   Copyright (C) 2008 by Keith Rusler   *
 *   xeckosx@live.com   *
 *                                                                         *
 *   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 "MSNSocket.h"

namespace MSNP
{
MSNSocket::MSNSocket ( QObject *parent )
		: QTcpSocket ( parent )
{
	m_state = MSNSocket::Unknown;
	m_unmodifiedCommand.clear();
	m_buffer.clear();
	m_blocksize = 0;

	QObject::connect ( this, SIGNAL ( readyRead() ),
					   this, SLOT ( readCommand() ) );
	QObject::connect ( this, SIGNAL ( stateChanged ( QAbstractSocket::SocketState ) ),
					   this, SLOT ( socketStateChanged ( QAbstractSocket::SocketState ) ) );
	QObject::connect ( this, SIGNAL ( error ( QAbstractSocket::SocketError ) ),
					   this, SLOT ( socketError ( QAbstractSocket::SocketError ) ) );
}

MSNSocket::~MSNSocket()
{
}

void
MSNSocket::connect ( const QString& address, const quint16 port )
{
	connectToHost ( address, port );
}

void
MSNSocket::disconnect()
{
	abort();
}

bool
MSNSocket::sendCommand ( QString command )
{
	if ( command.isEmpty() ) {
		return false;
	}

	bool status = false;
	m_unmodifiedCommand = command;

	if ( m_state == MSNSocket::Sending ) {
		m_command.parseCommand ( command, MSNCommand::Send );
		status = ( write ( m_command.toString().toUtf8() ) == m_command.toString().toUtf8().size() );
		qDebug() << "<<< " << m_command.toString();

		m_state = MSNSocket::Receiving;
		emit socketState ( m_state );
	}
	return status;
}

void
MSNSocket::readCommand()
{
	if ( m_state == MSNSocket::Sending ) {
		return;
	}

	if ( m_state == MSNSocket::Receiving ) {
		qint32 available = bytesAvailable();

		m_buffer = readAll();

		if(m_buffer.isEmpty()) {
			qDebug() << "m_buffer is empty.";
		} else if(available) {
			if(m_buffer.size() != available) {
				qDebug() << QString("Reported %1 but only read %2").arg(available).arg(m_buffer.size());
			}
			processData();
		}
	}
}

MSNCommand&
MSNSocket::getLastCommand()
{
	return m_command;
}

MSNSocket::ConnectionState
MSNSocket::getState() const
{
	return m_state;
}

void
MSNSocket::socketStateChanged ( QAbstractSocket::SocketState state )
{
	switch ( state ) {
		case QAbstractSocket::ConnectingState:
			//qDebug() << "[STATE]" << state;
			m_state = MSNSocket::Connecting;
			emit socketState ( m_state );
			break;
		case QAbstractSocket::ConnectedState:
			//qDebug() << "[STATE]" << state;
			m_state = MSNSocket::Connected;
			emit socketState ( m_state );
			m_state = MSNSocket::Sending;
			emit socketState ( m_state );
			sendCommand ( m_unmodifiedCommand );
			break;
		case QAbstractSocket::ClosingState:
			//qDebug() << "[STATE]" << state;
			m_state = MSNSocket::Disconnecting;
			emit socketState ( m_state );
			break;
		case QAbstractSocket::UnconnectedState:
			//qDebug() << "[STATE]" << state;
			m_state = MSNSocket::Disconnected;
			emit socketState ( m_state );
		default:
			//qDebug() << "[STATE]" << state;
			break;
	}
}

void
MSNSocket::socketError ( QAbstractSocket::SocketError error )
{
	qDebug() << error;
}

void
MSNSocket::processData()
{
	if(!finishBuffer()) {
		if(m_buffer.contains("\r\n")) {
			m_buffer.replace("\r\n", "");
			m_command.parseCommand(m_buffer, MSNCommand::Read);
			if(m_command.getError() != "No error") {
				qDebug() << ">>> " << m_command.toString();
				emit errorState(m_command.getErrorNumber(), m_command.getError());
			} else {
				qDebug() << ">>> " << m_command.toString();
				processData();
				m_state = MSNSocket::Sending;
				emit socketState(m_state);
				emit parseCommand(m_command);
			}
			m_state = MSNSocket::Receiving;
			emit socketState(m_state);
		}
	}
}

void
MSNSocket::connected()
{
}

void
MSNSocket::disconnected()
{
}

void
MSNSocket::readIntoBuffer ( qint32 buffer )
{
	if(m_blocksize) {
		return;
	}

	m_blocksize = buffer;
	qDebug() << "m_blocksize: " << m_blocksize;

	finishBuffer();
}

bool
MSNSocket::finishBuffer()
{
	if(!m_blocksize) {
		return false;
	} else if(m_blockBuffer.size() <= m_blocksize) {
		qDebug() << "Waiting for data. Received: " << m_blockBuffer.size() << ". Required: " << m_blocksize << "Left: " <<
				m_blocksize - m_blockBuffer.size();
		m_blockBuffer.append(m_buffer);
		m_buffer.clear();
		qDebug() << m_blockBuffer;
		return true;
	}

	qDebug() << "Hmm: " << m_blockBuffer;

	QByteArray block;

	for(int i = 0; i < m_blocksize; ++i) {
		block.append(m_blockBuffer[i]);
 	}

	m_blocksize = 0;
	emit readBlock(block);
	m_blockBuffer.clear();
	return false;
}

} // MSNP namespace.