/* ****************************************************************************
 * Copyright 2019 Open Systems Development BV                                 *
 *                                                                            *
 * Permission is hereby granted, free of charge, to any person obtaining a    *
 * copy of this software and associated documentation files (the "Software"), *
 * to deal in the Software without restriction, including without limitation  *
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
 * and/or sell copies of the Software, and to permit persons to whom the      *
 * Software is furnished to do so, subject to the following conditions:       *
 *                                                                            *
 * The above copyright notice and this permission notice shall be included in *
 * all copies or substantial portions of the Software.                        *
 *                                                                            *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING    *
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER        *
 * DEALINGS IN THE SOFTWARE.                                                  *
 * ***************************************************************************/
#include "qmqtt_client.h"
#include "qmqtt_client_p.h"

QMQTT::Client::Client(const QHostAddress& host,
                      const quint16 port,
                      QObject* parent)
    : QObject(parent)
    , d_ptr(new ClientPrivate(this))
{
    Q_D(Client);
    d->init(host, port);
}

#ifndef QT_NO_SSL
QMQTT::Client::Client(const QString &hostName,
                      const quint16 port,
                      const QSslConfiguration &config,
                      const bool ignoreSelfSigned, QObject *parent)
    : QObject(parent)
    , d_ptr(new ClientPrivate(this))
{
    Q_D(Client);
    d->init(hostName, port, config, ignoreSelfSigned);
}
#endif // QT_NO_SSL

QMQTT::Client::Client(const QString &hostName,
                      const quint16 port,
                      const bool ssl,
                      const bool ignoreSelfSigned,
                      QObject* parent)
    : QObject(parent)
    , d_ptr(new ClientPrivate(this))
{
    Q_D(Client);
    d->init(hostName, port, ssl, ignoreSelfSigned);
}

#ifdef QT_WEBSOCKETS_LIB
QMQTT::Client::Client(const QString& url,
                      const QString& origin,
                      QWebSocketProtocol::Version version,
                      bool ignoreSelfSigned,
                      QObject* parent)
    : QObject(parent)
    , d_ptr(new ClientPrivate(this))
{
    Q_D(Client);
#ifndef QT_NO_SSL
    d->init(url, origin, version, NULL, ignoreSelfSigned);
#else
    Q_UNUSED(ignoreSelfSigned)
    d->init(url, origin, version);
#endif // QT_NO_SSL
}

#ifndef QT_NO_SSL
QMQTT::Client::Client(const QString& url,
                      const QString& origin,
                      QWebSocketProtocol::Version version,
                      const QSslConfiguration& sslConfig,
                      const bool ignoreSelfSigned,
                      QObject* parent)
    : QObject(parent)
    , d_ptr(new ClientPrivate(this))
{
    Q_D(Client);
    d->init(url, origin, version, &sslConfig, ignoreSelfSigned);
}
#endif // QT_NO_SSL
#endif // QT_WEBSOCKETS_LIB

QMQTT::Client::Client(NetworkInterface* network,
                      const QHostAddress& host,
                      const quint16 port,
                      QObject* parent)
    : QObject(parent)
    , d_ptr(new ClientPrivate(this))
{
    Q_D(Client);
    d->init(host, port, network);
}

QMQTT::Client::~Client()
{
}

QHostAddress QMQTT::Client::host() const
{
    Q_D(const Client);
    return d->host();
}

void QMQTT::Client::setHost(const QHostAddress& host)
{
    Q_D(Client);
    d->setHost(host);
}

QString QMQTT::Client::hostName() const
{
    Q_D(const Client);
    return d->hostName();
}

void QMQTT::Client::setHostName(const QString &hostName)
{
    Q_D(Client);
    d->setHostName(hostName);
}

quint16 QMQTT::Client::port() const
{
    Q_D(const Client);
    return d->port();
}

void QMQTT::Client::setPort(const quint16 port)
{
    Q_D(Client);
    d->setPort(port);
}

QString QMQTT::Client::clientId() const
{
    Q_D(const Client);
    return d->clientId();
}

void QMQTT::Client::setClientId(const QString& clientId)
{
    Q_D(Client);
    d->setClientId(clientId);
}

QString QMQTT::Client::username() const
{
    Q_D(const Client);
    return d->username();
}

void QMQTT::Client::setUsername(const QString& username)
{
    Q_D(Client);
    d->setUsername(username);
}

QMQTT::MQTTVersion QMQTT::Client::version() const
{
    Q_D(const Client);
    return d->version();
}

void QMQTT::Client::setVersion(const QMQTT::MQTTVersion version)
{
    Q_D(Client);
    d->setVersion(version);
}

QByteArray QMQTT::Client::password() const
{
    Q_D(const Client);
    return d->password();
}

