#include <iostream>
#include <unistd.h>
#include <assert.h>
#include <QtCore>
#include <QtDBus/QtDBus>
#include <memory>
#include <sstream>

using namespace std;

const char *WPAS_DBUS_SERVICE = "fi.w1.wpa_supplicant1";

bool startsWith( const std::string &str, const std::string &prefix )
{
    return str.substr(0,prefix.size())==prefix;
}

// Throws exceptions on errors.
void checkResult( const QDBusMessage &result, const std::string &func, int expectedNumArgs )
{
    if (result.type() != QDBusMessage::ReplyMessage)
    {
        if ( startsWith( result.errorMessage().toStdString(), "The name fi.w1.wpa_supplicant1 was not provided by any .service files" ) )
        {
            throw "Error: "+result.errorMessage().toStdString();
        }
        throw "Error: wpa_supplicant DBus error in "+func+": " + result.errorMessage().toStdString();
    }
    if ( result.arguments().size() != 1 )
    {
        stringstream ss;
        ss << "Expected just one wifi interface, found "<<result.arguments().size();
        throw ss.str();
    }
}

// Translates network device to DBus object path (e.g. "wlan0" -> "/fi/w1/wpa_supplicant1/Interfaces/3")
std::string getNetDevObjectPath( const std::string &netDevInterfaceName, const QDBusConnection &systemBus )
{
    cout<<__func__ << "("<<netDevInterfaceName<<")" << endl;

    QDBusInterface interface( WPAS_DBUS_SERVICE,
                              "/fi/w1/wpa_supplicant1",
                              "fi.w1.wpa_supplicant1",
                              systemBus );
    if (!interface.isValid())
    {
        throw "interface not valid";
    }

    // Call GetInterface, which gives us the object path to the DBus proxy for the interface
    QDBusMessage result = interface.call( "GetInterface", netDevInterfaceName.c_str() );
    qDebug() << __func__ << ": GetInterface result: " << result;
    checkResult( result, __func__, 1 );
    QDBusObjectPath opath = result.arguments()[0].value<QDBusObjectPath>();
    return opath.path().toStdString();
}
// Returns a list of object-paths
std::vector<std::string> listNetDevInterfaces( QDBusConnection &systemBus )
{
    cout<<__func__ << "()" << endl;
    QDBusInterface interface( WPAS_DBUS_SERVICE,
                              "/fi/w1/wpa_supplicant1",
                              "org.freedesktop.DBus.Properties",
                              systemBus );
    QDBusMessage result = interface.call( "Get", "fi.w1.wpa_supplicant1", "Interfaces" );
    checkResult( result, __func__, 1 );
    const QVariant &var = result.arguments()[0].value<QDBusVariant>().variant();
    const QDBusArgument &dbArg = var.value<QDBusArgument>();
    std::vector<std::string> ret;
    dbArg.beginArray();
    while ( !dbArg.atEnd() )
    {
        QString item;
        dbArg >> item;
        ret.push_back( item.toStdString() );
    }
    dbArg.endArray();

    return ret;
}
void removeNetDevInterface( const std::string &objPath, QDBusConnection &systemBus )
{
    QDBusInterface interface( WPAS_DBUS_SERVICE,
                              "/fi/w1/wpa_supplicant1",
                              "fi.w1.wpa_supplicant1",
                              systemBus );
    QDBusObjectPath path( objPath.c_str() );
    QDBusMessage result = interface.call( "RemoveInterface", QVariant::fromValue<QDBusObjectPath>(path) );
    checkResult( result, __func__, 0 );
}
void clearNetDevInterfaces(QDBusConnection &systemBus)
{
    cout<<__func__ << "()" << endl;
    std::vector<std::string> objPaths = listNetDevInterfaces(systemBus);
    for ( auto &objPath : objPaths )
    {
        removeNetDevInterface( objPath, systemBus );
    }
}
// Returns the objectPath of the newly-created interface
std::string createNetDevInterface( const std::string &netDev, QDBusConnection &systemBus )
{
    cout<<__func__ << "()" << endl;
    QDBusInterface interface( WPAS_DBUS_SERVICE,
                              "/fi/w1/wpa_supplicant1",
                              "fi.w1.wpa_supplicant1",
                              systemBus );
    QMap<QString, QVariant> args;
    args["Ifname"] = netDev.c_str();
    args["Driver"] = "nl80211";
    QDBusMessage result = interface.call( "CreateInterface", args );
    //qDebug() << __func__ << ": result: " << result;
    checkResult( result, __func__, 1 );
    QDBusObjectPath opath = result.arguments()[0].value<QDBusObjectPath>();
    return opath.path().toStdString();
}

