/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2012-2016 Symless Ltd.
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file LICENSE that should have accompanied this file.
 * 
 * This package 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, see <http://www.gnu.org/licenses/>.
 */

#include "client/Client.h"

#include "client/ServerProxy.h"
#include "synergy/AppUtil.h"
#include "synergy/Screen.h"
#include "synergy/FileChunk.h"
#include "synergy/DropHelper.h"
#include "synergy/PacketStreamFilter.h"
#include "synergy/ProtocolUtil.h"
#include "synergy/protocol_types.h"
#include "synergy/XSynergy.h"
#include "synergy/StreamChunker.h"
#include "synergy/IPlatformScreen.h"
#include "mt/Thread.h"
#include "net/TCPSocket.h"
#include "net/IDataSocket.h"
#include "net/ISocketFactory.h"
#include "net/SecureSocket.h"
#include "arch/Arch.h"
#include "base/Log.h"
#include "base/IEventQueue.h"
#include "base/TMethodEventJob.h"
#include "base/TMethodJob.h"
#include "common/stdexcept.h"

#include <cstring>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <algorithm>
#include <climits>
#include <iterator>

//
// Client
//

Client::Client(
        IEventQueue* events,
        const String& name, const NetworkAddress& address,
        ISocketFactory* socketFactory,
        synergy::Screen* screen,
        lib::synergy::ClientArgs const& args) :
    m_mock(false),
    m_name(name),
    m_serverAddress(address),
    m_socketFactory(socketFactory),
    m_screen(screen),
    m_stream(NULL),
    m_timer(NULL),
    m_server(NULL),
    m_ready(false),
    m_active(false),
    m_suspended(false),
    m_connectOnResume(false),
    m_events(events),
    m_sendFileThread(nullptr),
    m_writeToDropDirThread(nullptr),
    m_useSecureNetwork(args.m_enableCrypto),
    m_args(args),
    m_enableClipboard(true),
	m_maximumClipboardSize(INT_MAX)
{
    assert(m_socketFactory != NULL);
    assert(m_screen        != NULL);

    // register suspend/resume event handlers
    m_events->adoptHandler(m_events->forIScreen().suspend(),
                            getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleSuspend));
    m_events->adoptHandler(m_events->forIScreen().resume(),
                            getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleResume));

    if (m_args.m_enableDragDrop) {
        m_events->adoptHandler(m_events->forFile().fileChunkSending(),
                                this,
                                new TMethodEventJob<Client>(this,
                                    &Client::handleFileChunkSending));
        m_events->adoptHandler(m_events->forFile().fileRecieveCompleted(),
                                this,
                                new TMethodEventJob<Client>(this,
                                    &Client::handleFileRecieveCompleted));
    }
}

Client::~Client()
{
    if (m_mock) {
        return;
    }

    m_events->removeHandler(m_events->forIScreen().suspend(),
                              getEventTarget());
    m_events->removeHandler(m_events->forIScreen().resume(),
                              getEventTarget());

    cleanupTimer();
    cleanupScreen();
    cleanupConnecting();
    cleanupConnection();
    delete m_socketFactory;
}

void
Client::connect(size_t addressIndex)
{
    if (m_stream != NULL) {
        return;
    }
    if (m_suspended) {
        m_connectOnResume = true;
        return;
    }

    try {
        if (m_args.m_hostMode)
        {
            LOG((CLOG_NOTE "waiting for server conection on %i port", m_serverAddress.getPort()));
        }
        else {
            // resolve the server hostname.  do this every time we connect
            // in case we couldn't resolve the address earlier or the address
            // has changed (which can happen frequently if this is a laptop
            // being shuttled between various networks).  patch by Brent
            // Priddy.
            m_resolvedAddressesCount = m_serverAddress.resolve(addressIndex);

            // m_serverAddress will be null if the hostname address is not reolved
            if (m_serverAddress.getAddress() != nullptr) {
              // to help users troubleshoot, show server host name (issue: 60)
              LOG((CLOG_NOTE "connecting to '%s': %s:%i",
              m_serverAddress.getHostname().c_str(),
              ARCH->addrToString(m_serverAddress.getAddress()).c_str(),
              m_serverAddress.getPort()));
            }
        }

        // create the socket
        IDataSocket* socket = m_socketFactory->create(m_useSecureNetwork, ARCH->getAddrFamily(m_serverAddress.getAddress()));
        // filter socket messages, including a packetizing filter
        m_stream = new PacketStreamFilter(m_events, socket, true);

        // connect
        LOG((CLOG_DEBUG1 "connecting to server"));
        setupConnecting();
        setupTimer();
        socket->connect(m_serverAddress);
    }
    catch (XBase& e) {
        cleanupTimer();
        cleanupConnecting();
        cleanupStream();
        LOG((CLOG_DEBUG1 "connection failed"));
        sendConnectionFailedEvent(e.what());
        return;
    }
}

