#include "overlaycontroller.h"
#include <QApplication>
#include <QQmlApplicationEngine>
#include <QQuickView>
#include <QQmlEngine>
#include <QQmlComponent>
#include <QSettings>
#include <QStandardPaths>
#include <openvr.h>
#include <iostream>
#include "logging.h"

INITIALIZE_EASYLOGGINGPP

void myQtMessageHandler( QtMsgType type,
                         const QMessageLogContext& context,
                         const QString& msg )
{
    QByteArray localMsg = msg.toLocal8Bit();
    switch ( type )
    {
    case QtDebugMsg:
        LOG( DEBUG ) << localMsg.constData() << " (" << context.file << ":"
                     << context.line << ")";
        break;
    case QtInfoMsg:
        LOG( INFO ) << localMsg.constData() << " (" << context.file << ":"
                    << context.line << ")";
        break;
    case QtWarningMsg:
        LOG( WARNING ) << localMsg.constData() << " (" << context.file << ":"
                       << context.line << ")";
        break;
    case QtCriticalMsg:
        LOG( ERROR ) << localMsg.constData() << " (" << context.file << ":"
                     << context.line << ")";
        break;
    case QtFatalMsg:
        LOG( FATAL ) << localMsg.constData() << " (" << context.file << ":"
                     << context.line << ")";
        break;
    }
}

void installManifest( bool cleaninstall = false )
{
    auto manifestQPath
        = QDir::cleanPath( QDir( QCoreApplication::applicationDirPath() )
                               .absoluteFilePath( "manifest.vrmanifest" ) );
    if ( QFile::exists( manifestQPath ) )
    {
        bool alreadyInstalled = false;
        if ( vr::VRApplications()->IsApplicationInstalled(
                 advsettings::OverlayController::applicationKey ) )
        {
            if ( cleaninstall )
            {
                char buffer[1024];
                auto appError = vr::VRApplicationError_None;
                vr::VRApplications()->GetApplicationPropertyString(
                    advsettings::OverlayController::applicationKey,
                    vr::VRApplicationProperty_WorkingDirectory_String,
                    buffer,
                    1024,
                    &appError );
                if ( appError == vr::VRApplicationError_None )
                {
                    auto oldManifestQPath
                        = QDir::cleanPath( QDir( buffer ).absoluteFilePath(
                            "manifest.vrmanifest" ) );
                    if ( oldManifestQPath.compare( manifestQPath,
                                                   Qt::CaseInsensitive )
                         != 0 )
                    {
                        vr::VRApplications()->RemoveApplicationManifest(
                            QDir::toNativeSeparators( oldManifestQPath )
                                .toStdString()
                                .c_str() );
                    }
                    else
                    {
                        alreadyInstalled = true;
                    }
                }
            }
            else
            {
                alreadyInstalled = true;
            }
        }
        auto apperror = vr::VRApplications()->AddApplicationManifest(
            QDir::toNativeSeparators( manifestQPath ).toStdString().c_str() );
        if ( apperror != vr::VRApplicationError_None )
        {
            throw std::runtime_error(
                std::string( "Could not add application manifest: " )
                + std::string(
                      vr::VRApplications()->GetApplicationsErrorNameFromEnum(
                          apperror ) ) );
        }
        else if ( !alreadyInstalled || cleaninstall )
        {
            auto app_error = vr::VRApplications()->SetApplicationAutoLaunch(
                advsettings::OverlayController::applicationKey, true );
            if ( app_error != vr::VRApplicationError_None )
            {
                throw std::runtime_error(
                    std::string( "Could not set auto start: " )
                    + std::string( vr::VRApplications()
                                       ->GetApplicationsErrorNameFromEnum(
                                           apperror ) ) );
            }
        }
    }
    else
    {
        throw std::runtime_error(
            std::string( "Could not find application manifest: " )
            + manifestQPath.toStdString() );
    }
}

