/*

 * dialer - MeeGo Voice Call Manager

 * Copyright (c) 2009, 2010, Intel Corporation.

 *

 * This program is licensed under the terms and conditions of the

 * Apache License, version 2.0.  The full text of the Apache License is at

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 */

#include "dialerapplication.h"

#include "common.h"

#include "dbustypes.h"

#include "dialercontext.h"

#include "dbusdialeradapter.h"

#include "pacontrol.h"

#include "dialer_adaptor.h"

#include <QDebug>

#include <QX11Info>

#include <QInputContext>

#include <QInputContextFactory>

#include <MNotification>

#include <iostream>

#define OFONO_VOICECALLMANAGER_INTERFACE "org.ofono.VoiceCallManager"

// pulls in X11 headers, so this *must* be last otherwise it might cause odd conflicts with Qt headers

#include "atoms.h"

void messageHandler(QtMsgType type, const char *msg)

{

    switch (type) {

    case QtDebugMsg:

        fprintf(stderr, "Debug: %s\n", msg);

        break;

    case QtWarningMsg:

        fprintf(stderr, "Warning: %s\n", msg);

        break;

    case QtCriticalMsg:

        fprintf(stderr, "Critical: %s\n", msg);

        break;

    case QtFatalMsg:

        fprintf(stderr, "Fatal: %s\n", msg);

        abort();

    }

}

DialerApplication::DialerApplication(int &argc, char **argv) :

    QApplication(argc, argv),

    orientation(1),

    foregroundWindow(0),

    mainWindow(NULL)

{

    TRACE

    setApplicationName("dialer");

    connect(&orientationSensor, SIGNAL(readingChanged()), SLOT(onOrientationChanged()));

    QString theme = MGConfItem("/meego/ux/theme").value().toString();

    QString themeFile = QString("/usr/share/themes/") + theme + "/theme.ini";

    if(!QFile::exists(themeFile))

    {

        // fallback

        themeFile = QString("/usr/share/themes/1024-600-10/theme.ini");

    }

    themeConfig = new QSettings(themeFile, QSettings::NativeFormat, this);

//    QInputContext *ic = QInputContextFactory::create("MInputContext", 0);

//    if(ic)

//        setInputContext(ic);

    qInstallMsgHandler(messageHandler);

    // Enable dynamic switching between gl and software rendering on systems

    // with graphics architectures that see a benifit in memory usage.

    MGConfItem *enableSwapItem = new MGConfItem("/meego/ux/EnableDynamicRendering");

    m_enableRenderingSwap = enableSwapItem->value().toBool();

    delete enableSwapItem;

    init();

    mainWindow = QMLMainWindow::instance();

}

void DialerApplication::connectAll()

{

    TRACE

    ManagerProxy *m_manager = ManagerProxy::instance();

    if (m_manager->modem() &&

        m_manager->modem()->isValid() &&

        !m_manager->modem()->path().isEmpty())

    {

        qDebug() << QString("Connecting to CallManager....");

        m_manager->setNetwork(m_manager->modem()->path());

        m_manager->setCallManager(m_manager->modem()->path());

        m_manager->setVolumeManager(m_manager->modem()->path());

        m_manager->setVoicemail(m_manager->modem()->path());

        connect(m_manager->network(), SIGNAL(connected()), this,

                                      SLOT(networkConnected()));

        connect(m_manager->network(), SIGNAL(disconnected()), this,

                                      SLOT(networkDisconnected()));

        connect(m_manager->callManager(), SIGNAL(connected()), this,

                                          SLOT(callManagerConnected()));

        connect(m_manager->callManager(), SIGNAL(disconnected()), this,

                                          SLOT(callManagerDisconnected()));

        connect(m_manager->callManager(), SIGNAL(callsChanged()), this,

                                          SLOT(onCallsChanged()));

        connect(m_manager->voicemail(), SIGNAL(messagesWaitingChanged()), this,

                                          SLOT(messagesWaitingChanged()));

        if (MODE_HFP_ENABLED)

        {

            PAControl* paControl = PAControl::instance();

            connect(m_manager->callManager(), SIGNAL(callsChanged()), paControl,

                                              SLOT(onCallsChanged()));

        }

    }

}