void
Client::disconnect(const char* msg)
{
    cleanup();

    if (msg) {
        sendConnectionFailedEvent(msg);
    }
    else {
        sendEvent(m_events->forClient().disconnected(), NULL);
    }
}

void
Client::refuseConnection(const char* msg)
{
    cleanup();

    if (msg) {
        auto info = new FailInfo(msg);
        info->m_retry = true;
        Event event(m_events->forClient().connectionRefused(), getEventTarget(), info, Event::kDontFreeData);
        m_events->addEvent(event);
    }
}

void
Client::handshakeComplete()
{
    m_ready = true;
    m_screen->enable();
    sendEvent(m_events->forClient().connected(), NULL);
}

bool
Client::isConnected() const
{
    return (m_server != NULL);
}

bool
Client::isConnecting() const
{
    return (m_timer != NULL);
}

NetworkAddress
Client::getServerAddress() const
{
    return m_serverAddress;
}

void*
Client::getEventTarget() const
{
    return m_screen->getEventTarget();
}

bool
Client::getClipboard(ClipboardID id, IClipboard* clipboard) const
{
    return m_screen->getClipboard(id, clipboard);
}

void
Client::getShape(SInt32& x, SInt32& y, SInt32& w, SInt32& h) const
{
    m_screen->getShape(x, y, w, h);
}

void
Client::getCursorPos(SInt32& x, SInt32& y) const
{
    m_screen->getCursorPos(x, y);
}

void
Client::enter(SInt32 xAbs, SInt32 yAbs, UInt32, KeyModifierMask mask, bool)
{
    m_active = true;
    m_screen->mouseMove(xAbs, yAbs);
    m_screen->enter(mask);

    if (m_sendFileThread) {
        StreamChunker::interruptFile();
        m_sendFileThread.reset(nullptr);
    }
}

bool
Client::leave()
{
    m_active = false;

    m_screen->leave();
    
    if (m_enableClipboard) {
        // send clipboards that we own and that have changed
        for (ClipboardID id = 0; id < kClipboardEnd; ++id) {
            if (m_ownClipboard[id]) {
                sendClipboard(id);
            }
        }
    }

    return true;
}

void
Client::setClipboard(ClipboardID id, const IClipboard* clipboard)
{
     m_screen->setClipboard(id, clipboard);
    m_ownClipboard[id]  = false;
    m_sentClipboard[id] = false;
}

void
Client::grabClipboard(ClipboardID id)
{
    m_screen->grabClipboard(id);
    m_ownClipboard[id]  = false;
    m_sentClipboard[id] = false;
}

void
Client::setClipboardDirty(ClipboardID, bool)
{
    assert(0 && "shouldn't be called");
}

void
Client::keyDown(KeyID id, KeyModifierMask mask, KeyButton button, const String &lang)
{
     m_screen->keyDown(id, mask, button, lang);
}

void
Client::keyRepeat(KeyID id, KeyModifierMask mask,
                SInt32 count, KeyButton button, const String& lang)
{
     m_screen->keyRepeat(id, mask, count, button, lang);
}

