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

#include <ctime>
#include <iostream>

#include <QIcon>
#include <QLibraryInfo>
#include <QMessageBox>
#include <QProcess>
#include <QRect>
#include <QSystemTrayIcon>

#ifdef QT_DBUS_LIB
#include <QDBusConnection>
#include <QDBusMessage>
#include <QDBusReply>
#endif

#include <libtransmission/transmission.h>
#include <libtransmission/tr-getopt.h>
#include <libtransmission/utils.h>
#include <libtransmission/version.h>

#include "AddData.h"
#include "Application.h"
#include "Formatter.h"
#include "InteropHelper.h"
#include "MainWindow.h"
#include "OptionsDialog.h"
#include "Prefs.h"
#include "Session.h"
#include "TorrentModel.h"
#include "WatchDir.h"

namespace
{

QLatin1String const MY_CONFIG_NAME("transmission");
QLatin1String const MY_READABLE_NAME("transmission-qt");

tr_option const opts[] =
{
    { 'g', "config-dir", "Where to look for configuration files", "g", true, "<path>" },
    { 'm', "minimized", "Start minimized in system tray", "m", false, nullptr },
    { 'p', "port", "Port to use when connecting to an existing session", "p", true, "<port>" },
    { 'r', "remote", "Connect to an existing session at the specified hostname", "r", true, "<host>" },
    { 'u', "username", "Username to use when connecting to an existing session", "u", true, "<username>" },
    { 'v', "version", "Show version number and exit", "v", false, nullptr },
    { 'w', "password", "Password to use when connecting to an existing session", "w", true, "<password>" },
    { 0, nullptr, nullptr, nullptr, false, nullptr }
};

char const* getUsage()
{
    return "Usage:\n"
        "  transmission [OPTIONS...] [torrent files]";
}

enum
{
    STATS_REFRESH_INTERVAL_MSEC = 3000,
    SESSION_REFRESH_INTERVAL_MSEC = 3000,
    MODEL_REFRESH_INTERVAL_MSEC = 3000
};

bool loadTranslation(QTranslator& translator, QString const& name, QLocale const& locale, QStringList const& searchDirectories)
{
    for (QString const& directory : searchDirectories)
    {
        if (translator.load(locale, name, QLatin1String("_"), directory))
        {
            return true;
        }
    }

    return false;
}

} // namespace