bool DialerApplication::isConnected()

{

    TRACE

    return m_connected;

}

bool DialerApplication::hasError() const

{

    TRACE

    return !m_lastError.isEmpty();

}

QString DialerApplication::lastError() const

{

    TRACE

    return m_lastError;

}

void DialerApplication::setError(const QString msg)

{

    TRACE

    m_lastError.clear();

    m_lastError = QString(msg);

}

DialerApplication *DialerApplication::instance()

{

    TRACE

    return qobject_cast<DialerApplication *>(QApplication::instance());

}

SeasideSyncModel *DialerApplication::seasideModel()

{

    TRACE

    return m_seasideModel;

}

SeasideProxyModel *DialerApplication::seasideProxy()

{

    TRACE

    return m_seasideProxy;

}

HistoryTableModel *DialerApplication::historyModel()

{

    TRACE

    return m_historyModel;

}

QSortFilterProxyModel *DialerApplication::historyProxy()

{

    TRACE

    return m_historyProxy;

}

void DialerApplication::init()

{

    TRACE

    m_connected = false;

    m_lastError = QString();

    // Notify Qt of our custom DBus MetaTypes

    registerMyDataTypes();

    m_manager = ManagerProxy::instance();

    if (!m_manager || !m_manager->isValid())

        //% "Failed to connect to org.ofono.Manager: is ofonod running?"

        setError(qtTrId("xx_no_ofono_error"));

    else

        m_connected = true;

    DBusDialerAdapter *adapter = new DBusDialerAdapter(this);

    if(!adapter)

    {

        qWarning() << "DBus adapter instantiation failed.";

    }

    if(!QDBusConnection::sessionBus().registerObject(DBUS_SERVICE_PATH, this))

    {

        qCritical() << "Error registering dbus object:" <<

                       QDBusConnection::sessionBus().lastError().message();

    }

    m_seasideModel = new SeasideSyncModel();

    m_seasideProxy = new SeasideProxyModel();

    m_seasideProxy->setSourceModel(m_seasideModel);

    m_seasideProxy->setDynamicSortFilter(true);

    m_seasideProxy->setFilterKeyColumn(-1);

    m_seasideProxy->setFilterRegExp(MATCH_ALL);

    m_seasideProxy->sort(Seaside::ColumnLastName, Qt::AscendingOrder);

    m_historyModel = new HistoryTableModel();

    m_historyProxy = new QSortFilterProxyModel();

    m_historyProxy->setSourceModel(m_historyModel);

    m_historyProxy->setDynamicSortFilter(true);

    m_historyProxy->setFilterKeyColumn(HistoryTableModel::COLUMN_LINEID);

    m_historyProxy->sort(HistoryTableModel::COLUMN_CALLSTART,

                         Qt::DescendingOrder);

    connect(m_manager->modem(), SIGNAL(connected()),

                                SLOT(modemConnected()));

    connect(m_manager->modem(), SIGNAL(disconnected()),

                                SLOT(modemDisconnected()));

}

void DialerApplication::modemConnected()

{

    TRACE

    //TODO: Handle multiple modems

    if (m_manager->modem() && m_manager->modem()->isValid())

    {

        m_modem = m_manager->modem();

        qDebug() << QString("Modem connected");

        connect(m_modem, SIGNAL(interfacesChanged(QStringList)), this,

                           SLOT(modemInterfacesChanged(QStringList)));

        connect(m_modem, SIGNAL(poweredChanged(bool)), this,

                           SLOT(modemPowered(bool)));

        if (m_modem->powered() &&

            m_modem->interfaces().contains(OFONO_VOICECALLMANAGER_INTERFACE))

        {

            /* connect all now, modem is enabled */

            qDebug() << QString("Modem is powered: ");

            this->connectAll();

        }

    }

}

void DialerApplication::modemDisconnected()

{

    TRACE

    //TODO: Handle multiple modems

}

