/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt Quick Dialogs module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qquickabstractdialog_p.h"
#include "qquickitem.h"

#include <private/qguiapplication_p.h>
#include <private/qqmlglobal_p.h>
#include <QLoggingCategory>
#include <QWindow>
#include <QQmlComponent>
#include <QQuickWindow>
#include <qpa/qplatformintegration.h>

QT_BEGIN_NAMESPACE

Q_LOGGING_CATEGORY(lcWindow, "qt.quick.dialogs.window")

QUrl QQuickAbstractDialog::m_decorationComponentUrl = QUrl();

QQuickAbstractDialog::QQuickAbstractDialog(QObject *parent)
    : QObject(parent)
    , m_parentWindow(0)
    , m_visible(false)
    , m_modality(Qt::WindowModal)
    , m_contentItem(0)
    , m_dialogWindow(0)
    , m_windowDecoration(0)
    , m_hasNativeWindows(QGuiApplicationPrivate::platformIntegration()->
        hasCapability(QPlatformIntegration::MultipleWindows) &&
        QGuiApplicationPrivate::platformIntegration()->
        hasCapability(QPlatformIntegration::WindowManagement))
    , m_hasAspiredPosition(false)
    , m_visibleChangedConnected(false)
    , m_dialogHelperInUse(false)
{
}

QQuickAbstractDialog::~QQuickAbstractDialog()
{
}

