/*
 * This file Copyright (C) 2009-2016 Mnemosyne LLC
 *
 * It may be used under the GNU GPL versions 2 or 3
 * or any future license endorsed by Mnemosyne LLC.
 *
 */

#include <cassert>
#include <iostream>

#include <QApplication>
#include <QByteArray>
#include <QClipboard>
#include <QCoreApplication>
#include <QDebug>
#include <QDesktopServices>
#include <QFile>
#include <QFileInfo>
#include <QMessageBox>
#include <QStyle>
#include <QTextStream>

#include <libtransmission/transmission.h>
#include <libtransmission/session-id.h>
#include <libtransmission/utils.h> // tr_free
#include <libtransmission/variant.h>

#include "AddData.h"
#include "Prefs.h"
#include "RpcQueue.h"
#include "Session.h"
#include "SessionDialog.h"
#include "Torrent.h"
#include "Utils.h"

/***
****
***/

namespace
{

typedef Torrent::KeyList KeyList;

KeyList const& getInfoKeys()
{
    return Torrent::getInfoKeys();
}

KeyList const& getStatKeys()
{
    return Torrent::getStatKeys();
}

KeyList const& getExtraStatKeys()
{
    return Torrent::getExtraStatKeys();
}

void addList(tr_variant* list, KeyList const& keys)
{
    tr_variantListReserve(list, keys.size());

    for (tr_quark const key : keys)
    {
        tr_variantListAddQuark(list, key);
    }
}

// If this object is passed as "ids" (compared by address), then recently active torrents are queried.
QSet<int> const recentlyActiveIds = QSet<int>() << -1;

// If this object is passed as "ids" (compared by being empty), then all torrents are queried.
QSet<int> const allIds;

} // namespace

void Session::sessionSet(tr_quark const key, QVariant const& value)
{
    tr_variant args;
    tr_variantInitDict(&args, 1);

    switch (value.type())
    {
    case QVariant::Bool:
        tr_variantDictAddBool(&args, key, value.toBool());
        break;

    case QVariant::Int:
        tr_variantDictAddInt(&args, key, value.toInt());
        break;

    case QVariant::Double:
        tr_variantDictAddReal(&args, key, value.toDouble());
        break;

    case QVariant::String:
        tr_variantDictAddStr(&args, key, value.toString().toUtf8().constData());
        break;

    default:
        assert(false);
    }

    exec("session-set", &args);
}

void Session::portTest()
{
    RpcQueue* q = new RpcQueue();

    q->add([this]()
        {
            return exec("port-test", nullptr);
        });

    q->add([this](RpcResponse const& r)
        {
            bool isOpen = false;

            if (r.success)
            {
                (void)tr_variantDictFindBool(r.args.get(), TR_KEY_port_is_open, &isOpen);
            }

            emit portTested(isOpen);
        });

    q->run();
}

void Session::copyMagnetLinkToClipboard(int torrentId)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    tr_variantListAddInt(tr_variantDictAddList(&args, TR_KEY_ids, 1), torrentId);
    tr_variantListAddStr(tr_variantDictAddList(&args, TR_KEY_fields, 1), "magnetLink");

    RpcQueue* q = new RpcQueue();

    q->add([this, &args]()
        {
            return exec(TR_KEY_torrent_get, &args);
        });

    q->add([this](RpcResponse const& r)
        {
            tr_variant* torrents;
            tr_variant* child;
            char const* str;

            if (tr_variantDictFindList(r.args.get(), TR_KEY_torrents, &torrents) &&
                (child = tr_variantListChild(torrents, 0)) && tr_variantDictFindStr(child, TR_KEY_magnetLink, &str, nullptr))
            {
                qApp->clipboard()->setText(QString::fromUtf8(str));
            }
        });

    q->run();
}

