#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Client/ClientSession.h>

#include <Swiften/TLS/CertificateVerificationError.h>

#include <Swiften/Network/ChainedConnector.h>

#include <Swiften/Network/NetworkFactories.h>

#include <Swiften/Network/ProxyProvider.h>

#include <Swiften/TLS/PKCS12Certificate.h>

#include <Swiften/Session/BasicSessionStream.h>

#include <Swiften/Session/BOSHSessionStream.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Client/ClientSessionStanzaChannel.h>

#include <Swiften/Network/SOCKS5ProxiedConnectionFactory.h>

#include <Swiften/Network/HTTPConnectProxiedConnectionFactory.h>

namespace Swift {

}

void CoreClient::connect(const std::string& host) {

forceReset();

SWIFT_LOG(debug) << "Connecting to host " << host << std::endl;

disconnectRequested_ = false;

assert(!connector_);

assert(proxyConnectionFactories.empty());

proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getConnectionFactory(), networkFactories->getProxyProvider()->getSOCKS5Proxy()));

}

if(networkFactories->getProxyProvider()->getHTTPConnectProxy().isValid()) {

proxyConnectionFactories.push_back(new HTTPConnectProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), networkFactories->getEventLoop(), networkFactories->getProxyProvider()->getHTTPConnectProxy().getAddress().toString(), networkFactories->getProxyProvider()->getHTTPConnectProxy().getPort()));

}

std::vector<ConnectionFactory*> connectionFactories(proxyConnectionFactories);

if (options.boshURL.empty()) {

connectionFactories.push_back(networkFactories->getConnectionFactory());

connector_ = boost::make_shared<ChainedConnector>(host, networkFactories->getDomainNameResolver(), connectionFactories, networkFactories->getTimerFactory());

connector_->setTimeoutMilliseconds(60*1000);

connector_->start();

}

else {

/* Autodiscovery of which proxy works is largely ok with a TCP session, because this is a one-off. With BOSH

* it would be quite painful given that potentially every stanza could be sent on a new connection.

*/

//sessionStream_ = boost::make_shared<BOSHSessionStream>(boost::make_shared<BOSHConnectionFactory>(options.boshURL, networkFactories->getConnectionFactory(), networkFactories->getXMLParserFactory(), networkFactories->getTLSContextFactory()), getPayloadParserFactories(), getPayloadSerializers(), networkFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory(), networkFactories->getEventLoop(), host, options.boshHTTPConnectProxyURL, options.boshHTTPConnectProxyAuthID, options.boshHTTPConnectProxyAuthPassword);

sessionStream_ = boost::shared_ptr<BOSHSessionStream>(new BOSHSessionStream(

stanzaChannel_->setSession(session_);

session_->onFinished.connect(boost::bind(&CoreClient::handleSessionFinished, this, _1));

session_->onNeedCredentials.connect(boost::bind(&CoreClient::handleNeedCredentials, this));

session_->start();

}

/**

* Only called for TCP sessions. BOSH is handled inside the BOSHSessionStream.

*/

resetConnector();

if (!connection) {

if (options.forgetPassword) {

purgePassword();

}

}

else {

assert(!connection_);

connection_ = connection;

assert(!sessionStream_);

sessionStream_ = boost::make_shared<BasicSessionStream>(ClientStreamType, connection_, getPayloadParserFactories(), getPayloadSerializers(), networkFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory());

if (certificate_ && !certificate_->isNull()) {

sessionStream_->setTLSCertificate(certificate_);

return jid_;

}

}

void CoreClient::purgePassword() {

safeClear(password_);

}

void CoreClient::resetConnector() {

connector_.reset();

foreach(ConnectionFactory* f, proxyConnectionFactories) {

delete f;

}

proxyConnectionFactories.clear();

}

void CoreClient::resetSession() {

session_->onFinished.disconnect(boost::bind(&CoreClient::handleSessionFinished, this, _1));

return networkFactories;

}

/**

* Called before onConnected signal is emmitted.

*/

virtual void handleConnected() {};

private:

void handleStanzaChannelAvailableChanged(bool available);

void handleSessionFinished(boost::shared_ptr<Error>);

void handleNeedCredentials();

void handleDataRead(const SafeByteArray&);

void handleDataWritten(const SafeByteArray&);

void handlePresenceReceived(boost::shared_ptr<Presence>);

void handleMessageReceived(boost::shared_ptr<Message>);

void handleStanzaAcked(boost::shared_ptr<Stanza>);

void purgePassword();