void
Client::keyUp(KeyID id, KeyModifierMask mask, KeyButton button)
{
     m_screen->keyUp(id, mask, button);
}

void
Client::mouseDown(ButtonID id)
{
     m_screen->mouseDown(id);
}

void
Client::mouseUp(ButtonID id)
{
     m_screen->mouseUp(id);
}

void
Client::mouseMove(SInt32 x, SInt32 y)
{
    m_screen->mouseMove(x, y);
}

void
Client::mouseRelativeMove(SInt32 dx, SInt32 dy)
{
    m_screen->mouseRelativeMove(dx, dy);
}

void
Client::mouseWheel(SInt32 xDelta, SInt32 yDelta)
{
    m_screen->mouseWheel(xDelta, yDelta);
}

void
Client::screensaver(bool activate)
{
     m_screen->screensaver(activate);
}

void
Client::resetOptions()
{
    m_screen->resetOptions();
}

void
Client::setOptions(const OptionsList& options)
{
    for (OptionsList::const_iterator index = options.begin();
         index != options.end(); ++index) {
        const OptionID id       = *index;
        if (id == kOptionClipboardSharing) {
            index++;
            if (index != options.end()) {
				if (!*index) {
					LOG((CLOG_NOTE "clipboard sharing disabled by server"));
                }
                m_enableClipboard = *index;
            }
        } else if (id == kOptionClipboardSharingSize) {
            index++;
            if (index != options.end()) {
				m_maximumClipboardSize = *index;
            }
        }
    }

    if (m_enableClipboard && !m_maximumClipboardSize) {
        m_enableClipboard = false;
        LOG((CLOG_NOTE "clipboard sharing is disabled because the server "
                       "set the maximum clipboard size to 0"));
    }

    m_screen->setOptions(options);
}

String
Client::getName() const
{
    return m_name;
}

void
Client::sendClipboard(ClipboardID id)
{
    // note -- m_mutex must be locked on entry
    assert(m_screen != NULL);
    assert(m_server != NULL);

    // get clipboard data.  set the clipboard time to the last
    // clipboard time before getting the data from the screen
    // as the screen may detect an unchanged clipboard and
    // avoid copying the data.
    Clipboard clipboard;
    if (clipboard.open(m_timeClipboard[id])) {
        clipboard.close();
    }
    m_screen->getClipboard(id, &clipboard);

    // check time
    if (m_timeClipboard[id] == 0 ||
        clipboard.getTime() != m_timeClipboard[id]) {
        // marshall the data
		String data = clipboard.marshall();
		if (data.size() >= m_maximumClipboardSize * 1024) {
			LOG((CLOG_NOTE "Skipping clipboard transfer because the clipboard"
				" contents exceeds the %i MB size limit set by the server",
				m_maximumClipboardSize / 1024));
			return;
		}

		// save new time
		m_timeClipboard[id] = clipboard.getTime();
        // save and send data if different or not yet sent
        if (!m_sentClipboard[id] || data != m_dataClipboard[id]) {
            m_sentClipboard[id] = true;
            m_dataClipboard[id] = data;
            m_server->onClipboardChanged(id, &clipboard);
        }
    }
}

void
Client::sendEvent(Event::Type type, void* data)
{
    m_events->addEvent(Event(type, getEventTarget(), data));
}

void
Client::sendConnectionFailedEvent(const char* msg)
{
    FailInfo* info = new FailInfo(msg);
    info->m_retry = true;
    Event event(m_events->forClient().connectionFailed(), getEventTarget(), info, Event::kDontFreeData);
    m_events->addEvent(event);
}

void
Client::sendFileChunk(const void* data)
{
    FileChunk* chunk = static_cast<FileChunk*>(const_cast<void*>(data));
    LOG((CLOG_DEBUG1 "send file chunk"));
    assert(m_server != NULL);

    // relay
    m_server->fileChunkSending(chunk->m_chunk[0], &chunk->m_chunk[1], chunk->m_dataSize);
}