Application::Application(int& argc, char** argv) :
    QApplication(argc, argv),
    myPrefs(nullptr),
    mySession(nullptr),
    myModel(nullptr),
    myWindow(nullptr),
    myWatchDir(nullptr),
    myLastFullUpdateTime(0)
{
    setApplicationName(MY_CONFIG_NAME);
    loadTranslations();

    Formatter::initUnits();

#if defined(_WIN32) || defined(__APPLE__)

    if (QIcon::themeName().isEmpty())
    {
        QIcon::setThemeName(QLatin1String("Faenza"));
    }

#endif

    // set the default icon
    QIcon icon = QIcon::fromTheme(QLatin1String("transmission"));

    if (icon.isNull())
    {
        QList<int> sizes;
        sizes << 16 << 22 << 24 << 32 << 48 << 64 << 72 << 96 << 128 << 192 << 256;

        for (int const size : sizes)
        {
            icon.addPixmap(QPixmap(QString::fromLatin1(":/icons/transmission-%1.png").arg(size)));
        }
    }

    setWindowIcon(icon);

#ifdef __APPLE__
    setAttribute(Qt::AA_DontShowIconsInMenus);
#endif

    // parse the command-line arguments
    int c;
    bool minimized = false;
    char const* optarg;
    QString host;
    QString port;
    QString username;
    QString password;
    QString configDir;
    QStringList filenames;

    while ((c = tr_getopt(getUsage(), argc, const_cast<char const**>(argv), opts, &optarg)) != TR_OPT_DONE)
    {
        switch (c)
        {
        case 'g':
            configDir = QString::fromUtf8(optarg);
            break;

        case 'p':
            port = QString::fromUtf8(optarg);
            break;

        case 'r':
            host = QString::fromUtf8(optarg);
            break;

        case 'u':
            username = QString::fromUtf8(optarg);
            break;

        case 'w':
            password = QString::fromUtf8(optarg);
            break;

        case 'm':
            minimized = true;
            break;

        case 'v':
            std::cerr << MY_READABLE_NAME.latin1() << ' ' << LONG_VERSION_STRING << std::endl;
            quitLater();
            return;

        case TR_OPT_ERR:
            std::cerr << qPrintable(QObject::tr("Invalid option")) << std::endl;
            tr_getopt_usage(MY_READABLE_NAME.latin1(), getUsage(), opts);
            quitLater();
            return;

        default:
            filenames.append(QString::fromUtf8(optarg));
            break;
        }
    }

    // try to delegate the work to an existing copy of Transmission
    // before starting ourselves...
    InteropHelper interopClient;

    if (interopClient.isConnected())
    {
        bool delegated = false;

        for (QString const& filename : filenames)
        {
            QString metainfo;

            AddData a(filename);

            switch (a.type)
            {
            case AddData::URL:
                metainfo = a.url.toString();
                break;

            case AddData::MAGNET:
                metainfo = a.magnet;
                break;

            case AddData::FILENAME:
            case AddData::METAINFO:
                metainfo = QString::fromLatin1(a.toBase64());
                break;

            default:
                break;
            }

            if (!metainfo.isEmpty() && interopClient.addMetainfo(metainfo))
            {
                delegated = true;
            }
        }

        if (delegated)
        {
            quitLater();
            return;
        }
    }

    // set the fallback config dir
    if (configDir.isNull())
    {
        configDir = QString::fromUtf8(tr_getDefaultConfigDir("transmission"));
    }

    // ensure our config directory exists
    QDir dir(configDir);

    if (!dir.exists())
    {
        dir.mkpath(configDir);
    }

    // is this the first time we've run transmission?
    bool const firstTime = !dir.exists(QLatin1String("settings.json"));

    // initialize the prefs
    myPrefs = new Prefs(configDir);

    if (!host.isNull())
    {
        myPrefs->set(Prefs::SESSION_REMOTE_HOST, host);
    }

    if (!port.isNull())
    {
        myPrefs->set(Prefs::SESSION_REMOTE_PORT, port.toUInt());
    }

    if (!username.isNull())
    {
        myPrefs->set(Prefs::SESSION_REMOTE_USERNAME, username);
    }

    if (!password.isNull())
    {
        myPrefs->set(Prefs::SESSION_REMOTE_PASSWORD, password);
    }

    if (!host.isNull() || !port.isNull() || !username.isNull() || !password.isNull())
    {
        myPrefs->set(Prefs::SESSION_IS_REMOTE, true);
    }

    if (myPrefs->getBool(Prefs::START_MINIMIZED))
    {
        minimized = true;
    }

    // start as minimized only if the system tray present
    if (!myPrefs->getBool(Prefs::SHOW_TRAY_ICON))
    {
        minimized = false;
    }

    mySession = new Session(configDir, *myPrefs);
    myModel = new TorrentModel(*myPrefs);
    myWindow = new MainWindow(*mySession, *myPrefs, *myModel, minimized);
    myWatchDir = new WatchDir(*myModel);

    connect(myModel, &TorrentModel::torrentsAdded, this, &Application::onTorrentsAdded);
    connect(myModel, &TorrentModel::torrentsCompleted, this, &Application::onTorrentsCompleted);
    connect(myModel, &TorrentModel::torrentsNeedInfo, this, &Application::onTorrentsNeedInfo);
    connect(myPrefs, &Prefs::changed, this, &Application::refreshPref);
    connect(mySession, &Session::sourceChanged, this, &Application::onSessionSourceChanged);
    connect(mySession, &Session::torrentsRemoved, myModel, &TorrentModel::removeTorrents);
    connect(mySession, &Session::torrentsUpdated, myModel, &TorrentModel::updateTorrents);
    connect(myWatchDir, &WatchDir::torrentFileAdded, this, &Application::addTorrent);

    // init from preferences
    for (auto const key : { Prefs::DIR_WATCH })
    {
        refreshPref(key);
    }

    QTimer* timer = &myModelTimer;
    connect(timer, &QTimer::timeout, this, &Application::refreshTorrents);
    timer->setSingleShot(false);
    timer->setInterval(MODEL_REFRESH_INTERVAL_MSEC);
    timer->start();

    timer = &myStatsTimer;
    connect(timer, &QTimer::timeout, mySession, &Session::refreshSessionStats);
    timer->setSingleShot(false);
    timer->setInterval(STATS_REFRESH_INTERVAL_MSEC);
    timer->start();

    timer = &mySessionTimer;
    connect(timer, &QTimer::timeout, mySession, &Session::refreshSessionInfo);
    timer->setSingleShot(false);
    timer->setInterval(SESSION_REFRESH_INTERVAL_MSEC);
    timer->start();

    maybeUpdateBlocklist();

    if (!firstTime)
    {
        mySession->restart();
    }
    else
    {
        myWindow->openSession();
    }

    if (!myPrefs->getBool(Prefs::USER_HAS_GIVEN_INFORMED_CONSENT))
    {
        auto* dialog = new QMessageBox(QMessageBox::Information, QString(),
            tr("<b>Transmission is a file sharing program.</b>"), QMessageBox::Ok | QMessageBox::Cancel, myWindow);
        dialog->setInformativeText(tr("When you run a torrent, its data will be made available to others by means of upload. "
            "Any content you share is your sole responsibility."));
        dialog->button(QMessageBox::Ok)->setText(tr("I &Agree"));
        dialog->setDefaultButton(QMessageBox::Ok);
        dialog->setModal(true);

        connect(dialog, SIGNAL(finished(int)), this, SLOT(consentGiven(int)));

        dialog->setAttribute(Qt::WA_DeleteOnClose);
        dialog->show();
    }

    for (QString const& filename : filenames)
    {
        addTorrent(filename);
    }

    InteropHelper::registerObject(this);
}