void QQuickAbstractDialog::setVisible(bool v)
{
    if (m_visible == v) return;
    m_visible = v;

    if (m_dialogHelperInUse || v) {
        // To show the dialog, we first check if there is a dialog helper that can be used
        // and that show succeeds given the current configuration. Otherwise we fall back
        // to use the pure QML version.
        if (QPlatformDialogHelper *dialogHelper = helper()) {
            if (v) {
                Qt::WindowFlags flags = Qt::Dialog;
                if (!title().isEmpty())
                    flags |= Qt::WindowTitleHint;
                if (dialogHelper->show(flags, m_modality, parentWindow())) {
                    qCDebug(lcWindow) << "Show dialog using helper:" << dialogHelper;
                    m_dialogHelperInUse = true;
                    emit visibilityChanged();
                    return;
                }
            } else {
                qCDebug(lcWindow) << "Hide dialog using helper:" << dialogHelper;
                dialogHelper->hide();
                emit visibilityChanged();
                return;
            }
        }
    }

    qCDebug(lcWindow) << "Show/hide dialog using pure QML";
    m_dialogHelperInUse = false;

    // Pure QML implementation: wrap the contentItem in a window, or fake it
    if (!m_dialogWindow && m_contentItem) {
        if (v)
            emit __maximumDimensionChanged();
        if (m_hasNativeWindows)
            m_dialogWindow = m_contentItem->window();
        // An Item-based dialog implementation doesn't come with a window, so
        // we have to instantiate one iff the platform allows it.
        if (!m_dialogWindow && m_hasNativeWindows) {
            QQuickWindow *win = new QQuickWindow;
            ((QObject *)win)->setParent(this); // memory management only
            win->setFlags(Qt::Dialog);
            m_dialogWindow = win;
            m_contentItem->setParentItem(win->contentItem());
            QSize minSize = QSize(m_contentItem->implicitWidth(), m_contentItem->implicitHeight());
            QVariant minHeight = m_contentItem->property("minimumHeight");
            if (minHeight.isValid()) {
                if (minHeight.toInt() > minSize.height())
                    minSize.setHeight(minHeight.toDouble());
                connect(m_contentItem, SIGNAL(minimumHeightChanged()), this, SLOT(minimumHeightChanged()));
            }
            QVariant minWidth = m_contentItem->property("minimumWidth");
            if (minWidth.isValid()) {
                if (minWidth.toInt() > minSize.width())
                    minSize.setWidth(minWidth.toInt());
                connect(m_contentItem, SIGNAL(minimumWidthChanged()), this, SLOT(minimumWidthChanged()));
            }
            m_dialogWindow->setMinimumSize(minSize);
            connect(win, SIGNAL(widthChanged(int)), this, SLOT(windowGeometryChanged()));
            connect(win, SIGNAL(heightChanged(int)), this, SLOT(windowGeometryChanged()));
            qCDebug(lcWindow) << "created window" << win << "with min size" << win->minimumSize() << "geometry" << win->geometry();
        }

        if (!m_dialogWindow) {
            if (Q_UNLIKELY(!parentWindow())) {
                qWarning("cannot set dialog visible: no window");
                return;
            }
            m_dialogWindow = parentWindow();

            // If the platform does not support multiple windows, but the dialog is
            // implemented as an Item, then try to decorate it as a fake window and make it visible.
            if (!m_windowDecoration) {
                if (!m_decorationComponent)
                    m_decorationComponent = new QQmlComponent(qmlEngine(this), m_decorationComponentUrl, QQmlComponent::Asynchronous, this);
                if (m_decorationComponent) {
                    if (m_decorationComponent->isLoading())
                        connect(m_decorationComponent, SIGNAL(statusChanged(QQmlComponent::Status)),
                                this, SLOT(decorationLoaded()));
                    else
                        decorationLoaded(); // do the reparenting of contentItem on top of it
                }
                // Window decoration wasn't possible, so just reparent it into the scene
                else {
                    qCDebug(lcWindow) << "no window and no decoration";
                    m_contentItem->setParentItem(parentWindow()->contentItem());
                    m_contentItem->setZ(10000);
                }
            }
        }
    }
    if (m_dialogWindow) {
        // "grow up" to the size and position expected to achieve
        if (!m_sizeAspiration.isNull()) {
            if (m_hasAspiredPosition) {
                qCDebug(lcWindow) << "geometry aspiration" << m_sizeAspiration;
                m_dialogWindow->setGeometry(m_sizeAspiration);
            } else {
                qCDebug(lcWindow) << "size aspiration" << m_sizeAspiration.size();
                if (m_sizeAspiration.width() > 0)
                    m_dialogWindow->setWidth(m_sizeAspiration.width());
                if (m_sizeAspiration.height() > 0)
                    m_dialogWindow->setHeight(m_sizeAspiration.height());
            }
            connect(m_dialogWindow, SIGNAL(xChanged(int)), this, SLOT(setX(int)));
            connect(m_dialogWindow, SIGNAL(yChanged(int)), this, SLOT(setY(int)));
            connect(m_dialogWindow, SIGNAL(widthChanged(int)), this, SLOT(setWidth(int)));
            connect(m_dialogWindow, SIGNAL(heightChanged(int)), this, SLOT(setHeight(int)));
            connect(m_contentItem, SIGNAL(implicitHeightChanged()), this, SLOT(implicitHeightChanged()));
        }
        if (!m_visibleChangedConnected) {
            connect(m_dialogWindow, &QQuickWindow::visibleChanged, this, &QQuickAbstractDialog::visibleChanged);
            m_visibleChangedConnected = true;
        }
    }
    if (m_windowDecoration) {
        setDecorationDismissBehavior();
        m_windowDecoration->setVisible(v);
    } else if (m_dialogWindow) {
        if (v) {
            m_dialogWindow->setTransientParent(parentWindow());
            m_dialogWindow->setTitle(title());
            m_dialogWindow->setModality(m_modality);
        }
        m_dialogWindow->setVisible(v);
    }

    emit visibilityChanged();
}