void
Client::setupConnecting()
{
    assert(m_stream != NULL);

    if (m_args.m_enableCrypto) {
        m_events->adoptHandler(m_events->forIDataSocket().secureConnected(),
                    m_stream->getEventTarget(),
                        new TMethodEventJob<Client>(this,
                                &Client::handleConnected));
    }
    else {
        m_events->adoptHandler(m_events->forIDataSocket().connected(),
                    m_stream->getEventTarget(),
                        new TMethodEventJob<Client>(this,
                                &Client::handleConnected));
    }

    m_events->adoptHandler(m_events->forIDataSocket().connectionFailed(),
                            m_stream->getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleConnectionFailed));
}

void
Client::setupConnection()
{
    assert(m_stream != NULL);

    m_events->adoptHandler(m_events->forISocket().disconnected(),
                            m_stream->getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleDisconnected));
    m_events->adoptHandler(m_events->forIStream().inputReady(),
                            m_stream->getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleHello));
    m_events->adoptHandler(m_events->forIStream().outputError(),
                            m_stream->getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleOutputError));
    m_events->adoptHandler(m_events->forIStream().inputShutdown(),
                            m_stream->getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleDisconnected));
    m_events->adoptHandler(m_events->forIStream().outputShutdown(),
                            m_stream->getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleDisconnected));

    m_events->adoptHandler(m_events->forISocket().stopRetry(),
                           m_stream->getEventTarget(),
                           new TMethodEventJob<Client>(this, &Client::handleStopRetry));
}

void
Client::setupScreen()
{
    assert(m_server == NULL);

    m_ready  = false;
    m_server = new ServerProxy(this, m_stream, m_events);
    m_events->adoptHandler(m_events->forIScreen().shapeChanged(),
                            getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleShapeChanged));
    m_events->adoptHandler(m_events->forClipboard().clipboardGrabbed(),
                            getEventTarget(),
                            new TMethodEventJob<Client>(this,
                                &Client::handleClipboardGrabbed));
}

void
Client::setupTimer()
{
    assert(m_timer == NULL);

    if (!m_args.m_hostMode) {
        m_timer = m_events->newOneShotTimer(2.0, NULL);
        m_events->adoptHandler(Event::kTimer, m_timer,
                                new TMethodEventJob<Client>(this,
                                    &Client::handleConnectTimeout));
    }
}

void
Client::cleanup()
{
    m_connectOnResume = false;
    cleanupTimer();
    cleanupScreen();
    cleanupConnecting();
    cleanupConnection();
}

void
Client::cleanupConnecting()
{
    if (m_stream != NULL) {
        m_events->removeHandler(m_events->forIDataSocket().connected(),
                            m_stream->getEventTarget());
        m_events->removeHandler(m_events->forIDataSocket().connectionFailed(),
                            m_stream->getEventTarget());
    }
}

void
Client::cleanupConnection()
{
    if (m_stream != NULL) {
        m_events->removeHandler(m_events->forIStream().inputReady(),
                            m_stream->getEventTarget());
        m_events->removeHandler(m_events->forIStream().outputError(),
                            m_stream->getEventTarget());
        m_events->removeHandler(m_events->forIStream().inputShutdown(),
                            m_stream->getEventTarget());
        m_events->removeHandler(m_events->forIStream().outputShutdown(),
                            m_stream->getEventTarget());
        m_events->removeHandler(m_events->forISocket().disconnected(),
                            m_stream->getEventTarget());
        m_events->removeHandler(m_events->forISocket().stopRetry(),
                                m_stream->getEventTarget());
        cleanupStream();
    }
}

void
Client::cleanupScreen()
{
    if (m_server != NULL) {
        if (m_ready) {
            m_screen->disable();
            m_ready = false;
        }
        m_events->removeHandler(m_events->forIScreen().shapeChanged(),
                            getEventTarget());
        m_events->removeHandler(m_events->forClipboard().clipboardGrabbed(),
                            getEventTarget());
        delete m_server;
        m_server = NULL;
    }
}