void removeManifest()
{
    auto manifestQPath
        = QDir::cleanPath( QDir( QCoreApplication::applicationDirPath() )
                               .absoluteFilePath( "manifest.vrmanifest" ) );
    if ( QFile::exists( manifestQPath ) )
    {
        if ( vr::VRApplications()->IsApplicationInstalled(
                 advsettings::OverlayController::applicationKey ) )
        {
            vr::VRApplications()->RemoveApplicationManifest(
                QDir::toNativeSeparators( manifestQPath )
                    .toStdString()
                    .c_str() );
        }
    }
    else
    {
        throw std::runtime_error(
            std::string( "Could not find application manifest: " )
            + manifestQPath.toStdString() );
    }
}

class MyQApplication : public QApplication
{
public:
    using QApplication::QApplication;

    virtual bool notify( QObject* receiver, QEvent* event ) override
    {
        try
        {
            return QApplication::notify( receiver, event );
        }
        catch ( std::exception& e )
        {
            LOG( ERROR ) << "Exception thrown from an event handler: "
                         << e.what();
        }
        return false;
    }
};

namespace argument
{
// Checks whether a specific string was passed as a launch argument.
bool CheckCommandLineArgument( int argc,
                               char* argv[],
                               const std::string parameter )
{
    // The old way was one giant loop that tested every single parameter.
    // Having an individual loop for all args most likely has a very small
    // performance penalty compared to the original solution, but the gains in
    // readability and ease of extension of not having a hundred line+ for loop
    // are worth it.
    for ( int i = 0; i < argc; i++ )
    {
        if ( std::string( argv[i] ) == parameter )
        {
            return true;
        }
    }
    return false;
}

constexpr auto DESKTOP_MODE = "-desktop";
constexpr auto NO_SOUND = "-nosound";
constexpr auto NO_MANIFEST = "-nomanifest";
constexpr auto INSTALL_MANIFEST = "-installmanifest";
constexpr auto REMOVE_MANIFEST = "-removemanifest";
} // namespace argument

enum ReturnErrorCode
{
    SUCCESS = 0,
    GENERAL_FAILURE = -1,
    OPENVR_INIT_ERROR = -2,
};