void Application::loadTranslations()
{
    QStringList const qtQmDirs = QStringList() << QLibraryInfo::location(QLibraryInfo::TranslationsPath) <<
#ifdef TRANSLATIONS_DIR
        QString::fromUtf8(TRANSLATIONS_DIR) <<
#endif
        (applicationDirPath() + QLatin1String("/translations"));

    QStringList const appQmDirs = QStringList() <<
#ifdef TRANSLATIONS_DIR
        QString::fromUtf8(TRANSLATIONS_DIR) <<
#endif
        (applicationDirPath() + QLatin1String("/translations"));

    QString const qtFileName = QLatin1String("qtbase");

    QLocale const locale;
    QLocale const englishLocale(QLocale::English, QLocale::UnitedStates);

    if (loadTranslation(myQtTranslator, qtFileName, locale, qtQmDirs) ||
        loadTranslation(myQtTranslator, qtFileName, englishLocale, qtQmDirs))
    {
        installTranslator(&myQtTranslator);
    }

    if (loadTranslation(myAppTranslator, MY_CONFIG_NAME, locale, appQmDirs) ||
        loadTranslation(myAppTranslator, MY_CONFIG_NAME, englishLocale, appQmDirs))
    {
        installTranslator(&myAppTranslator);
    }
}

void Application::quitLater()
{
    QTimer::singleShot(0, this, SLOT(quit()));
}

void Application::onTorrentsEdited(torrent_ids_t const& ids)
{
    // the backend's tr_info has changed, so reload those fields
    mySession->initTorrents(ids);
}

QStringList Application::getNames(torrent_ids_t const& ids) const
{
    QStringList names;
    for (auto const& id : ids)
    {
        names.push_back(myModel->getTorrentFromId(id)->name());
    }

    names.sort();
    return names;
}

void Application::onTorrentsAdded(torrent_ids_t const& ids)
{
    if (myPrefs->getBool(Prefs::SHOW_NOTIFICATION_ON_ADD))
    {
        auto const title = tr("Torrent(s) Added", nullptr, ids.size());
        auto const body = getNames(ids).join(QStringLiteral("\n"));
        notifyApp(title, body);
    }
}

void Application::onTorrentsCompleted(torrent_ids_t const& ids)
{
    if (myPrefs->getBool(Prefs::SHOW_NOTIFICATION_ON_COMPLETE))
    {
        auto const title = tr("Torrent Completed", nullptr, ids.size());
        auto const body = getNames(ids).join(QStringLiteral("\n"));
        notifyApp(title, body);
    }

    if (myPrefs->getBool(Prefs::COMPLETE_SOUND_ENABLED))
    {
#if defined(Q_OS_WIN) || defined(Q_OS_MAC)
        beep();
#else
        QProcess::execute(myPrefs->getString(Prefs::COMPLETE_SOUND_COMMAND));
#endif
    }
}

void Application::onTorrentsNeedInfo(torrent_ids_t const& ids)
{
    if (!ids.empty())
    {
        mySession->initTorrents(ids);
    }
}

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

void Application::consentGiven(int result)
{
    if (result == QMessageBox::Ok)
    {
        myPrefs->set<bool>(Prefs::USER_HAS_GIVEN_INFORMED_CONSENT, true);
    }
    else
    {
        quit();
    }
}

