// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later

#include "connection.h"

Connection::Connection(const std::shared_ptr<Core>& core):
    state(initial),
    core(core),
    gloox()
{}

Connection::~Connection() noexcept {
    deinitialize();
}

void Connection::initiialize() {
    if (state != initial)
        return;

    gloox = std::make_unique<gloox::Client>(core->config.getFullJID(), core->config.getPassword());
    gloox->registerConnectionListener(this);
    gloox->registerMessageHandler(this);

    ::gloox::LogLevel level = Logger::convert(core->config.getLogLevel());
    gloox->logInstance().registerLogHandler(level, gloox::LogAreaAll, &core->logger);

    gloox::Disco* disco = gloox->disco();
    disco->setVersion("Jay", "0.0.1");
    disco->setIdentity("client", "bot");

    gloox->setTls(core->config.getTLSPolicy());
    gloox->setSASLMechanisms(gloox::SaslMechAll);
    gloox->setStreamManagement(true, true);

    state = disconnected;
}

void Connection::deinitialize() {
    if (state == initial)
        return;

    core->logger.log(Logger::debug, "deinitializing", {"Connection"});
    gloox->logInstance().removeLogHandler(&core->logger);

    gloox->removeMessageHandler(this);
    gloox->removeConnectionListener(this);
    gloox = nullptr;

    state = initial;
}

void Connection::connect() {
    if (state != disconnected)
        return;

    core->logger.log(Logger::debug, "connecting", {"Connection"});
    state = connected;
    gloox->connect(true);
    state = disconnected;
}

void Connection::send(const std::string& jid, const std::string& body) {
    core->logger.log(Logger::debug, "sending message \"" + body + "\" to " + jid, {"Connection"});
    gloox->send(gloox::Message(gloox::Message::Chat, jid, body));
}

void Connection::handleMessage(const gloox::Message& message, gloox::MessageSession* session) {
    std::string jid = message.from().bare();
    core->logger.log(Logger::debug, "received message \"" + message.body() + "\" from " + jid, {"Connection"});
    core->router.routeMessage(jid, message.body());
}

void Connection::onConnect() {
    core->logger.log(Logger::info, "connection established", {"Connection"});
}
void Connection::onDisconnect(gloox::ConnectionError e) {
    std::string error;

    switch (e) {
        case gloox::ConnNoError:
            break;
        case gloox::ConnStreamError:   //TODO Use ClientBase::streamError() to find the reason. */
            error = "stream error occured";
            break;
        case gloox::ConnStreamVersionError:
            error = "incoming stream's version is not supported";
            break;
        case gloox::ConnStreamClosed:
            error = "stream has been closed (by the server)";
            break;
        case gloox::ConnProxyAuthRequired:
            error = "HTTP/SOCKS5 proxy requires authentication";
            break;
        case gloox::ConnProxyAuthFailed:
            error = "HTTP/SOCKS5 proxy authentication failed";
            break;
        case gloox::ConnProxyNoSupportedAuth:
            error = "HTTP/SOCKS5 proxy requires an unsupported auth mechanism";
            break;
        case gloox::ConnIoError:
            error = "I/O error occured";
            break;
        case gloox::ConnParseError:
            error = "XML parse error occurred";
            break;
        case gloox::ConnConnectionRefused:
            error = "connection was refused by the server (on the socket level)";
            break;
        case gloox::ConnDnsError:
            error = "resolving the server's hostname failed";
            break;
        case gloox::ConnOutOfMemory:
            error = "connection out of memory";
            break;
        case gloox::ConnNoSupportedAuth:
            error = "auth mechanisms the server offers are not supported";
            break;
        case gloox::ConnTlsFailed:
            error = "server's certificate could not be verified or the TLS";
            break;
        case gloox::ConnTlsNotAvailable:
            error = "server didn't offer TLS while it was set to be required";
            break;
        case gloox::ConnCompressionFailed:
            error = "negotiating/initializing compression failed";
            break;
        case gloox::ConnAuthenticationFailed: //TODO use ClientBase::authError() to find the reason. */
            error = "authentication failed";
            break;

        case gloox::ConnUserDisconnected:
            error = "user (or higher-level protocol) requested a disconnect";
            break;
        case gloox::ConnNotConnected:
            error = "there is no active connection";
    }

    if (error.empty())
        core->logger.log(Logger::info, "disconnected"  , {"Connection"});
    else
        core->logger.log(Logger::error, "disconnected: " + error  , {"Connection"});
}
bool Connection::onTLSConnect(const gloox::CertInfo&) {
    core->logger.log(Logger::info, "TLS established", {"Connection"});
    return true;
}