int main( int argc, char* argv[] )
{
    const char* logConfigFileName = "logging.conf";

    const char* logConfigDefault
        = "* GLOBAL:\n"
          "	FORMAT = \"[%level] %datetime{%Y-%M-%d %H:%m:%s}: %msg\"\n"
          "	FILENAME = \"AdvancedSettings.log\"\n"
          "	ENABLED = true\n"
          "	TO_FILE = true\n"
          "	TO_STANDARD_OUTPUT = true\n"
          "	MAX_LOG_FILE_SIZE = 2097152 ## 2MB\n"
          "* TRACE:\n"
          "	ENABLED = false\n"
          "* DEBUG:\n"
          "	ENABLED = false\n";

    const bool desktop_mode = argument::CheckCommandLineArgument(
        argc, argv, argument::DESKTOP_MODE );
    const bool no_sound
        = argument::CheckCommandLineArgument( argc, argv, argument::NO_SOUND );
    const bool no_manifest = argument::CheckCommandLineArgument(
        argc, argv, argument::NO_MANIFEST );
    const bool install_manifest = argument::CheckCommandLineArgument(
        argc, argv, argument::INSTALL_MANIFEST );
    const bool remove_manifest = argument::CheckCommandLineArgument(
        argc, argv, argument::REMOVE_MANIFEST );

    if ( install_manifest || remove_manifest )
    {
        int exit_code = ReturnErrorCode::SUCCESS;
        QCoreApplication coreApp( argc, argv );
        auto openvr_init_status = vr::VRInitError_None;
        vr::VR_Init( &openvr_init_status, vr::VRApplication_Utility );

        if ( openvr_init_status == vr::VRInitError_None )
        {
            try
            {
                if ( install_manifest )
                {
                    installManifest( true );
                }
                else if ( remove_manifest )
                {
                    removeManifest();
                }
            }
            catch ( std::exception& e )
            {
                exit_code = ReturnErrorCode::GENERAL_FAILURE;
                std::cerr << e.what() << std::endl;
            }
        }
        else
        {
            exit_code = ReturnErrorCode::OPENVR_INIT_ERROR;
            std::cerr << std::string(
                             "Failed to initialize OpenVR: "
                             + std::string(
                                   vr::VR_GetVRInitErrorAsEnglishDescription(
                                       openvr_init_status ) ) )
                      << std::endl;
        }

        vr::VR_Shutdown();
        exit( exit_code );
    }

    try
    {
        MyQApplication a( argc, argv );
        a.setOrganizationName( "matzman666" );
        a.setApplicationName( "OpenVRAdvancedSettings" );
        a.setApplicationDisplayName(
            advsettings::OverlayController::applicationName );
        a.setApplicationVersion(
            advsettings::OverlayController::applicationVersionString );

        qInstallMessageHandler( myQtMessageHandler );

        // Configure logger
        QString logFilePath;
        START_EASYLOGGINGPP( argc, argv );
        el::Loggers::addFlag(
            el::LoggingFlag::DisableApplicationAbortOnFatalLog );
        auto logconfigfile = QFileInfo( logConfigFileName ).absoluteFilePath();
        el::Configurations conf;
        if ( QFile::exists( logconfigfile ) )
        {
            conf.parseFromFile( logconfigfile.toStdString() );
        }
        else
        {
            conf.parseFromText( logConfigDefault );
        }
        if ( !conf.get( el::Level::Global, el::ConfigurationType::Filename ) )
        {
            logFilePath = QDir( QStandardPaths::writableLocation(
                                    QStandardPaths::AppDataLocation ) )
                              .absoluteFilePath( "AdvancedSettings.log" );
            conf.set( el::Level::Global,
                      el::ConfigurationType::Filename,
                      QDir::toNativeSeparators( logFilePath ).toStdString() );
        }
        conf.setRemainingToDefault();
        el::Loggers::reconfigureAllLoggers( conf );
        LOG( INFO ) << "Application started (Version "
                    << advsettings::OverlayController::applicationVersionString
                    << ")";
        LOG( INFO ) << "Log Config: "
                    << QDir::toNativeSeparators( logconfigfile ).toStdString();
        if ( !logFilePath.isEmpty() )
        {
            LOG( INFO ) << "Log File: " << logFilePath;
        }

        if ( desktop_mode )
        {
            LOG( INFO ) << "Desktop mode enabled.";
        }
        if ( no_sound )
        {
            LOG( INFO ) << "Sound effects disabled.";
        }
        if ( no_manifest )
        {
            LOG( INFO ) << "vrmanifest disabled.";
        }

        QSettings appSettings( QSettings::IniFormat,
                               QSettings::UserScope,
                               a.organizationName(),
                               a.applicationName() );
        advsettings::OverlayController::setAppSettings( &appSettings );
        LOG( INFO ) << "Settings File: "
                    << appSettings.fileName().toStdString();

        QQmlEngine qmlEngine;

        advsettings::OverlayController* controller
            = advsettings::OverlayController::createInstance( desktop_mode,
                                                              no_sound );
        controller->Init( &qmlEngine );

        QQmlComponent component(
            &qmlEngine, QUrl::fromLocalFile( "res/qml/mainwidget.qml" ) );
        auto errors = component.errors();
        for ( auto& e : errors )
        {
            LOG( ERROR ) << "QML Error: " << e.toString().toStdString()
                         << std::endl;
        }
        auto quickObj = component.create();
        controller->SetWidget( qobject_cast<QQuickItem*>( quickObj ),
                               advsettings::OverlayController::applicationName,
                               advsettings::OverlayController::applicationKey );

        if ( !desktop_mode && !no_manifest )
        {
            try
            {
                installManifest();
            }
            catch ( std::exception& e )
            {
                LOG( ERROR ) << e.what();
            }
        }

        if ( desktop_mode )
        {
            auto m_pWindow = new QQuickWindow();
            qobject_cast<QQuickItem*>( quickObj )
                ->setParentItem( m_pWindow->contentItem() );
            m_pWindow->setGeometry(
                0,
                0,
                qobject_cast<QQuickItem*>( quickObj )->width(),
                qobject_cast<QQuickItem*>( quickObj )->height() );
            m_pWindow->show();
        }

        return a.exec();
    }
    catch ( const std::exception& e )
    {
        LOG( FATAL ) << e.what();
        return ReturnErrorCode::GENERAL_FAILURE;
    }
}