void DialerApplication::modemInterfacesChanged(QStringList interfaces)

{

    TRACE

    qDebug() << QString("Modem Interfaces: ") << interfaces;

    if (interfaces.contains(OFONO_VOICECALLMANAGER_INTERFACE) &&

        m_manager->modem()->powered())

    {

        qDebug() << QString("Modem VoiceCallManager available, connect CallManager");

        this->connectAll();

    }

}

void DialerApplication::modemPowered(bool isPowered)

{

    TRACE

    qDebug() << QString("Modem Powered: ") << isPowered;

    if (isPowered &&

        m_manager->modem()->interfaces().contains(OFONO_VOICECALLMANAGER_INTERFACE))

    {

        qDebug() << QString("Modem powered up, connect CallManager");

        this->connectAll();

    }

}

void DialerApplication::networkConnected()

{

    TRACE

    if (m_manager->network() && m_manager->network()->isValid())

        m_network = m_manager->network();

}

void DialerApplication::networkDisconnected()

{

    TRACE

}

void DialerApplication::callManagerConnected()

{

    TRACE

    if (m_manager->callManager() && m_manager->callManager()->isValid())

        m_callManager = m_manager->callManager();

    qDebug() << QString("Disconnect calls changed signal");

    disconnect(m_callManager, SIGNAL(callsChanged()));

    qDebug() << QString("Disconnect incoming signal");

    disconnect(m_callManager, SIGNAL(incomingCall(CallItem*)));

    qDebug() << QString("Disconnect resource lost");

    disconnect(m_callManager, SIGNAL(callResourceLost(const QString)));

}

void DialerApplication::callManagerDisconnected()

{

    TRACE

    qDebug() << QString("CallMgr disconnected");

}

void DialerApplication::messagesWaitingChanged()

{

    TRACE

    static MNotification *vmail = NULL;

    if (!m_manager->voicemail() || !m_manager->voicemail()->isValid()) {

        qDebug() << QString("Voicemail proxy is invalid, ignoring");

        return;

    }

    if (!vmail) {

        bool found = false;

        foreach (MNotification *notice, MNotification::notifications()) {

            if (notice->eventType() == MNotification::MessageArrivedEvent) {

                // If we've already found a MessageArrived notification,

                // we must delete others since we only want one

                if (found) {

                    qDebug() << QString("Removing duplicate voicemail notice");

                    notice->remove();

                    delete notice;

                }

                else {

                    vmail = notice;

                    found = true;

                }

            }

            else {

                // We're only interested in MessageArrived events, all others

                // can need to be deleted here since they are copies

                delete notice;

            }

        }

        if (!found) {

            if (!m_manager->voicemail()->waiting()) {

                qDebug() << QString("No waiting Voicemail messages");

                return;

            }

            else {

                // This is the first instance of a MessageArrived event

                qDebug() << QString("Creating new voicemail notice instance");

                vmail = new MNotification(MNotification::MessageArrivedEvent);

                vmail->setCount(0);

            }

        }

        else {

            if (!m_manager->voicemail()->waiting()) {

                qDebug() << QString("No waiting Voicemail messages");

                vmail->remove();

                return;

            }

        }

    }

    // We've got a valid notification and we have messages waiting...

    int vCount = m_manager->voicemail()->count();

    int nCount = vmail->count();

    if (vCount < 0) vCount = 0;

    if (nCount < 0) nCount = 0;

    qDebug() << QString("Voicemails: %1").arg(QString::number(vCount));

    qDebug() << QString("Notices:    %1").arg(QString::number(nCount));

    // No more Voicemail messages waiting, remove notification

    if (vCount <= 0) {

        qDebug() << QString("No Voicemails waiting, removing notification");

        vmail->remove();

        return;

    }

    // The waiting voicemail count has changed, update and [re]publish it

    //% "You have %1 voice messages"

    vmail->setSummary(qtTrId("xx_messages_waiting").arg(vCount));

    vmail->setImage("icon-m-telephony-voicemail");

    vmail->setCount(vCount);

    qDebug() << QString("Voicemail count changed, publishing notification");

    vmail->publish();

}