void Session::updatePref(int key)
{
    if (myPrefs.isCore(key))
    {
        switch (key)
        {
        case Prefs::ALT_SPEED_LIMIT_DOWN:
        case Prefs::ALT_SPEED_LIMIT_ENABLED:
        case Prefs::ALT_SPEED_LIMIT_TIME_BEGIN:
        case Prefs::ALT_SPEED_LIMIT_TIME_DAY:
        case Prefs::ALT_SPEED_LIMIT_TIME_ENABLED:
        case Prefs::ALT_SPEED_LIMIT_TIME_END:
        case Prefs::ALT_SPEED_LIMIT_UP:
        case Prefs::BLOCKLIST_DATE:
        case Prefs::BLOCKLIST_ENABLED:
        case Prefs::BLOCKLIST_URL:
        case Prefs::DHT_ENABLED:
        case Prefs::DOWNLOAD_QUEUE_ENABLED:
        case Prefs::DOWNLOAD_QUEUE_SIZE:
        case Prefs::DSPEED:
        case Prefs::DSPEED_ENABLED:
        case Prefs::IDLE_LIMIT:
        case Prefs::IDLE_LIMIT_ENABLED:
        case Prefs::INCOMPLETE_DIR:
        case Prefs::INCOMPLETE_DIR_ENABLED:
        case Prefs::LPD_ENABLED:
        case Prefs::PEER_LIMIT_GLOBAL:
        case Prefs::PEER_LIMIT_TORRENT:
        case Prefs::PEER_PORT:
        case Prefs::PEER_PORT_RANDOM_ON_START:
        case Prefs::QUEUE_STALLED_MINUTES:
        case Prefs::PEX_ENABLED:
        case Prefs::PORT_FORWARDING:
        case Prefs::RENAME_PARTIAL_FILES:
        case Prefs::SCRIPT_TORRENT_DONE_ENABLED:
        case Prefs::SCRIPT_TORRENT_DONE_FILENAME:
        case Prefs::START:
        case Prefs::TRASH_ORIGINAL:
        case Prefs::USPEED:
        case Prefs::USPEED_ENABLED:
        case Prefs::UTP_ENABLED:
            sessionSet(myPrefs.getKey(key), myPrefs.variant(key));
            break;

        case Prefs::DOWNLOAD_DIR:
            sessionSet(myPrefs.getKey(key), myPrefs.variant(key));
            /* this will change the 'freespace' argument, so refresh */
            refreshSessionInfo();
            break;

        case Prefs::RATIO:
            sessionSet(TR_KEY_seedRatioLimit, myPrefs.variant(key));
            break;

        case Prefs::RATIO_ENABLED:
            sessionSet(TR_KEY_seedRatioLimited, myPrefs.variant(key));
            break;

        case Prefs::ENCRYPTION:
            {
                int const i = myPrefs.variant(key).toInt();

                switch (i)
                {
                case 0:
                    sessionSet(myPrefs.getKey(key), QLatin1String("tolerated"));
                    break;

                case 1:
                    sessionSet(myPrefs.getKey(key), QLatin1String("preferred"));
                    break;

                case 2:
                    sessionSet(myPrefs.getKey(key), QLatin1String("required"));
                    break;
                }

                break;
            }

        case Prefs::RPC_AUTH_REQUIRED:
            if (mySession != nullptr)
            {
                tr_sessionSetRPCPasswordEnabled(mySession, myPrefs.getBool(key));
            }

            break;

        case Prefs::RPC_ENABLED:
            if (mySession != nullptr)
            {
                tr_sessionSetRPCEnabled(mySession, myPrefs.getBool(key));
            }

            break;

        case Prefs::RPC_PASSWORD:
            if (mySession != nullptr)
            {
                tr_sessionSetRPCPassword(mySession, myPrefs.getString(key).toUtf8().constData());
            }

            break;

        case Prefs::RPC_PORT:
            if (mySession != nullptr)
            {
                tr_sessionSetRPCPort(mySession, myPrefs.getInt(key));
            }

            break;

        case Prefs::RPC_USERNAME:
            if (mySession != nullptr)
            {
                tr_sessionSetRPCUsername(mySession, myPrefs.getString(key).toUtf8().constData());
            }

            break;

        case Prefs::RPC_WHITELIST_ENABLED:
            if (mySession != nullptr)
            {
                tr_sessionSetRPCWhitelistEnabled(mySession, myPrefs.getBool(key));
            }

            break;

        case Prefs::RPC_WHITELIST:
            if (mySession != nullptr)
            {
                tr_sessionSetRPCWhitelist(mySession, myPrefs.getString(key).toUtf8().constData());
            }

            break;

        default:
            std::cerr << "unhandled pref: " << key << std::endl;
        }
    }
}

/***
****
***/