void QQuickAbstractDialog::decorationLoaded()
{
    bool ok = false;
    Q_ASSERT(parentWindow());
    QQuickItem *parentItem = parentWindow()->contentItem();
    Q_ASSERT(parentItem);
    if (m_decorationComponent->isError()) {
        qWarning() << m_decorationComponent->errors();
    } else {
        QObject *decoration = m_decorationComponent->create();
        m_windowDecoration = qobject_cast<QQuickItem *>(decoration);
        if (m_windowDecoration) {
            m_windowDecoration->setParentItem(parentItem);
            // Give the window decoration its content to manage
            QVariant contentVariant;
            contentVariant.setValue<QQuickItem*>(m_contentItem);
            m_windowDecoration->setProperty("content", contentVariant);
            setDecorationDismissBehavior();
            connect(m_windowDecoration, SIGNAL(dismissed()), this, SLOT(reject()));
            ok = true;
            qCDebug(lcWindow) << "using synthetic window decoration" << m_windowDecoration << "from" << m_decorationComponent->url();
        } else {
            qWarning() << m_decorationComponent->url() <<
                "cannot be used as a window decoration because it's not an Item";
            delete decoration;
            delete m_decorationComponent;
            m_decorationComponent = nullptr;
        }
    }
    // Window decoration wasn't possible, so just reparent it into the scene
    if (!ok) {
        m_contentItem->setParentItem(parentItem);
        m_contentItem->setZ(10000);
        qCDebug(lcWindow) << "no decoration";
    }
}

void QQuickAbstractDialog::setModality(Qt::WindowModality m)
{
    if (m_modality == m) return;
    qCDebug(lcWindow) << "modality" << m;
    m_modality = m;
    emit modalityChanged();
}

void QQuickAbstractDialog::accept()
{
    setVisible(false);
    emit accepted();
}

void QQuickAbstractDialog::reject()
{
    setVisible(false);
    emit rejected();
}

void QQuickAbstractDialog::visibleChanged(bool v)
{
    if (m_visible && !v) // closed by user
        emit rejected(); // treat as rejected
    m_visible = v;
    qCDebug(lcWindow) << "visible" << v;
    emit visibilityChanged();
}

void QQuickAbstractDialog::windowGeometryChanged()
{
    if (m_dialogWindow && m_contentItem) {
        qCDebug(lcWindow) << m_dialogWindow->geometry();
        m_contentItem->setWidth(m_dialogWindow->width());
        m_contentItem->setHeight(m_dialogWindow->height());
    }
}

void QQuickAbstractDialog::minimumWidthChanged()
{
    qreal min = m_contentItem->property("minimumWidth").toReal();
    qreal implicitOrMin = qMax(m_contentItem->implicitWidth(), min);
    qCDebug(lcWindow) << "content implicitWidth" << m_contentItem->implicitWidth() << "minimumWidth" << min;
    if (m_dialogWindow->width() < implicitOrMin)
        m_dialogWindow->setWidth(implicitOrMin);
    m_dialogWindow->setMinimumWidth(implicitOrMin);
}

void QQuickAbstractDialog::minimumHeightChanged()
{
    qreal min = m_contentItem->property("minimumHeight").toReal();
    qreal implicitOrMin = qMax(m_contentItem->implicitHeight(), min);
    qCDebug(lcWindow) << "content implicitHeight" << m_contentItem->implicitHeight() << "minimumHeight" << min;
    if (m_dialogWindow->height() < implicitOrMin)
        m_dialogWindow->setHeight(implicitOrMin);
    m_dialogWindow->setMinimumHeight(implicitOrMin);
}

void QQuickAbstractDialog::implicitHeightChanged()
{
    qCDebug(lcWindow) << "content implicitHeight" << m_contentItem->implicitHeight()
                      << "window minimumHeight" << m_dialogWindow->minimumHeight();
    if (m_contentItem->implicitHeight() < m_dialogWindow->minimumHeight())
        m_dialogWindow->setMinimumHeight(m_contentItem->implicitHeight());
}

QQuickWindow *QQuickAbstractDialog::parentWindow()
{
    if (!m_parentWindow) {
        // Usually a dialog is declared inside an Item; but if its QObject parent
        // is a Window, that's the window we are interested in. (QTBUG-38578)
        QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
        m_parentWindow = (parentItem ? parentItem->window() : qmlobject_cast<QQuickWindow *>(parent()));
    }
    return m_parentWindow;
}

