// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2019 Luxoft Sweden AB
// Copyright (C) 2018 Pelagicore AG
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include <qplatformdefs.h>

#include "application.h"
#include "abstractcontainer.h"


/*!
    \qmltype Container
    \inqmlmodule QtApplicationManager.SystemUI
    \ingroup system-ui-non-instantiable
    \brief The handle for a container, that an application's \l Runtime is using.

    Instances of this class are available to the System UI via an application's \l Runtime object,
    while an application is running. Please see the \l{Containers}{Container documentation} for
    an in-depth description of containers within the application manager.

    \note Applications running in single-process mode (even ones using the \c qml-inprocess runtime
          while the application manager is running in multi-process mode) will have no Container
          object associated.
*/
/*!
    \qmlproperty string Container::controlGroup

    This property lets you get and set which control group the application's container will be in.

    If you are using cgroups \b v1, then the control group name handled by this property is \b not
    the low-level name used by the operating system, but an abstraction. See the
    \l{control group mapping}{container documentation} for more details on how to setup this mapping.

    Starting with release 6.8.3 of the application manager, cgroups \b v2 are supported as well. In
    this case, the control group name is the low-level cgroup name (or path in \c{/sys/fs/cgroup})
    used by the operating system, without any mappings.

    \note Control groups are only supported on Linux through the kernel's \c cgroup system in the
          built-in \c process container. Custom container plugins might not implement the necessary
          interface.
*/
/*!
    \qmlproperty bool Container::hasDebugWrapper
    \readonly
    \since 6.8

    Returns \c true, if the runtime in this container is executing with a debug wrapper and \c
    false otherwise.

    \sa Debugging
*/


QT_BEGIN_NAMESPACE_AM

AbstractContainer::~AbstractContainer()
{ }

/*!
    \qmlproperty string Container::containerId
    \readonly
    \since 6.10

    This property returns the \c id of the container that is executing the application. The \c id
    is a unique identifier for the container integration and can be used to reference it in other
    parts of the System UI or in configuration files.
*/
QString AbstractContainer::containerId() const
{
    return m_manager->identifier();
}

QString AbstractContainer::controlGroup() const
{
    return QString();
}

bool AbstractContainer::setControlGroup(const QString &groupName)
{
    Q_UNUSED(groupName)
    return false;
}

bool AbstractContainer::setProgram(const QString &program)
{
    if (!m_program.isEmpty())
        return false;
    m_program = program;
    return true;
}

void AbstractContainer::setBaseDirectory(const QString &baseDirectory)
{
    m_baseDirectory = baseDirectory;
}

QString AbstractContainer::mapContainerPathToHost(const QString &containerPath) const
{
    return containerPath;
}

QString AbstractContainer::mapHostPathToContainer(const QString &hostPath) const
{
    return hostPath;
}

AbstractContainerProcess *AbstractContainer::process() const
{
    return m_process;
}

void AbstractContainer::setApplication(Application *app)
{
    if (app != m_app) {
        m_app = app;
        emit applicationChanged(app);
    }
}

Application *AbstractContainer::application() const
{
    return m_app;
}

AbstractContainer::AbstractContainer(AbstractContainerManager *manager, Application *app)
    : QObject(manager)
    , m_manager(manager)
    , m_app(app)
{ }

QVariantMap AbstractContainer::configuration() const
{
    if (m_manager)
        return m_manager->configuration();
    return QVariantMap();
}



AbstractContainerManager::AbstractContainerManager(const QString &id, QObject *parent)
    : QObject(parent)
    , m_id(id)
{ }

QString AbstractContainerManager::defaultIdentifier()
{
    return QString();
}

QString AbstractContainerManager::identifier() const
{
    return m_id;
}

bool AbstractContainerManager::supportsQuickLaunch() const
{
    return false;
}

QVariantMap AbstractContainerManager::configuration() const
{
    return m_configuration;
}

void AbstractContainerManager::setConfiguration(const QVariantMap &configuration)
{
    m_configuration = configuration;
}

QT_END_NAMESPACE_AM

#include "moc_abstractcontainer.cpp"