/*
# Copyright (c) 2009 - OpenSLX Project, Computer Center University of Freiburg
#
# This program is free software distributed under the GPL version 2.
# See http://openslx.org/COPYING
#
# If you have any feedback please consult http://openslx.org/feedback and
# send your suggestions, praise, or complaints to feedback@openslx.org
#
# General information about OpenSLX can be found at http://openslx.org/
# -----------------------------------------------------------------------------
# src/core/vncConnection.cpp
# -----------------------------------------------------------------------------
*/


#include "vncConnection.h"
#include <iostream>
#include <src/core/pvsConnectionManager.h>
#include <src/core/pvsClient.h>
#include <src/gui/connectionFrame.h>


//***********************************************************************************//
//			VNCConnection                                                  //
//***********************************************************************************//



VNCConnection::VNCConnection(QString newPass)
{
	thread = NULL;
    pwSet = false;
    if (newPass != "")
    {
        password = newPass;
        pwSet = true;
    }
    else
        password = "";
    first  = true;
    view_only = true;
    locked = false;
    myFrame = NULL;
}

VNCConnection::~VNCConnection()
{
	setDead();
}

bool VNCConnection::initClient(VNCConnectInfo* newConInfo)
{
    int argc = newConInfo->getCount();
    char** argv = newConInfo->getArguments();

	if (argc > 0)
	{

		stringHost = QString(argv[0]);

		/*QString cropHost = colonSplitter(stringHost, true);
		QString cropPort = colonSplitter(stringHost, false);*/
		_host = colonSplitter(stringHost, true);
		_port = colonSplitter(stringHost, false);
		/*if (!(cropHost.size()))
			cropHost = stringHost;
		if (!(cropPort.size()))
			_port = 5900;
		password  = newConInfo->getPassword();
		_host     = cropHost;
		thread = new VNCClientThread(_host, 5900, password , 0, 500);*/
        if (!(_host.size()))
        	_host = stringHost;
        if (!(_port.size()))
        	_port = QString("5900");
        thread = new VNCClientThread(_host, string2Int(_port), newConInfo->getPassword(), 0, 500);
        connect(thread, SIGNAL(finished()), this, SIGNAL(finished()));

		return true;
	}

    rfbClientLog("init failed\n");
    emit finished();
    return false;
}

/*
 * disconnect and terminate the current connection and set a new one.
 */
void VNCConnection::reInitClientWithQuality(int quality)
{
	disconnect(thread, SIGNAL(finished()), this, SIGNAL(finished()));
	thread->terminate = true;
	thread = new VNCClientThread(_host, string2Int(_port), password , quality, 500);
	connect(thread, SIGNAL(finished()), this, SIGNAL(finished()));
}

bool VNCConnection::isOK()
{
    return thread != NULL && thread->isRunning();
}

bool VNCConnection::viewOnly()
{
    return view_only;
}

void VNCConnection::setDead()
{
    if (thread != NULL)
    {
    	disconnect(thread, SIGNAL(finished()), this, SIGNAL(finished()));
    	if (thread->isRunning())
    	{
			thread->terminate = true;
			thread->wait(2000);
    	}
		delete thread;
		thread = NULL;
    }
}

void VNCConnection::clear()
{
    setDead();

    if (myFrame)
    {
        myFrame = NULL;
    }
}

void VNCConnection::setFrame(ConnectionFrame* newFrame)
{
    if (newFrame)
    {
        if (myFrame)
        {
            // TODO: Tell it that we left?
        }
        myFrame = newFrame;
        if (thread != NULL) myFrame->setToolTip(thread->getDesktopName());
        myFrame->setRatio(ratio);
        myFrame->setOversized(overSized);
    }
}

ConnectionFrame* VNCConnection::getFrame()
{
    return myFrame;
}

char* VNCConnection::getPassword(rfbClient* myClient)
{
    // better off somewhere else?

    QString tmpPassword;
    QString serverHost(myClient->serverHost);
    QString cropHost = colonSplitter(serverHost, true);
    if (!(cropHost.size()))
        cropHost = serverHost;
    if (PVSClient* selfConnection = PVSConnectionManager::getManager()->getClientFromIp(cropHost)) // no candidate means false call anyway
    {
        tmpPassword = selfConnection->getPassword();
    }
    else
    {
        tmpPassword = "";
        ConsoleLog writeError("Couldn't find a matching connection to retrieve a password from!");
    }
    if (tmpPassword.length() > 8)	// shorten if pw is too long
    {
        std::cout << "VNCConnection::getPassword() given password too long, cutting it down to 8 chars!" << std::endl;
        tmpPassword = tmpPassword.mid(0,8);
    }


    char* pw = new char[9];
    strcpy(pw, tmpPassword.toUtf8().data());
    return pw;
}

QString VNCConnection::getPassword()
{
    return password;
}

bool VNCConnection::getPWSet()
{
    return pwSet;
}

QString VNCConnection::getDesktopName()
{
	if (_desktopName.isNull() && thread != NULL && thread->isRunning()) _desktopName = thread->getDesktopName();
	return _desktopName;
}

VNCClientThread* VNCConnection::getVNCClientThread()
{
	if (thread)
		return thread;
	return NULL;
}



//***********************************************************************************//
//			VNCConnectInfo                                                  //
//***********************************************************************************//



VNCConnectInfo::VNCConnectInfo()
{
    count = 0;
    arguments = NULL;
    password = "";
    passwordSupplied = false;
}

VNCConnectInfo::VNCConnectInfo(int newCount, char** newArgs, QString pass)
{
    if (pass == "")
        setArguments(newCount, newArgs);
    else
        setArguments(newCount, newArgs, pass);
}

VNCConnectInfo::~VNCConnectInfo()
{
    if (arguments)
        delete[] arguments;
}

void VNCConnectInfo::setArguments(int newCount, char** newArgs, QString pass)
{
    count = newCount;
    arguments = newArgs;
    if (pass != "")
    {
        password = pass;
        passwordSupplied = true;
    }
}

int VNCConnectInfo::getCount()
{
    return count;
}

char** VNCConnectInfo::getArguments()
{
    return arguments;
}

QString VNCConnectInfo::getPassword()
{
    return password;
}