Session::Session(QString const& configDir, Prefs& prefs) :
    myConfigDir(configDir),
    myPrefs(prefs),
    myBlocklistSize(-1),
    mySession(nullptr),
    myIsDefinitelyLocalSession(true)
{
    myStats.ratio = TR_RATIO_NA;
    myStats.uploadedBytes = 0;
    myStats.downloadedBytes = 0;
    myStats.filesAdded = 0;
    myStats.sessionCount = 0;
    myStats.secondsActive = 0;
    myCumulativeStats = myStats;

    connect(&myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)));
    connect(&myRpc, SIGNAL(httpAuthenticationRequired()), this, SIGNAL(httpAuthenticationRequired()));
    connect(&myRpc, SIGNAL(dataReadProgress()), this, SIGNAL(dataReadProgress()));
    connect(&myRpc, SIGNAL(dataSendProgress()), this, SIGNAL(dataSendProgress()));
    connect(&myRpc, SIGNAL(networkResponse(QNetworkReply::NetworkError, QString)), this,
        SIGNAL(networkResponse(QNetworkReply::NetworkError, QString)));
}

Session::~Session()
{
    stop();
}

/***
****
***/

void Session::stop()
{
    myRpc.stop();

    if (mySession != nullptr)
    {
        tr_sessionClose(mySession);
        mySession = nullptr;
    }
}

void Session::restart()
{
    stop();
    start();
}

void Session::start()
{
    if (myPrefs.get<bool>(Prefs::SESSION_IS_REMOTE))
    {
        QUrl url;
        url.setScheme(QLatin1String("http"));
        url.setHost(myPrefs.get<QString>(Prefs::SESSION_REMOTE_HOST));
        url.setPort(myPrefs.get<int>(Prefs::SESSION_REMOTE_PORT));
        url.setPath(QLatin1String("/transmission/rpc"));

        if (myPrefs.get<bool>(Prefs::SESSION_REMOTE_AUTH))
        {
            url.setUserName(myPrefs.get<QString>(Prefs::SESSION_REMOTE_USERNAME));
            url.setPassword(myPrefs.get<QString>(Prefs::SESSION_REMOTE_PASSWORD));
        }

        myRpc.start(url);
    }
    else
    {
        tr_variant settings;
        tr_variantInitDict(&settings, 0);
        tr_sessionLoadSettings(&settings, myConfigDir.toUtf8().constData(), "qt");
        mySession = tr_sessionInit(myConfigDir.toUtf8().constData(), true, &settings);
        tr_variantFree(&settings);

        myRpc.start(mySession);

        tr_ctor* ctor = tr_ctorNew(mySession);
        int torrentCount;
        tr_torrent** torrents = tr_sessionLoadTorrents(mySession, ctor, &torrentCount);
        tr_free(torrents);
        tr_ctorFree(ctor);
    }

    emit sourceChanged();
}

bool Session::isServer() const
{
    return mySession != nullptr;
}

bool Session::isLocal() const
{
    if (!mySessionId.isEmpty())
    {
        return myIsDefinitelyLocalSession;
    }

    return myRpc.isLocal();
}

/***
****
***/

namespace
{

void addOptionalIds(tr_variant* args, QSet<int> const& ids)
{
    if (&ids == &recentlyActiveIds)
    {
        tr_variantDictAddStr(args, TR_KEY_ids, "recently-active");
    }
    else if (!ids.isEmpty())
    {
        tr_variant* idList(tr_variantDictAddList(args, TR_KEY_ids, ids.size()));

        for (int const i : ids)
        {
            tr_variantListAddInt(idList, i);
        }
    }
}

} // namespace

void Session::torrentSet(QSet<int> const& ids, tr_quark const key, double value)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    tr_variantDictAddReal(&args, key, value);
    addOptionalIds(&args, ids);

    exec(TR_KEY_torrent_set, &args);
}

void Session::torrentSet(QSet<int> const& ids, tr_quark const key, int value)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    tr_variantDictAddInt(&args, key, value);
    addOptionalIds(&args, ids);

    exec(TR_KEY_torrent_set, &args);
}

void Session::torrentSet(QSet<int> const& ids, tr_quark const key, bool value)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    tr_variantDictAddBool(&args, key, value);
    addOptionalIds(&args, ids);

    exec(TR_KEY_torrent_set, &args);
}

void Session::torrentSet(QSet<int> const& ids, tr_quark const key, QStringList const& value)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    addOptionalIds(&args, ids);
    tr_variant* list(tr_variantDictAddList(&args, key, value.size()));

    for (QString const& str : value)
    {
        tr_variantListAddStr(list, str.toUtf8().constData());
    }

    exec(TR_KEY_torrent_set, &args);
}