void QQuickAbstractDialog::setDecorationDismissBehavior()
{
    m_windowDecoration->setProperty("dismissOnOuterClick", (m_modality == Qt::NonModal));
}

void QQuickAbstractDialog::setContentItem(QQuickItem *obj)
{
    m_contentItem = obj;
    qCDebug(lcWindow) << obj;
    if (m_dialogWindow) {
        disconnect(m_dialogWindow, &QQuickWindow::visibleChanged, this, &QQuickAbstractDialog::visibleChanged);
        // Can't necessarily delete because m_dialogWindow might have been provided by the QML.
        m_dialogWindow = 0;
    }
}

int QQuickAbstractDialog::x() const
{
    if (m_dialogWindow)
        return m_dialogWindow->x();
    return m_sizeAspiration.x();
}

int QQuickAbstractDialog::y() const
{
    if (m_dialogWindow)
        return m_dialogWindow->y();
    return m_sizeAspiration.y();
}

int QQuickAbstractDialog::width() const
{
    if (m_dialogWindow)
        return m_dialogWindow->width();
    return m_sizeAspiration.width();
}

int QQuickAbstractDialog::height() const
{
    if (m_dialogWindow)
        return m_dialogWindow->height();
    return m_sizeAspiration.height();
}

/*
    A non-fullscreen dialog is not allowed to be too large
    to fit on the screen in either orientation (portrait or landscape).
    That way on platforms which can do rotation, the dialog does not
    change its size when the screen is rotated.  So the value returned
    here is the maximum for both width and height.  We need to know
    at init time, not wait until the dialog's content item is shown in
    a window so that the desktopAvailableWidth and Height will be valid
    in the Screen attached property.  And to allow space for window borders,
    the max is further reduced by 10%.
*/
int QQuickAbstractDialog::__maximumDimension() const
{
    QScreen *screen = QGuiApplication::primaryScreen();
    qCDebug(lcWindow) << "__maximumDimension checking screen" << screen << "geometry" << screen->availableVirtualGeometry();
    return (screen ?
                qMin(screen->availableVirtualGeometry().width(), screen->availableVirtualGeometry().height()) :
                480) * 9 / 10;
}

void QQuickAbstractDialog::setX(int arg)
{
    m_hasAspiredPosition = true;
    m_sizeAspiration.moveLeft(arg);
    if (helper()) {
        // TODO
    } else if (m_dialogWindow) {
        if (sender() != m_dialogWindow)
            m_dialogWindow->setX(arg);
    } else if (m_contentItem) {
        m_contentItem->setX(arg);
    }
    qCDebug(lcWindow) << arg;
    emit geometryChanged();
}

void QQuickAbstractDialog::setY(int arg)
{
    m_hasAspiredPosition = true;
    m_sizeAspiration.moveTop(arg);
    if (helper()) {
        // TODO
    } else if (m_dialogWindow) {
        if (sender() != m_dialogWindow)
            m_dialogWindow->setY(arg);
    } else if (m_contentItem) {
        m_contentItem->setY(arg);
    }
    qCDebug(lcWindow) << arg;
    emit geometryChanged();
}

void QQuickAbstractDialog::setWidth(int arg)
{
    m_sizeAspiration.setWidth(arg);
    if (helper()) {
        // TODO
    } else if (m_dialogWindow) {
        if (sender() != m_dialogWindow)
            m_dialogWindow->setWidth(arg);
    } else if (m_contentItem) {
        m_contentItem->setWidth(arg);
    }
    qCDebug(lcWindow) << arg;
    emit geometryChanged();
}

void QQuickAbstractDialog::setHeight(int arg)
{
    m_sizeAspiration.setHeight(arg);
    if (helper()) {
        // TODO
    } else if (m_dialogWindow) {
        if (sender() != m_dialogWindow)
            m_dialogWindow->setHeight(arg);
    } else if (m_contentItem) {
        m_contentItem->setHeight(arg);
    }
    qCDebug(lcWindow) << arg;
    emit geometryChanged();
}

QT_END_NAMESPACE