Application::~Application()
{
    if (myPrefs != nullptr && myWindow != nullptr)
    {
        QRect const mainwinRect(myWindow->geometry());
        myPrefs->set(Prefs::MAIN_WINDOW_HEIGHT, std::max(100, mainwinRect.height()));
        myPrefs->set(Prefs::MAIN_WINDOW_WIDTH, std::max(100, mainwinRect.width()));
        myPrefs->set(Prefs::MAIN_WINDOW_X, mainwinRect.x());
        myPrefs->set(Prefs::MAIN_WINDOW_Y, mainwinRect.y());
    }

    delete myWatchDir;
    delete myWindow;
    delete myModel;
    delete mySession;
    delete myPrefs;
}

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

void Application::refreshPref(int key)
{
    switch (key)
    {
    case Prefs::BLOCKLIST_UPDATES_ENABLED:
        maybeUpdateBlocklist();
        break;

    case Prefs::DIR_WATCH:
    case Prefs::DIR_WATCH_ENABLED:
        {
            QString const path(myPrefs->getString(Prefs::DIR_WATCH));
            bool const isEnabled(myPrefs->getBool(Prefs::DIR_WATCH_ENABLED));
            myWatchDir->setPath(path, isEnabled);
            break;
        }

    default:
        break;
    }
}

void Application::maybeUpdateBlocklist()
{
    if (!myPrefs->getBool(Prefs::BLOCKLIST_UPDATES_ENABLED))
    {
        return;
    }

    QDateTime const lastUpdatedAt = myPrefs->getDateTime(Prefs::BLOCKLIST_DATE);
    QDateTime const nextUpdateAt = lastUpdatedAt.addDays(7);
    QDateTime const now = QDateTime::currentDateTime();

    if (now < nextUpdateAt)
    {
        mySession->updateBlocklist();
        myPrefs->set(Prefs::BLOCKLIST_DATE, now);
    }
}

void Application::onSessionSourceChanged()
{
    mySession->initTorrents();
    mySession->refreshSessionStats();
    mySession->refreshSessionInfo();
}

void Application::refreshTorrents()
{
    // usually we just poll the torrents that have shown recent activity,
    // but we also periodically ask for updates on the others to ensure
    // nothing's falling through the cracks.
    time_t const now = time(nullptr);

    if (myLastFullUpdateTime + 60 >= now)
    {
        mySession->refreshActiveTorrents();
    }
    else
    {
        myLastFullUpdateTime = now;
        mySession->refreshAllTorrents();
    }
}

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

void Application::addTorrent(AddData const& addme)
{
    if (addme.type == addme.NONE)
    {
        return;
    }

    if (!myPrefs->getBool(Prefs::OPTIONS_PROMPT))
    {
        mySession->addTorrent(addme);
    }
    else
    {
        auto* o = new OptionsDialog(*mySession, *myPrefs, addme, myWindow);
        o->show();
    }

    raise();
}

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

void Application::raise()
{
    alert(myWindow);
}

bool Application::notifyApp(QString const& title, QString const& body) const
{
#ifdef QT_DBUS_LIB

    QLatin1String const dbusServiceName("org.freedesktop.Notifications");
    QLatin1String const dbusInterfaceName("org.freedesktop.Notifications");
    QLatin1String const dbusPath("/org/freedesktop/Notifications");

    QDBusConnection bus = QDBusConnection::sessionBus();

    if (bus.isConnected())
    {
        QDBusMessage m = QDBusMessage::createMethodCall(dbusServiceName, dbusPath, dbusInterfaceName, QLatin1String("Notify"));
        QVariantList args;
        args.append(QLatin1String("Transmission")); // app_name
        args.append(0U); // replaces_id
        args.append(QLatin1String("transmission")); // icon
        args.append(title); // summary
        args.append(body); // body
        args.append(QStringList()); // actions - unused for plain passive popups
        args.append(QVariantMap()); // hints - unused atm
        args.append(static_cast<int32_t>(-1)); // use the default timeout period
        m.setArguments(args);
        QDBusReply<quint32> const replyMsg = bus.call(m);

        if (replyMsg.isValid() && replyMsg.value() > 0)
        {
            return true;
        }
    }

#endif

    myWindow->trayIcon().showMessage(title, body);
    return true;
}

FaviconCache& Application::faviconCache()
{
    return myFavicons;
}

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

int tr_main(int argc, char* argv[])
{
    InteropHelper::initialize();

#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
    Application::setAttribute(Qt::AA_EnableHighDpiScaling);
#endif

    Application::setAttribute(Qt::AA_UseHighDpiPixmaps);

    Application app(argc, argv);
    return app.exec();
}