/*
 * This file Copyright (C) Mnemosyne LLC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 *
 * $Id$
 */

#include <cassert>
#include <iostream>

#include <QApplication>
#include <QByteArray>
#include <QClipboard>
#include <QCoreApplication>
#include <QDesktopServices>
#include <QMessageBox>
#include <QNetworkProxy>
#include <QNetworkProxyFactory>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QSet>
#include <QStringList>
#include <QStyle>
#include <QTextStream>

#include <curl/curl.h>

#include <event2/buffer.h>

#include <libtransmission/transmission.h>
#include <libtransmission/rpcimpl.h>
#include <libtransmission/utils.h> // tr_free
#include <libtransmission/variant.h>
#include <libtransmission/version.h> // LONG_VERSION
#include <libtransmission/web.h>

#include "add-data.h"
#include "prefs.h"
#include "session.h"
#include "session-dialog.h"
#include "torrent.h"
#include "utils.h"

// #define DEBUG_HTTP

namespace
{
    enum
    {
        TAG_SOME_TORRENTS,
        TAG_ALL_TORRENTS,
        TAG_SESSION_STATS,
        TAG_SESSION_INFO,
        TAG_BLOCKLIST_UPDATE,
        TAG_ADD_TORRENT,
        TAG_PORT_TEST,
        TAG_MAGNET_LINK,
        TAG_RENAME_PATH,

        FIRST_UNIQUE_TAG
    };
}

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

namespace
{
  typedef Torrent::KeyList KeyList;
  const KeyList& getInfoKeys() { return Torrent::getInfoKeys(); }
  const KeyList& getStatKeys() { return Torrent::getStatKeys(); }
  const KeyList& getExtraStatKeys() { return Torrent::getExtraStatKeys(); }

  void
  addList (tr_variant * list, const KeyList& keys)
  {
    tr_variantListReserve (list, keys.size());
    foreach (tr_quark key, keys)
      tr_variantListAddQuark (list, key);
  }
}

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

void
Session :: sessionSet( const tr_quark key, const QVariant& value )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddStr( &top, TR_KEY_method, "session-set" );
    tr_variant * args( tr_variantDictAddDict( &top, TR_KEY_arguments, 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( "unknown type" );
    }
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: portTest( )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddStr( &top, TR_KEY_method, "port-test" );
    tr_variantDictAddInt( &top, TR_KEY_tag, TAG_PORT_TEST );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: copyMagnetLinkToClipboard( int torrentId )
{
    tr_variant top;
    tr_variantInitDict( &top, 3 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_get );
    tr_variantDictAddInt( &top, TR_KEY_tag, TAG_MAGNET_LINK );
    tr_variant * args = tr_variantDictAddDict( &top, TR_KEY_arguments, 2 );
    tr_variantListAddInt( tr_variantDictAddList( args, TR_KEY_ids, 1 ), torrentId );
    tr_variantListAddStr( tr_variantDictAddList( args, TR_KEY_fields, 1 ), "magnetLink" );

    exec( &top );
    tr_variantFree( &top );
}

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:
            {
                const int i = myPrefs.variant(key).toInt();
                switch( i )
                {
                    case 0:
                        sessionSet( myPrefs.getKey(key), "tolerated" );
                        break;
                    case 1:
                        sessionSet( myPrefs.getKey(key), "preferred" );
                        break;
                    case 2:
                        sessionSet( myPrefs.getKey(key), "required" );
                        break;
                }
                break;
            }

        case Prefs :: RPC_AUTH_REQUIRED:
            if( mySession )
                tr_sessionSetRPCPasswordEnabled( mySession, myPrefs.getBool(key) );
            break;
        case Prefs :: RPC_ENABLED:
            if( mySession )
                tr_sessionSetRPCEnabled( mySession, myPrefs.getBool(key) );
            break;
        case Prefs :: RPC_PASSWORD:
            if( mySession )
                tr_sessionSetRPCPassword( mySession, myPrefs.getString(key).toUtf8().constData() );
            break;
        case Prefs :: RPC_PORT:
            if( mySession )
                tr_sessionSetRPCPort( mySession, myPrefs.getInt(key) );
            break;
        case Prefs :: RPC_USERNAME:
            if( mySession )
                tr_sessionSetRPCUsername( mySession, myPrefs.getString(key).toUtf8().constData() );
            break;
        case Prefs :: RPC_WHITELIST_ENABLED:
            if( mySession )
                tr_sessionSetRPCWhitelistEnabled( mySession, myPrefs.getBool(key) );
            break;
        case Prefs :: RPC_WHITELIST:
            if( mySession )
                tr_sessionSetRPCWhitelist( mySession, myPrefs.getString(key).toUtf8().constData() );
            break;

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

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

Session :: Session( const char * configDir, Prefs& prefs ):
    nextUniqueTag( FIRST_UNIQUE_TAG ),
    myBlocklistSize( -1 ),
    myPrefs( prefs ),
    mySession( 0 ),
    myConfigDir( QString::fromUtf8( configDir ) ),
    myNAM( 0 ),
    myDownloadDirFreeSpace( -1 )
{
    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 (this, SIGNAL(responseReceived(const QByteArray&)),
             this, SLOT(onResponseReceived(const QByteArray&)));
}

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

QNetworkAccessManager *
Session :: networkAccessManager( )
{
    if( myNAM == 0 )
    {
        myNAM = new QNetworkAccessManager;

        connect( myNAM, SIGNAL(finished(QNetworkReply*)),
                 this, SLOT(onFinished(QNetworkReply*)) );

        connect( myNAM, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)),
                 this, SIGNAL(httpAuthenticationRequired()) );
    }

    return myNAM;
}

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