void DialerApplication::onCallsChanged()

{

    TRACE

}

bool DialerApplication::x11EventFilter(XEvent *event)

{

    Display *dpy = QX11Info::display();

    Atom activeWindowAtom = getAtom(ATOM_NET_ACTIVE_WINDOW);

    // Foreground window detection

    if (event->type == PropertyNotify &&

            event->xproperty.atom == activeWindowAtom)

    {

        Atom actualType;

        int actualFormat;

        unsigned long numWindowItems, bytesLeft;

        unsigned char *data = NULL;

        int result = XGetWindowProperty(dpy,

                                        DefaultRootWindow(dpy),

                                        activeWindowAtom,

                                        0, 0x7fffffff,

                                        false, XA_WINDOW,

                                        &actualType,

                                        &actualFormat,

                                        &numWindowItems,

                                        &bytesLeft,

                                        &data);

        if (result == Success && data != None)

        {

            Window w = *(Window *)data;

            XFree(data);

            if (foregroundWindow != (int)w && !isSystemModelDialog(w))

            {

                foregroundWindow = (int)w;

                emit foregroundWindowChanged();

                if (m_enableRenderingSwap)

                {

                    if (mainWindow)

                    {

                        if (mainWindow->winId() == (int)w)

                        {

                            mainWindow->switchToGLRendering();

                        }

                        else

                        {

                            mainWindow->switchToSoftwareRendering();

                        }

                    }

                }

            }

        }

    }

    return QApplication::x11EventFilter(event);

}

void DialerApplication::setOrientationLocked(bool locked)

{

    orientationLocked = locked;

    setOrientationSensorOn(!locked);

}

// Copied from libmeegotouch, which we don't link against.  We need it

// defined so we can connect a signal to the MInputContext object

// (loaded from a plugin) that uses this type.

namespace M {

    enum OrientationAngle { Angle0=0, Angle90=90, Angle180=180, Angle270=270 };

}

void DialerApplication::onOrientationChanged()

{

    TRACE

    int orientation = orientationSensor.reading()->orientation();

    int qmlOrient = -1;

    M::OrientationAngle mtfOrient;

    switch (orientation)

    {

    case QOrientationReading::LeftUp:

        mtfOrient = M::Angle270;

        qmlOrient = 2;

        break;

    case QOrientationReading::TopDown:

        mtfOrient = M::Angle180;

        qmlOrient = 3;

        break;

    case QOrientationReading::RightUp:

        mtfOrient = M::Angle90;

        qmlOrient = 0;

        break;

    case QOrientationReading::TopUp:

        mtfOrient = M::Angle0;

        qmlOrient = 1;

        break;

    default:

        // ignore faceup and facedown events

        break;

    }

    if (qmlOrient == -1)

        return;

    setOrientation(qmlOrient);

    // Need to tell the MInputContext plugin to rotate the VKB too

//    QMetaObject::invokeMethod(inputContext(),

//                              "notifyOrientationChanged",

//                              Q_ARG(M::OrientationAngle, mtfOrient));

}

void DialerApplication::setOrientationSensorOn(bool value)

{

    if (value && !orientationSensor.isActive())

    {

        orientationSensor.start();

    }

    else if(!value && orientationSensor.isActive())

    {

        orientationSensor.stop();

    }

}

bool DialerApplication::isSystemModelDialog(unsigned target)

{

    Atom actualType;

    int actualFormat;

    unsigned long numWindowItems, bytesLeft;

    unsigned char *data = NULL;

    int result = XGetWindowProperty(QX11Info::display(),

                                    target,

                                    getAtom(ATOM_MEEGO_SYSTEM_DIALOG),

                                    0, 0x7fffffff,

                                    false, XA_WINDOW,

                                    &actualType,

                                    &actualFormat,

                                    &numWindowItems,

                                    &bytesLeft,

                                    &data);

    if (result == Success && data != None)

    {

        XFree(data);

        return true;

    }

    return false;

}