void Session::torrentSet(QSet<int> const& ids, tr_quark const key, QList<int> const& value)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    addOptionalIds(&args, ids);
    tr_variant* list(tr_variantDictAddList(&args, key, value.size()));

    for (int const i : value)
    {
        tr_variantListAddInt(list, i);
    }

    exec(TR_KEY_torrent_set, &args);
}

void Session::torrentSet(QSet<int> const& ids, tr_quark const key, QPair<int, QString> const& value)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    addOptionalIds(&args, ids);
    tr_variant* list(tr_variantDictAddList(&args, key, 2));
    tr_variantListAddInt(list, value.first);
    tr_variantListAddStr(list, value.second.toUtf8().constData());

    exec(TR_KEY_torrent_set, &args);
}

void Session::torrentSetLocation(QSet<int> const& ids, QString const& location, bool doMove)
{
    tr_variant args;
    tr_variantInitDict(&args, 3);
    addOptionalIds(&args, ids);
    tr_variantDictAddStr(&args, TR_KEY_location, location.toUtf8().constData());
    tr_variantDictAddBool(&args, TR_KEY_move, doMove);

    exec(TR_KEY_torrent_set_location, &args);
}

void Session::torrentRenamePath(QSet<int> const& ids, QString const& oldpath, QString const& newname)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    addOptionalIds(&args, ids);
    tr_variantDictAddStr(&args, TR_KEY_path, oldpath.toUtf8().constData());
    tr_variantDictAddStr(&args, TR_KEY_name, newname.toUtf8().constData());

    RpcQueue* q = new RpcQueue();

    q->add([this, &args]()
        {
            return exec("torrent-rename-path", &args);
        },
        [this](RpcResponse const& r)
        {
            char const* path = "(unknown)";
            char const* name = "(unknown)";
            tr_variantDictFindStr(r.args.get(), TR_KEY_path, &path, nullptr);
            tr_variantDictFindStr(r.args.get(), TR_KEY_name, &name, nullptr);

            QMessageBox* d = new QMessageBox(QMessageBox::Information, tr("Error Renaming Path"),
                tr("<p><b>Unable to rename \"%1\" as \"%2\": %3.</b></p><p>Please correct the errors and try again.</p>").
                    arg(QString::fromUtf8(path)).arg(QString::fromUtf8(name)).arg(r.result), QMessageBox::Close,
                qApp->activeWindow());
            connect(d, SIGNAL(rejected()), d, SLOT(deleteLater()));
            d->show();
        });

    q->add([this](RpcResponse const& r)
        {
            int64_t id = 0;

            if (tr_variantDictFindInt(r.args.get(), TR_KEY_id, &id) && id != 0)
            {
                refreshTorrents(QSet<int>() << id, KeyList() << TR_KEY_fileStats << TR_KEY_files << TR_KEY_id << TR_KEY_name);
            }
        });

    q->run();
}

void Session::refreshTorrents(QSet<int> const& ids, KeyList const& keys)
{
    tr_variant args;
    tr_variantInitDict(&args, 2);
    addList(tr_variantDictAddList(&args, TR_KEY_fields, 0), keys);
    addOptionalIds(&args, ids);

    RpcQueue* q = new RpcQueue();

    q->add([this, &args]()
        {
            return exec(TR_KEY_torrent_get, &args);
        });

    bool const allTorrents = ids.empty();

    q->add([this, allTorrents](RpcResponse const& r)
        {
            tr_variant* torrents;

            if (tr_variantDictFindList(r.args.get(), TR_KEY_torrents, &torrents))
            {
                emit torrentsUpdated(torrents, allTorrents);
            }

            if (tr_variantDictFindList(r.args.get(), TR_KEY_removed, &torrents))
            {
                emit torrentsRemoved(torrents);
            }
        });

    q->run();
}

void Session::refreshExtraStats(QSet<int> const& ids)
{
    refreshTorrents(ids, getStatKeys() + getExtraStatKeys());
}

void Session::sendTorrentRequest(char const* request, QSet<int> const& ids)
{
    tr_variant args;
    tr_variantInitDict(&args, 1);
    addOptionalIds(&args, ids);

    RpcQueue* q = new RpcQueue();

    q->add([this, request, &args]()
        {
            return exec(request, &args);
        });

    q->add([this, ids]()
        {
            refreshTorrents(ids, getStatKeys());
        });

    q->run();
}