void
Session :: stop( )
{
    if( myNAM != 0 )
    {
        myNAM->deleteLater( );
        myNAM = 0;
    }

    myUrl.clear( );

    if( mySession )
    {
        tr_sessionClose( mySession );
        mySession = 0;
    }
}

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

void
Session :: start( )
{
    if( myPrefs.get<bool>(Prefs::SESSION_IS_REMOTE) )
    {
        QUrl url;
        url.setScheme( "http" );
        url.setHost( myPrefs.get<QString>(Prefs::SESSION_REMOTE_HOST) );
        url.setPort( myPrefs.get<int>(Prefs::SESSION_REMOTE_PORT) );
        url.setPath( "/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) );
        }
        myUrl = url;
    }
    else
    {
        tr_variant settings;
        tr_variantInitDict( &settings, 0 );
        tr_sessionLoadSettings( &settings, myConfigDir.toUtf8().constData(), "qt" );
        mySession = tr_sessionInit( "qt", myConfigDir.toUtf8().constData(), true, &settings );
        tr_variantFree( &settings );

        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 != 0;
}

bool
Session :: isLocal( ) const
{
    if( mySession != 0 )
        return true;

    if( myUrl.host() == "127.0.0.1" )
        return true;

    if( !myUrl.host().compare( "localhost", Qt::CaseInsensitive ) )
        return true;

    return false;
}

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

namespace
{
  tr_variant *
  buildRequest (const char * method, tr_variant& top, int tag=-1)
  {
    tr_variantInitDict (&top, 3);
    tr_variantDictAddStr (&top, TR_KEY_method, method);

    if (tag >= 0)
      tr_variantDictAddInt (&top, TR_KEY_tag, tag);

    return tr_variantDictAddDict (&top, TR_KEY_arguments, 0);
  }

  void
  addOptionalIds( tr_variant * args, const QSet<int>& ids )
  {
    if (!ids.isEmpty())
      {
        tr_variant * idList (tr_variantDictAddList (args, TR_KEY_ids, ids.size()));
        foreach (int i, ids)
          tr_variantListAddInt (idList, i);
      }
  }
}

void
Session :: torrentSet( const QSet<int>& ids, const tr_quark key, double value )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_set );
    tr_variant * args = tr_variantDictAddDict( &top, TR_KEY_arguments, 2 );
    tr_variantDictAddReal( args, key, value );
    addOptionalIds( args, ids );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: torrentSet( const QSet<int>& ids, const tr_quark key, int value )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_set );
    tr_variant * args = tr_variantDictAddDict( &top, TR_KEY_arguments, 2 );
    tr_variantDictAddInt( args, key, value );
    addOptionalIds( args, ids );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: torrentSet( const QSet<int>& ids, const tr_quark key, bool value )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_set );
    tr_variant * args = tr_variantDictAddDict( &top, TR_KEY_arguments, 2 );
    tr_variantDictAddBool( args, key, value );
    addOptionalIds( args, ids );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: torrentSet( const QSet<int>& ids, const tr_quark key, const QStringList& value )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_set );
    tr_variant * args = tr_variantDictAddDict( &top, TR_KEY_arguments, 2 );
    addOptionalIds( args, ids );
    tr_variant * list( tr_variantDictAddList( args, key, value.size( ) ) );
    foreach( const QString str, value )
        tr_variantListAddStr( list, str.toUtf8().constData() );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: torrentSet( const QSet<int>& ids, const tr_quark key, const QList<int>& value )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_set );
    tr_variant * args( tr_variantDictAddDict( &top, TR_KEY_arguments, 2 ) );
    addOptionalIds( args, ids );
    tr_variant * list( tr_variantDictAddList( args, key, value.size( ) ) );
    foreach( int i, value )
        tr_variantListAddInt( list, i );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: torrentSet( const QSet<int>& ids, const tr_quark key, const QPair<int,QString>& value )
{
  tr_variant top;
  tr_variantInitDict (&top, 2);
  tr_variantDictAddQuark (&top, TR_KEY_method, TR_KEY_torrent_set);
  tr_variant * args (tr_variantDictAddDict (&top, TR_KEY_arguments, 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 (&top);
  tr_variantFree (&top);
}

void
Session :: torrentSetLocation( const QSet<int>& ids, const QString& location, bool doMove)
{
  tr_variant top;
  tr_variantInitDict (&top, 2);
  tr_variantDictAddQuark (&top, TR_KEY_method, TR_KEY_torrent_set_location);
  tr_variant * args (tr_variantDictAddDict(&top, TR_KEY_arguments, 3));
  addOptionalIds (args, ids);
  tr_variantDictAddStr (args, TR_KEY_location, location.toUtf8().constData());
  tr_variantDictAddBool (args, TR_KEY_move, doMove);
  exec (&top);
  tr_variantFree (&top);
}

void
Session :: torrentRenamePath (const QSet<int>& ids, const QString& oldpath, const QString& newname)
{
  tr_variant top;
  tr_variantInitDict (&top, 2);
  tr_variantDictAddStr (&top, TR_KEY_method, "torrent-rename-path");
  tr_variantDictAddInt (&top, TR_KEY_tag, TAG_RENAME_PATH);
  tr_variant * args (tr_variantDictAddDict(&top, TR_KEY_arguments, 3));
  addOptionalIds (args, ids);
  tr_variantDictAddStr (args, TR_KEY_path, oldpath.toUtf8().constData());
  tr_variantDictAddStr (args, TR_KEY_name, newname.toUtf8().constData());
  exec (&top);
  tr_variantFree (&top);
}

void
Session :: refreshTorrents( const QSet<int>& ids )
{
    if( ids.empty( ) )
    {
        refreshAllTorrents( );
    }
    else
    {
        tr_variant top;
        tr_variantInitDict( &top, 3 );
        tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_get );
        tr_variantDictAddInt( &top, TR_KEY_tag, TAG_SOME_TORRENTS );
        tr_variant * args( tr_variantDictAddDict( &top, TR_KEY_arguments, 2 ) );
        addList( tr_variantDictAddList( args, TR_KEY_fields, 0 ), getStatKeys( ) );
        addOptionalIds( args, ids );
        exec( &top );
        tr_variantFree( &top );
    }
}

void
Session :: refreshExtraStats( const QSet<int>& ids )
{
    tr_variant top;
    tr_variantInitDict( &top, 3 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_get );
    tr_variantDictAddInt( &top, TR_KEY_tag, TAG_SOME_TORRENTS );
    tr_variant * args( tr_variantDictAddDict( &top, TR_KEY_arguments, 2 ) );
    addOptionalIds( args, ids );
    addList( tr_variantDictAddList( args, TR_KEY_fields, 0 ), getStatKeys( ) + getExtraStatKeys( ));
    exec( &top );
    tr_variantFree( &top );
}

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

  tr_variant * args (buildRequest (request, top));
  addOptionalIds (args, ids);
  exec (&top);
  tr_variantFree (&top);

  refreshTorrents (ids);
}