void
Client::cleanupTimer()
{
    if (m_timer != NULL) {
        m_events->removeHandler(Event::kTimer, m_timer);
        m_events->deleteTimer(m_timer);
        m_timer = NULL;
    }
}

void
Client::cleanupStream()
{
    delete m_stream;
    m_stream = NULL;
}

void
Client::handleConnected(const Event&, void*)
{
    LOG((CLOG_DEBUG1 "connected;  wait for hello"));
    cleanupConnecting();
    setupConnection();

    // reset clipboard state
    for (ClipboardID id = 0; id < kClipboardEnd; ++id) {
        m_ownClipboard[id]  = false;
        m_sentClipboard[id] = false;
        m_timeClipboard[id] = 0;
    }
}

void
Client::handleConnectionFailed(const Event& event, void*)
{
    IDataSocket::ConnectionFailedInfo* info =
        static_cast<IDataSocket::ConnectionFailedInfo*>(event.getData());

    cleanupTimer();
    cleanupConnecting();
    cleanupStream();
    LOG((CLOG_DEBUG1 "connection failed"));
    sendConnectionFailedEvent(info->m_what.c_str());
    delete info;
}

void
Client::handleConnectTimeout(const Event&, void*)
{
    cleanupTimer();
    cleanupConnecting();
    cleanupConnection();
    cleanupStream();
    LOG((CLOG_DEBUG1 "connection timed out"));
    sendConnectionFailedEvent("Timed out");
}

void
Client::handleOutputError(const Event&, void*)
{
    cleanupTimer();
    cleanupScreen();
    cleanupConnection();
    LOG((CLOG_WARN "error sending to server"));
    sendEvent(m_events->forClient().disconnected(), NULL);
}

void
Client::handleDisconnected(const Event&, void*)
{
    cleanupTimer();
    cleanupScreen();
    cleanupConnection();
    LOG((CLOG_DEBUG1 "disconnected"));
    sendEvent(m_events->forClient().disconnected(), NULL);
}

void
Client::handleShapeChanged(const Event&, void*)
{
    LOG((CLOG_DEBUG "resolution changed"));
    m_server->onInfoChanged();
}

void
Client::handleClipboardGrabbed(const Event& event, void*)
{
    if (!m_enableClipboard || (m_maximumClipboardSize == 0)) {
        return;
    }

    const IScreen::ClipboardInfo* info =
        static_cast<const IScreen::ClipboardInfo*>(event.getData());

    // grab ownership
    m_server->onGrabClipboard(info->m_id);

    // we now own the clipboard and it has not been sent to the server
    m_ownClipboard[info->m_id]  = true;
    m_sentClipboard[info->m_id] = false;
    m_timeClipboard[info->m_id] = 0;

    // if we're not the active screen then send the clipboard now,
    // otherwise we'll wait until we leave.
    if (!m_active) {
        sendClipboard(info->m_id);
    }
}

bool
Client::isCompatible(int major, int minor) const
{
    const std::map< int, std::set<int> > compatibleTable {
        {6, {7, 8}}, //1.6 is compatible with 1.7 and 1.8
        {7, {8}} //1.7 is compatible with 1.8
    };

    bool isCompatible = false;

    if (major == kProtocolMajorVersion) {
        auto versions = compatibleTable.find(minor);
        if (versions != compatibleTable.end()) {
            auto compatibleVersions = versions->second;
            isCompatible = compatibleVersions.find(kProtocolMinorVersion) != compatibleVersions.end();
        }
    }

    return isCompatible;
}