int signalPoll( QDBusInterface &netDevInterfaceInterface )
{
    QDBusMessage result = netDevInterfaceInterface.call( "SignalPoll" );
    //qDebug() << __func__ << ": 'SignalPoll' result: "<<result<<endl;
    if ( result.type() != QDBusMessage::ReplyMessage && result.errorMessage() == "Failed to read signal" )
        throw "Not connected";
    checkResult( result, __func__, 1 );

    // result is something like this:  QDBusMessage(type=MethodReturn, service=":1.15", signature="v", contents=([Variant: [Argument: a{sv} {"rssi" = [Variant(int): -44], "linkspeed" = [Variant(int): 1], "noise" = [Variant(int): 9999], "frequency" = [Variant(uint): 2437], "width" = [Variant(QString): "40 MHz"], "avg-rssi" = [Variant(int): -43]}]]) ) 

    const QVariant &var = result.arguments()[0].value<QDBusVariant>().variant();
    const QDBusArgument &dbArg = var.value<QDBusArgument>();
    
    // Iterate over it 
    int rssi;
    int numEntries = 0;
    dbArg.beginMap();
    while ( !dbArg.atEnd() )
    {
        QString key;
        QVariant value;
        dbArg.beginMapEntry();
        dbArg >> key;
        dbArg >> value;
        dbArg.endMapEntry();
        numEntries++;

        if ( key == "rssi" )
        {
            rssi = value.toInt();
            return rssi;
        }
    }
    throw "rssi not found";
}

const char *USAGE_ARGS = "[-i interface]";

int main( int argc, char **argv )
{
    std::string interface;
    for ( int i=1; i < argc; i++ )
    {
        if ( i<argc-1 && !strcmp(argv[i],"-i") )
            interface = argv[++i];
        else
        {
            cout << "USAGE: "<<argv[0]<<" "<<USAGE_ARGS<<endl;
            exit(1);
        }
    }
    if ( interface.empty() )
    {
        interface="wlan0";
    }

    QCoreApplication app(argc,argv);

    QDBusConnection systemBus_ = QDBusConnection::systemBus();
    assert( systemBus_.isConnected() );

    // Set up Interfaces
    std::string netDevInterfaceObjectPath_;
    try {
        netDevInterfaceObjectPath_ = getNetDevObjectPath(interface,systemBus_);
    }
    catch ( std::exception &e )
    {
        cout<<"TRACE(wpasupplicant.cpp): getNetDevObjectPath("<<interface<<"): " << e.what() << endl;
        cout<<"TRACE(wpasupplicant.cpp): Interface doesn't exist for "<<interface<<" -- clearing and creating." << endl;
        clearNetDevInterfaces(systemBus_);
        netDevInterfaceObjectPath_ = createNetDevInterface(interface,systemBus_);
    }

    std::auto_ptr<QDBusInterface> netDevInterfaceInterface_; // the DBus interface corresponding to the network interface.
    std::auto_ptr<QDBusInterface> netDevInterfaceProperties_; // the DBus interface corresponding to the 'Properties' of the network interface.
    netDevInterfaceInterface_.reset( new QDBusInterface( WPAS_DBUS_SERVICE,
                                                         netDevInterfaceObjectPath_.c_str(),
                                                         "fi.w1.wpa_supplicant1.Interface",
                                                         systemBus_ ) );
    netDevInterfaceProperties_.reset( new QDBusInterface( WPAS_DBUS_SERVICE,
                                                          netDevInterfaceObjectPath_.c_str(),
                                                          "org.freedesktop.DBus.Properties",
                                                          systemBus_ ) );
    


    QTime timer;
    timer.start();
    int i = 0;
    while ( true )
    {
        try {
            int a = timer.elapsed();
            int rssi = signalPoll( *netDevInterfaceInterface_ );
            int b = timer.elapsed();
            cout << i++ << " " << b << " " << (b-a) << " signalInfo rssi=" << rssi << endl;
        }
        catch ( std::exception &e )
        {
            cout << e.what() << endl;
        }
        catch ( char const *e )
        {
            cout << e << endl;
        }
        catch ( const std::string &e )
        {
            cout << e << endl;
        }
        //usleep(0.001 * 1e6);
    }
}