void Session :: pauseTorrents    (const QSet<int>& ids) { sendTorrentRequest ("torrent-stop",        ids); }
void Session :: startTorrents    (const QSet<int>& ids) { sendTorrentRequest ("torrent-start",       ids); } 
void Session :: startTorrentsNow (const QSet<int>& ids) { sendTorrentRequest ("torrent-start-now",   ids); }
void Session :: queueMoveTop     (const QSet<int>& ids) { sendTorrentRequest ("torrent-move-top",    ids); } 
void Session :: queueMoveUp      (const QSet<int>& ids) { sendTorrentRequest ("torrent-move-up",     ids); } 
void Session :: queueMoveDown    (const QSet<int>& ids) { sendTorrentRequest ("torrent-move-down",   ids); } 
void Session :: queueMoveBottom  (const QSet<int>& ids) { sendTorrentRequest ("torrent-move-bottom", ids); } 

void
Session :: refreshActiveTorrents( )
{
    tr_variant top;
    tr_variantInitDict( &top, 3 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_get );
    tr_variantDictAddInt( &top, TR_KEY_tag, TAG_SOME_TORRENTS );
    tr_variant * args( tr_variantDictAddDict( &top, TR_KEY_arguments, 2 ) );
    tr_variantDictAddStr( args, TR_KEY_ids, "recently-active" );
    addList( tr_variantDictAddList( args, TR_KEY_fields, 0 ), getStatKeys( ) );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: refreshAllTorrents( )
{
    tr_variant top;
    tr_variantInitDict( &top, 3 );
    tr_variantDictAddQuark( &top, TR_KEY_method, TR_KEY_torrent_get );
    tr_variantDictAddInt( &top, TR_KEY_tag, TAG_ALL_TORRENTS );
    tr_variant * args( tr_variantDictAddDict( &top, TR_KEY_arguments, 1 ) );
    addList( tr_variantDictAddList( args, TR_KEY_fields, 0 ), getStatKeys( ) );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: initTorrents( const QSet<int>& ids )
{
    tr_variant top;
    const int tag( ids.isEmpty() ? TAG_ALL_TORRENTS : TAG_SOME_TORRENTS );
    tr_variant * args( buildRequest( "torrent-get", top, tag ) );
    addOptionalIds( args, ids );
    addList( tr_variantDictAddList( args, TR_KEY_fields, 0 ), getStatKeys()+getInfoKeys() );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: refreshSessionStats( )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddStr( &top, TR_KEY_method, "session-stats" );
    tr_variantDictAddInt( &top, TR_KEY_tag, TAG_SESSION_STATS );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: refreshSessionInfo( )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddStr( &top, TR_KEY_method, "session-get" );
    tr_variantDictAddInt( &top, TR_KEY_tag, TAG_SESSION_INFO );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: updateBlocklist( )
{
    tr_variant top;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddStr( &top, TR_KEY_method, "blocklist-update" );
    tr_variantDictAddInt( &top, TR_KEY_tag, TAG_BLOCKLIST_UPDATE );
    exec( &top );
    tr_variantFree( &top );
}

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

void
Session :: exec( const tr_variant * request )
{
    char * str = tr_variantToStr( request, TR_VARIANT_FMT_JSON_LEAN, NULL );
    exec( str );
    tr_free( str );
}

void
Session :: localSessionCallback( tr_session * s, struct evbuffer * json, void * vself )
{
  Q_UNUSED (s);

  Session * self = static_cast<Session*>(vself);

  /* this callback is invoked in the libtransmission thread, so we don't want
     to process the response here... let's push it over to the Qt thread. */
  self->responseReceived (QByteArray ((const char *)evbuffer_pullup (json, -1),
                                      (int)evbuffer_get_length (json)));
}

#define REQUEST_DATA_PROPERTY_KEY "requestData"

void
Session :: exec( const char * json )
{
    if( mySession  )
    {
        tr_rpc_request_exec_json( mySession, json, strlen( json ), localSessionCallback, this );
    }
    else if( !myUrl.isEmpty( ) )
    {
        QNetworkRequest request;
        request.setUrl( myUrl );
        request.setRawHeader( "User-Agent", QString( QCoreApplication::instance()->applicationName() + "/" + LONG_VERSION_STRING ).toAscii() );
        request.setRawHeader( "Content-Type", "application/json; charset=UTF-8" );
        if( !mySessionId.isEmpty( ) )
            request.setRawHeader( TR_RPC_SESSION_ID_HEADER, mySessionId.toAscii() );

        const QByteArray requestData( json );
        QNetworkReply * reply = networkAccessManager()->post( request, requestData );
        reply->setProperty( REQUEST_DATA_PROPERTY_KEY, requestData );
        connect( reply, SIGNAL(downloadProgress(qint64,qint64)), this, SIGNAL(dataReadProgress()));
        connect( reply, SIGNAL(uploadProgress(qint64,qint64)), this, SIGNAL(dataSendProgress()));

#ifdef DEBUG_HTTP
        std::cerr << "sending " << "POST " << qPrintable( myUrl.path() ) << std::endl;
        foreach( QByteArray b, request.rawHeaderList() )
            std::cerr << b.constData()
                      << ": "
                      << request.rawHeader( b ).constData()
                      << std::endl;
        std::cerr << "Body:\n" << json << std::endl;
#endif
    }
}

void
Session :: onFinished( QNetworkReply * reply )
{
#ifdef DEBUG_HTTP
    std::cerr << "http response header: " << std::endl;
    foreach( QByteArray b, reply->rawHeaderList() )
        std::cerr << b.constData()
                  << ": "
                  << reply->rawHeader( b ).constData()
                  << std::endl;
    std::cerr << "json:\n" << reply->peek( reply->bytesAvailable() ).constData() << std::endl;
#endif

    if( ( reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ).toInt() == 409 )
        && ( reply->hasRawHeader( TR_RPC_SESSION_ID_HEADER ) ) )
    {
        // we got a 409 telling us our session id has expired.
        // update it and resubmit the request.
        mySessionId = QString( reply->rawHeader( TR_RPC_SESSION_ID_HEADER ) );
        exec( reply->property( REQUEST_DATA_PROPERTY_KEY ).toByteArray( ).constData( ) );
    }
    else if( reply->error() != QNetworkReply::NoError )
    {
        std::cerr << "http error: " << qPrintable( reply->errorString() ) << std::endl;
    }
    else
    {
        const QByteArray response( reply->readAll() );
        const char * json( response.constData( ) );
        int jsonLength( response.size( ) );
        if( jsonLength>0 && json[jsonLength-1] == '\n' ) --jsonLength;
        parseResponse( json, jsonLength );
    }

    reply->deleteLater();
}

void
Session :: onResponseReceived (const QByteArray& utf8)
{
  parseResponse (utf8.constData(), utf8.length());
}

void
Session :: parseResponse( const char * json, size_t jsonLength )
{
    tr_variant top;
    const int err (tr_variantFromJson (&top, json, jsonLength));
    if( !err )
    {
        int64_t tag = -1;
        const char * result = NULL;
        tr_variant * args = NULL;

        tr_variantDictFindInt ( &top, TR_KEY_tag, &tag );
        tr_variantDictFindStr ( &top, TR_KEY_result, &result, NULL );
        tr_variantDictFindDict( &top, TR_KEY_arguments, &args );

        emit executed( tag, result, args );

        tr_variant * torrents;
        const char * str;

        if( tr_variantDictFindInt( &top, TR_KEY_tag, &tag ) )
        {
            switch( tag )
            {
                case TAG_SOME_TORRENTS:
                case TAG_ALL_TORRENTS:
                    if( tr_variantDictFindDict( &top, TR_KEY_arguments, &args ) ) {
                        if( tr_variantDictFindList( args, TR_KEY_torrents, &torrents ) )
                            emit torrentsUpdated( torrents, tag==TAG_ALL_TORRENTS );
                        if( tr_variantDictFindList( args, TR_KEY_removed, &torrents ) )
                            emit torrentsRemoved( torrents );
                    }
                    break;

                case TAG_SESSION_STATS:
                    if( tr_variantDictFindDict( &top, TR_KEY_arguments, &args ) )
                        updateStats( args );
                    break;

                case TAG_SESSION_INFO:
                    if( tr_variantDictFindDict( &top, TR_KEY_arguments, &args ) )
                        updateInfo( args );
                    break;

                case TAG_BLOCKLIST_UPDATE: {
                    int64_t intVal = 0;
                    if( tr_variantDictFindDict( &top, TR_KEY_arguments, &args ) )
                        if( tr_variantDictFindInt( args, TR_KEY_blocklist_size, &intVal ) )
                            setBlocklistSize( intVal );
                    break;
                }

                case TAG_RENAME_PATH:
                  {
                    int64_t id = 0;
                    const char * result = 0;
                    if( tr_variantDictFindStr (&top, TR_KEY_result, &result, 0) && strcmp (result, "success") )
                      {
                        const char * path = "";
                        const char * name = "";
                        tr_variantDictFindStr (args, TR_KEY_path, &path, 0);
                        tr_variantDictFindStr (args, TR_KEY_name, &name, 0);
                        const QString title = tr("Error Renaming Path");
                        const QString text = tr("<p><b>Unable to rename \"%1\" as \"%2\": %3.</b></p> <p>Please correct the errors and try again.</p>").arg(path).arg(name).arg(result);
                        QMessageBox * d = new QMessageBox( QMessageBox::Information, title, text,
                                                           QMessageBox::Close,
                                                           QApplication::activeWindow());
                        connect( d, SIGNAL(rejected()), d, SLOT(deleteLater()) );
                        d->show( );
                      }
                    else if (tr_variantDictFindInt (args, TR_KEY_id, &id) && id)
                      {
                        // let's get the updated file list
                        char * req = tr_strdup_printf ("{ \"arguments\": { \"fields\": [ \"fileStats\", \"files\", \"id\", \"name\" ], \"ids\": %d }, \"method\": \"torrent-get\", \"tag\": %d }",
                                                       int(id),
                                                       int(TAG_SOME_TORRENTS));
                        exec (req);
                        tr_free (req);
                      }

                    break;
                }

                case TAG_PORT_TEST: {
                    bool isOpen = 0;
                    if( tr_variantDictFindDict( &top, TR_KEY_arguments, &args ) )
                        tr_variantDictFindBool( args, TR_KEY_port_is_open, &isOpen );
                    emit portTested( (bool)isOpen );
                    break;
                }

                case TAG_MAGNET_LINK: {
                    tr_variant * args;
                    tr_variant * torrents;
                    tr_variant * child;
                    const char * str;
                    if( tr_variantDictFindDict( &top, TR_KEY_arguments, &args )
                        && tr_variantDictFindList( args, TR_KEY_torrents, &torrents )
                        && (( child = tr_variantListChild( torrents, 0 )))
                        && tr_variantDictFindStr( child, TR_KEY_magnetLink, &str, NULL ) )
                            QApplication::clipboard()->setText( str );
                    break;
                }

                case TAG_ADD_TORRENT:
                    str = "";
                    if( tr_variantDictFindStr( &top, TR_KEY_result, &str, NULL ) && strcmp( str, "success" ) ) {
                        QMessageBox * d = new QMessageBox( QMessageBox::Information,
                                                           tr( "Add Torrent" ),
                                                           QString::fromUtf8(str),
                                                           QMessageBox::Close,
                                                           QApplication::activeWindow());
                        connect( d, SIGNAL(rejected()), d, SLOT(deleteLater()) );
                        d->show( );
                    }
                    break;

                default:
                    break;
            }
        }
        tr_variantFree( &top );
    }
}

void
Session :: updateStats( tr_variant * d, struct 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;
  const char * str;

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

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

      if (!b)
        continue;

      if (i == Prefs :: ENCRYPTION)
        {
          const char * val;
          if( tr_variantGetStr( b, &val, NULL ) )
            {
              if( !qstrcmp( val , "required" ) )
                myPrefs.set( i, 2 );
              else if( !qstrcmp( val , "preferred" ) )
                myPrefs.set( i, 1 );
              else if( !qstrcmp( val , "tolerated" ) )
                myPrefs.set( i, 0 );
            }
          continue;
        }

        switch( myPrefs.type( i ) )
        {
            case QVariant :: Int: {
                int64_t val;
                if( tr_variantGetInt( b, &val ) )
                    myPrefs.set( i, (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, (bool)val );
                break;
            }
            case TrTypes :: FilterModeType:
            case TrTypes :: SortModeType:
            case QVariant :: String: {
                const char * val;
                if( tr_variantGetStr( b, &val, NULL ) )
                    myPrefs.set( i, QString(val) );
                break;
            }
            default:
                break;
        }
    }

    bool b;
    double x;
    if( tr_variantDictFindBool( d, TR_KEY_seedRatioLimited, &b ) )
        myPrefs.set( Prefs::RATIO_ENABLED, b ? true : false );
    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 != 0 )
    {
        myPrefs.set( Prefs::RPC_ENABLED,           tr_sessionIsRPCEnabled           ( mySession ) );
        myPrefs.set( Prefs::RPC_AUTH_REQUIRED,     tr_sessionIsRPCPasswordEnabled   ( mySession ) );
        myPrefs.set( Prefs::RPC_PASSWORD,          tr_sessionGetRPCPassword         ( mySession ) );
        myPrefs.set( Prefs::RPC_PORT,              tr_sessionGetRPCPort             ( mySession ) );
        myPrefs.set( Prefs::RPC_USERNAME,          tr_sessionGetRPCUsername         ( mySession ) );
        myPrefs.set( Prefs::RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled ( mySession ) );
        myPrefs.set( Prefs::RPC_WHITELIST,         tr_sessionGetRPCWhitelist        ( mySession ) );
    }

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

    if( tr_variantDictFindStr( d, TR_KEY_version, &str, NULL ) && ( mySessionVersion != str ) )
        mySessionVersion = str;

    if( tr_variantDictFindInt( d, TR_KEY_download_dir_free_space, &i ) && ( myDownloadDirFreeSpace != i ) )
        myDownloadDirFreeSpace = i;

    //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( const AddData& addMe )
{
    const QByteArray b64 = addMe.toBase64();

    tr_variant top, *args;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddStr( &top, TR_KEY_method, "torrent-add" );
    args = tr_variantDictAddDict( &top, TR_KEY_arguments, 2 );
    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: tr_variantDictAddRaw( args, TR_KEY_metainfo, b64.constData(), b64.size() ); break;
        default: std::cerr << "Unhandled AddData type: " << addMe.type << std::endl;
    }
    exec( &top );
    tr_variantFree( &top );
}

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

    tr_variant top, *args;
    tr_variantInitDict( &top, 2 );
    tr_variantDictAddStr( &top, TR_KEY_method, "torrent-add" );
    args = tr_variantDictAddDict( &top, TR_KEY_arguments, 3 );
    tr_variantDictAddStr( args, TR_KEY_download_dir, localPathUtf8.constData() );
    tr_variantDictAddBool( args, TR_KEY_paused, !myPrefs.getBool( Prefs::START ) );
    tr_variantDictAddRaw( args, TR_KEY_metainfo, b64.constData(), b64.size() );
    exec( &top );
    tr_variantFree( &top );
}