void
Client::handleHello(const Event&, void*)
{
    SInt16 major, minor;
    if (!ProtocolUtil::readf(m_stream, kMsgHello, &major, &minor)) {
        sendConnectionFailedEvent("Protocol error from server, check encryption settings");
        cleanupTimer();
        cleanupConnection();
        return;
    }

    // check versions
    LOG((CLOG_DEBUG1 "got hello version %d.%d", major, minor));
    SInt16 helloBackMajor = kProtocolMajorVersion;
    SInt16 helloBackMinor = kProtocolMinorVersion;

    if (isCompatible(major, minor)) {
        //because 1.6 is comptable with 1.7 and 1.8 - downgrading protocol for server
        LOG((CLOG_NOTE "Downgrading protocol version for server"));
        helloBackMinor = minor;
    }
    else if (major < kProtocolMajorVersion ||
        (major == kProtocolMajorVersion && minor < kProtocolMinorVersion)) {
        sendConnectionFailedEvent(XIncompatibleClient(major, minor).what());
        cleanupTimer();
        cleanupConnection();
        return;
    }

    // say hello back
    LOG((CLOG_DEBUG1 "say hello version %d.%d", helloBackMajor, helloBackMinor));
    ProtocolUtil::writef(m_stream, kMsgHelloBack, helloBackMajor, helloBackMinor, &m_name);

    // now connected but waiting to complete handshake
    setupScreen();
    cleanupTimer();

    // make sure we process any remaining messages later.  we won't
    // receive another event for already pending messages so we fake
    // one.
    if (m_stream->isReady()) {
        m_events->addEvent(Event(m_events->forIStream().inputReady(),
                            m_stream->getEventTarget()));
    }
}

void
Client::handleSuspend(const Event&, void*)
{
    if (!m_suspended) {
        LOG((CLOG_INFO "suspend"));
        m_suspended       = true;
        bool wasConnected = isConnected();
        disconnect(NULL);
        m_connectOnResume = wasConnected;
    }
}

void
Client::handleResume(const Event&, void*)
{
    if (m_suspended) {
        LOG((CLOG_INFO "resume"));
        m_suspended = false;
        if (m_connectOnResume) {
            m_connectOnResume = false;
            connect();
        }
    }
}

void
Client::handleFileChunkSending(const Event& event, void*)
{
    sendFileChunk(event.getDataObject());
}

void
Client::handleFileRecieveCompleted(const Event& event, void*)
{
    onFileRecieveCompleted();
}

void
Client::onFileRecieveCompleted()
{
    if (isReceivedFileSizeValid()) {
        auto method = new TMethodJob<Client>(this, &Client::writeToDropDirThread);
        m_writeToDropDirThread.reset(new Thread(method));
    }
}

void
Client::handleStopRetry(const Event&, void*)
{
    m_args.m_restartable = false;
}

void
Client::writeToDropDirThread(void*)
{
    LOG((CLOG_DEBUG "starting write to drop dir thread"));

    while (m_screen->isFakeDraggingStarted()) {
        ARCH->sleep(.1f);
    }
    
    DropHelper::writeToDir(m_screen->getDropTarget(), m_dragFileList,
                    m_receivedFileData);
}

void
Client::dragInfoReceived(UInt32 fileNum, String data)
{
    // TODO: fix duplicate function from CServer
    if (!m_args.m_enableDragDrop) {
        LOG((CLOG_DEBUG "drag drop not enabled, ignoring drag info."));
        return;
    }

    DragInformation::parseDragInfo(m_dragFileList, fileNum, data);
    
    m_screen->startDraggingFiles(m_dragFileList);
}

bool
Client::isReceivedFileSizeValid()
{
    return m_expectedFileSize == m_receivedFileData.size();
}

void
Client::sendFileToServer(const char* filename)
{
    if (m_sendFileThread) {
        StreamChunker::interruptFile();
    }

    auto data = static_cast<void*>(const_cast<char*>(filename));
    auto method = new TMethodJob<Client>(this, &Client::sendFileThread, data);
    m_sendFileThread.reset(new Thread(method));
}

void
Client::sendFileThread(void* filename)
{
    try {
        char* name  = static_cast<char*>(filename);
        StreamChunker::sendFile(name, m_events, this);
    }
    catch (std::runtime_error& error) {
        LOG((CLOG_ERR "failed sending file chunks: %s", error.what()));
    }

    m_sendFileThread.reset(nullptr);
}

void
Client::sendDragInfo(UInt32 fileCount, String& info, size_t size)
{
    m_server->sendDragInfo(fileCount, info.c_str(), size);
}