void Session::pauseTorrents(QSet<int> const& ids)
{
    sendTorrentRequest("torrent-stop", ids);
}

void Session::startTorrents(QSet<int> const& ids)
{
    sendTorrentRequest("torrent-start", ids);
}

void Session::startTorrentsNow(QSet<int> const& ids)
{
    sendTorrentRequest("torrent-start-now", ids);
}

void Session::queueMoveTop(QSet<int> const& ids)
{
    sendTorrentRequest("queue-move-top", ids);
}

void Session::queueMoveUp(QSet<int> const& ids)
{
    sendTorrentRequest("queue-move-up", ids);
}

void Session::queueMoveDown(QSet<int> const& ids)
{
    sendTorrentRequest("queue-move-down", ids);
}

void Session::queueMoveBottom(QSet<int> const& ids)
{
    sendTorrentRequest("queue-move-bottom", ids);
}

void Session::refreshActiveTorrents()
{
    refreshTorrents(recentlyActiveIds, getStatKeys());
}

void Session::refreshAllTorrents()
{
    refreshTorrents(allIds, getStatKeys());
}

void Session::initTorrents(QSet<int> const& ids)
{
    refreshTorrents(ids, getStatKeys() + getInfoKeys());
}

void Session::refreshSessionStats()
{
    RpcQueue* q = new RpcQueue();

    q->add([this]()
        {
            return exec("session-stats", nullptr);
        });

    q->add([this](RpcResponse const& r)
        {
            updateStats(r.args.get());
        });

    q->run();
}

void Session::refreshSessionInfo()
{
    RpcQueue* q = new RpcQueue();

    q->add([this]()
        {
            return exec("session-get", nullptr);
        });

    q->add([this](RpcResponse const& r)
        {
            updateInfo(r.args.get());
        });

    q->run();
}

void Session::updateBlocklist()
{
    RpcQueue* q = new RpcQueue();

    q->add([this]()
        {
            return exec("blocklist-update", nullptr);
        });

    q->add([this](RpcResponse const& r)
        {
            int64_t blocklistSize;

            if (tr_variantDictFindInt(r.args.get(), TR_KEY_blocklist_size, &blocklistSize))
            {
                setBlocklistSize(blocklistSize);
            }
        });

    q->run();
}

/***
****
***/

RpcResponseFuture Session::exec(tr_quark method, tr_variant* args)
{
    return myRpc.exec(method, args);
}

RpcResponseFuture Session::exec(char const* method, tr_variant* args)
{
    return myRpc.exec(method, args);
}

void Session::updateStats(tr_variant* d, tr_session_stats* stats)
{
    int64_t i;

    if (tr_variantDictFindInt(d, TR_KEY_uploadedBytes, &i))
    {
        stats->uploadedBytes = i;
    }

    if (tr_variantDictFindInt(d, TR_KEY_downloadedBytes, &i))
    {
        stats->downloadedBytes = i;
    }

    if (tr_variantDictFindInt(d, TR_KEY_filesAdded, &i))
    {
        stats->filesAdded = i;
    }

    if (tr_variantDictFindInt(d, TR_KEY_sessionCount, &i))
    {
        stats->sessionCount = i;
    }

    if (tr_variantDictFindInt(d, TR_KEY_secondsActive, &i))
    {
        stats->secondsActive = i;
    }

    stats->ratio = tr_getRatio(stats->uploadedBytes, stats->downloadedBytes);
}

void Session::updateStats(tr_variant* d)
{
    tr_variant* c;

    if (tr_variantDictFindDict(d, TR_KEY_current_stats, &c))
    {
        updateStats(c, &myStats);
    }

    if (tr_variantDictFindDict(d, TR_KEY_cumulative_stats, &c))
    {
        updateStats(c, &myCumulativeStats);
    }

    emit statsUpdated();
}