void
Session :: removeTorrents( const QSet<int>& ids, bool deleteFiles )
{
    if( !ids.isEmpty( ) )
    {
        tr_variant top, *args;
        tr_variantInitDict( &top, 2 );
        tr_variantDictAddStr( &top, TR_KEY_method, "torrent-remove" );
        args = tr_variantDictAddDict( &top, TR_KEY_arguments, 2 );
        addOptionalIds( args, ids );
        tr_variantDictAddInt( args, TR_KEY_delete_local_data, deleteFiles );
        exec( &top );
        tr_variantFree( &top );
    }
}

void
Session :: verifyTorrents( const QSet<int>& ids )
{
    if( !ids.isEmpty( ) )
    {
        tr_variant top, *args;
        tr_variantInitDict( &top, 2 );
        tr_variantDictAddStr( &top, TR_KEY_method, "torrent-verify" );
        args = tr_variantDictAddDict( &top, TR_KEY_arguments, 1 );
        addOptionalIds( args, ids );
        exec( &top );
        tr_variantFree( &top );
    }
}

void
Session :: reannounceTorrents( const QSet<int>& ids )
{
    if( !ids.isEmpty( ) )
    {
        tr_variant top, *args;
        tr_variantInitDict( &top, 2 );
        tr_variantDictAddStr( &top, TR_KEY_method, "torrent-reannounce" );
        args = tr_variantDictAddDict( &top, TR_KEY_arguments, 1 );
        addOptionalIds( args, ids );
        exec( &top );
        tr_variantFree( &top );
    }
}

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

void
Session :: launchWebInterface( )
{
    QUrl url;
    if( !mySession ) // remote session
    {
        url = myUrl;
        url.setPath( "/transmission/web/" );
    }
    else // local session
    {
        url.setScheme( "http" );
        url.setHost( "localhost" );
        url.setPort( myPrefs.getInt( Prefs::RPC_PORT ) );
    }
    QDesktopServices :: openUrl( url );
}