void QMQTT::Client::setPassword(const QByteArray &password)
{
    Q_D(Client);
    d->setPassword(password);
}

quint16 QMQTT::Client::keepAlive() const
{
    Q_D(const Client);
    return d->keepAlive();
}

void QMQTT::Client::setKeepAlive(const quint16 keepAlive)
{
    Q_D(Client);
    d->setKeepAlive(keepAlive);
}

bool QMQTT::Client::cleanSession() const
{
    Q_D(const Client);
    return d->cleanSession();
}

void QMQTT::Client::setCleanSession(const bool cleanSession)
{
    Q_D(Client);
    d->setCleanSession(cleanSession);
}

bool QMQTT::Client::autoReconnect() const
{
    Q_D(const Client);
    return d->autoReconnect();
}

void QMQTT::Client::setAutoReconnect(const bool value)
{
    Q_D(Client);
    d->setAutoReconnect(value);
}

int QMQTT::Client::autoReconnectInterval() const
{
    Q_D(const Client);
    return d->autoReconnectInterval();
}

void QMQTT::Client::setAutoReconnectInterval(const int autoReconnectInterval)
{
    Q_D(Client);
    d->setAutoReconnectInterval(autoReconnectInterval);
}

QString QMQTT::Client::willTopic() const
{
    Q_D(const Client);
    return d->willTopic();
}

void QMQTT::Client::setWillTopic(const QString& willTopic)
{
    Q_D(Client);
    d->setWillTopic(willTopic);
}

quint8 QMQTT::Client::willQos() const
{
    Q_D(const Client);
    return d->willQos();
}

void QMQTT::Client::setWillQos(const quint8 willQos)
{
    Q_D(Client);
    d->setWillQos(willQos);
}

bool QMQTT::Client::willRetain() const
{
    Q_D(const Client);
    return d->willRetain();
}

void QMQTT::Client::setWillRetain(const bool willRetain)
{
    Q_D(Client);
    d->setWillRetain(willRetain);
}

QByteArray QMQTT::Client::willMessage() const
{
    Q_D(const Client);
    return d->willMessage();
}

void QMQTT::Client::setWillMessage(const QByteArray &willMessage)
{
    Q_D(Client);
    d->setWillMessage(willMessage);
}

QMQTT::ConnectionState QMQTT::Client::connectionState() const
{
    Q_D(const Client);
    return d->connectionState();
}

bool QMQTT::Client::isConnectedToHost() const
{
    Q_D(const Client);
    return d->isConnectedToHost();
}

#ifndef QT_NO_SSL
QSslConfiguration QMQTT::Client::sslConfiguration() const
{
    Q_D(const Client);
    return d->sslConfiguration();
}

void QMQTT::Client::setSslConfiguration(const QSslConfiguration& config)
{
    Q_D(Client);
    d->setSslConfiguration(config);
}
#endif // QT_NO_SSL

void QMQTT::Client::connectToHost()
{
    Q_D(Client);
    d->connectToHost();
}

void QMQTT::Client::onNetworkConnected()
{
    Q_D(Client);
    d->onNetworkConnected();
}

quint16 QMQTT::Client::publish(const Message& message)
{
    Q_D(Client);
    return d->publish(message);
}

void QMQTT::Client::subscribe(const QString& topic, const quint8 qos)
{
    Q_D(Client);
    d->subscribe(topic, qos);
}

void QMQTT::Client::unsubscribe(const QString& topic)
{
    Q_D(Client);
    d->unsubscribe(topic);
}

void QMQTT::Client::onTimerPingReq()
{
    Q_D(Client);
    d->onTimerPingReq();
}

void QMQTT::Client::onPingTimeout()
{
    Q_D(Client);
    d->onPingTimeout();
}

void QMQTT::Client::disconnectFromHost()
{
    Q_D(Client);
    d->disconnectFromHost();
}

void QMQTT::Client::onNetworkReceived(const QMQTT::Frame& frame)
{
    Q_D(Client);
    d->onNetworkReceived(frame);
}

void QMQTT::Client::onNetworkDisconnected()
{
    Q_D(Client);
    d->onNetworkDisconnected();
}

void QMQTT::Client::onNetworkError(QAbstractSocket::SocketError error)
{
    Q_D(Client);
    d->onNetworkError(error);
}

#ifndef QT_NO_SSL
void QMQTT::Client::onSslErrors(const QList<QSslError>& errors)
{
    Q_D(Client);
    d->onSslErrors(errors);
}
#endif // QT_NO_SSL

#ifndef QT_NO_SSL
void QMQTT::Client::ignoreSslErrors()
{
    Q_D(Client);
    d->ignoreSslErrors();
}

void QMQTT::Client::ignoreSslErrors(const QList<QSslError>& errors)
{
    Q_D(Client);
    d->ignoreSslErrors(errors);
}
#endif // QT_NO_SSL