void Session::updateInfo(tr_variant* d)
{
    int64_t i;
    char const* str;

    disconnect(&myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)));

    for (int i = Prefs::FIRST_CORE_PREF; i <= Prefs::LAST_CORE_PREF; ++i)
    {
        tr_variant const* b(tr_variantDictFind(d, myPrefs.getKey(i)));

        if (b == nullptr)
        {
            continue;
        }

        if (i == Prefs::ENCRYPTION)
        {
            char const* val;

            if (tr_variantGetStr(b, &val, nullptr))
            {
                if (qstrcmp(val, "required") == 0)
                {
                    myPrefs.set(i, 2);
                }
                else if (qstrcmp(val, "preferred") == 0)
                {
                    myPrefs.set(i, 1);
                }
                else if (qstrcmp(val, "tolerated") == 0)
                {
                    myPrefs.set(i, 0);
                }
            }

            continue;
        }

        switch (myPrefs.type(i))
        {
        case QVariant::Int:
            {
                int64_t val;

                if (tr_variantGetInt(b, &val))
                {
                    myPrefs.set(i, static_cast<int>(val));
                }

                break;
            }

        case QVariant::Double:
            {
                double val;

                if (tr_variantGetReal(b, &val))
                {
                    myPrefs.set(i, val);
                }

                break;
            }

        case QVariant::Bool:
            {
                bool val;

                if (tr_variantGetBool(b, &val))
                {
                    myPrefs.set(i, val);
                }

                break;
            }

        case CustomVariantType::FilterModeType:
        case CustomVariantType::SortModeType:
        case QVariant::String:
            {
                char const* val;

                if (tr_variantGetStr(b, &val, nullptr))
                {
                    myPrefs.set(i, QString::fromUtf8(val));
                }

                break;
            }

        default:
            break;
        }
    }

    bool b;
    double x;

    if (tr_variantDictFindBool(d, TR_KEY_seedRatioLimited, &b))
    {
        myPrefs.set(Prefs::RATIO_ENABLED, b);
    }

    if (tr_variantDictFindReal(d, TR_KEY_seedRatioLimit, &x))
    {
        myPrefs.set(Prefs::RATIO, x);
    }

    /* Use the C API to get settings that, for security reasons, aren't supported by RPC */
    if (mySession != nullptr)
    {
        myPrefs.set(Prefs::RPC_ENABLED, tr_sessionIsRPCEnabled(mySession));
        myPrefs.set(Prefs::RPC_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled(mySession));
        myPrefs.set(Prefs::RPC_PASSWORD, QString::fromUtf8(tr_sessionGetRPCPassword(mySession)));
        myPrefs.set(Prefs::RPC_PORT, tr_sessionGetRPCPort(mySession));
        myPrefs.set(Prefs::RPC_USERNAME, QString::fromUtf8(tr_sessionGetRPCUsername(mySession)));
        myPrefs.set(Prefs::RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled(mySession));
        myPrefs.set(Prefs::RPC_WHITELIST, QString::fromUtf8(tr_sessionGetRPCWhitelist(mySession)));
    }

    if (tr_variantDictFindInt(d, TR_KEY_blocklist_size, &i) && i != blocklistSize())
    {
        setBlocklistSize(i);
    }

    if (tr_variantDictFindStr(d, TR_KEY_version, &str, nullptr) && mySessionVersion != QString::fromUtf8(str))
    {
        mySessionVersion = QString::fromUtf8(str);
    }

    if (tr_variantDictFindStr(d, TR_KEY_session_id, &str, nullptr))
    {
        QString const sessionId = QString::fromUtf8(str);

        if (mySessionId != sessionId)
        {
            mySessionId = sessionId;
            myIsDefinitelyLocalSession = tr_session_id_is_local(str);
        }
    }
    else
    {
        mySessionId.clear();
    }

    // std::cerr << "Session::updateInfo end" << std::endl;
    connect(&myPrefs, SIGNAL(changed(int)), this, SLOT(updatePref(int)));

    emit sessionUpdated();
}

void Session::setBlocklistSize(int64_t i)
{
    myBlocklistSize = i;

    emit blocklistUpdated(i);
}

void Session::addTorrent(AddData const& addMe, tr_variant* args, bool trashOriginal)
{
    assert(tr_variantDictFind(args, TR_KEY_filename) == nullptr);
    assert(tr_variantDictFind(args, TR_KEY_metainfo) == nullptr);

    if (tr_variantDictFind(args, TR_KEY_paused) == nullptr)
    {
        tr_variantDictAddBool(args, TR_KEY_paused, !myPrefs.getBool(Prefs::START));
    }

    switch (addMe.type)
    {
    case AddData::MAGNET:
        tr_variantDictAddStr(args, TR_KEY_filename, addMe.magnet.toUtf8().constData());
        break;

    case AddData::URL:
        tr_variantDictAddStr(args, TR_KEY_filename, addMe.url.toString().toUtf8().constData());
        break;

    case AddData::FILENAME: /* fall-through */
    case AddData::METAINFO:
        {
            QByteArray const b64 = addMe.toBase64();
            tr_variantDictAddRaw(args, TR_KEY_metainfo, b64.constData(), b64.size());
            break;
        }

    default:
        qWarning() << "Unhandled AddData type: " << addMe.type;
        break;
    }

    RpcQueue* q = new RpcQueue();

    q->add([this, args]()
        {
            return exec("torrent-add", args);
        },
        [this, addMe](RpcResponse const& r)
        {
            QMessageBox* d = new QMessageBox(QMessageBox::Warning, tr("Error Adding Torrent"),
                QString::fromLatin1("<p><b>%1</b></p><p>%2</p>").arg(r.result).arg(addMe.readableName()), QMessageBox::Close,
                qApp->activeWindow());
            connect(d, SIGNAL(rejected()), d, SLOT(deleteLater()));
            d->show();
        });

    q->add([this, addMe, trashOriginal](RpcResponse const& r)
        {
            tr_variant* dup;
            char const* str;

            if (tr_variantDictFindDict(r.args.get(), TR_KEY_torrent_duplicate, &dup) &&
                tr_variantDictFindStr(dup, TR_KEY_name, &str, nullptr))
            {
                QString const name = QString::fromUtf8(str);
                QMessageBox* d = new QMessageBox(QMessageBox::Warning, tr("Add Torrent"),
                    tr("<p><b>Unable to add \"%1\".</b></p><p>It is a duplicate of \"%2\" which is already added.</p>").
                        arg(addMe.readableShortName()).arg(name), QMessageBox::Close, qApp->activeWindow());
                connect(d, SIGNAL(rejected()), d, SLOT(deleteLater()));
                d->show();
            }
            else if (trashOriginal && addMe.type == AddData::FILENAME)
            {
                QFile original(addMe.filename);
                original.setPermissions(QFile::ReadOwner | QFile::WriteOwner);
                original.remove();
            }
        });

    q->run();
}

void Session::addTorrent(AddData const& addMe)
{
    tr_variant args;
    tr_variantInitDict(&args, 3);

    addTorrent(addMe, &args, myPrefs.getBool(Prefs::TRASH_ORIGINAL));
}

void Session::addNewlyCreatedTorrent(QString const& filename, QString const& localPath)
{
    QByteArray const b64 = AddData(filename).toBase64();

    tr_variant args;
    tr_variantInitDict(&args, 3);
    tr_variantDictAddStr(&args, TR_KEY_download_dir, localPath.toUtf8().constData());
    tr_variantDictAddBool(&args, TR_KEY_paused, !myPrefs.getBool(Prefs::START));
    tr_variantDictAddRaw(&args, TR_KEY_metainfo, b64.constData(), b64.size());

    exec("torrent-add", &args);
}

void Session::removeTorrents(QSet<int> const& ids, bool deleteFiles)
{
    if (!ids.isEmpty())
    {
        tr_variant args;
        tr_variantInitDict(&args, 2);
        addOptionalIds(&args, ids);
        tr_variantDictAddInt(&args, TR_KEY_delete_local_data, deleteFiles);

        exec("torrent-remove", &args);
    }
}

void Session::verifyTorrents(QSet<int> const& ids)
{
    if (!ids.isEmpty())
    {
        tr_variant args;
        tr_variantInitDict(&args, 1);
        addOptionalIds(&args, ids);

        exec("torrent-verify", &args);
    }
}

void Session::reannounceTorrents(QSet<int> const& ids)
{
    if (!ids.isEmpty())
    {
        tr_variant args;
        tr_variantInitDict(&args, 1);
        addOptionalIds(&args, ids);

        exec("torrent-reannounce", &args);
    }
}

/***
****
***/

void Session::launchWebInterface()
{
    QUrl url;

    if (mySession == nullptr) // remote session
    {
        url = myRpc.url();
        url.setPath(QLatin1String("/transmission/web/"));
    }
    else // local session
    {
        url.setScheme(QLatin1String("http"));
        url.setHost(QLatin1String("localhost"));
        url.setPort(myPrefs.getInt(Prefs::RPC_PORT));
    }

    QDesktopServices::openUrl(url);
}