/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the plugins 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 "qwinrtwindow.h"
#include "qwinrtscreen.h"
#include <private/qeventdispatcher_winrt_p.h>

#include <EGL/egl.h>
#include <EGL/eglext.h>

#include <qfunctions_winrt.h>
#include <qpa/qplatformscreen.h>
#include <qpa/qwindowsysteminterface.h>
#include <QtGui/QGuiApplication>
#include <QtGui/QOpenGLContext>
#include <QtGui/QWindow>
#include <QtEglSupport/private/qeglconvenience_p.h>

#include <functional>
#include <wrl.h>
#include <windows.foundation.h>
#include <windows.foundation.collections.h>
#include <windows.ui.xaml.h>
#include <windows.ui.xaml.controls.h>
#include <windows.ui.viewmanagement.h>

using namespace ABI::Windows::UI::ViewManagement;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::Foundation::Collections;
using namespace ABI::Windows::UI;
using namespace ABI::Windows::UI::Xaml;
using namespace ABI::Windows::UI::Xaml::Controls;

QT_BEGIN_NAMESPACE

Q_LOGGING_CATEGORY(lcQpaWindows, "qt.qpa.windows");

static void setUIElementVisibility(IUIElement *uiElement, bool visibility)
{
    Q_ASSERT(uiElement);
    QEventDispatcherWinRT::runOnXamlThread([uiElement, visibility]() {
        HRESULT hr;
        hr = uiElement->put_Visibility(visibility ? Visibility_Visible : Visibility_Collapsed);
        Q_ASSERT_SUCCEEDED(hr);
        return S_OK;
    });
}

class QWinRTWindowPrivate
{
public:
    QWinRTScreen *screen;

    QSurfaceFormat surfaceFormat;
    QString windowTitle;
    Qt::WindowStates state;
    EGLDisplay display;
    EGLSurface surface;

    ComPtr<ISwapChainPanel> swapChainPanel;
    ComPtr<ICanvasStatics> canvas;
    ComPtr<IUIElement> uiElement;
};

QWinRTWindow::QWinRTWindow(QWindow *window)
    : QPlatformWindow(window)
    , d_ptr(new QWinRTWindowPrivate)
{
    Q_D(QWinRTWindow);
    qCDebug(lcQpaWindows) << __FUNCTION__ << this;

    d->surface = EGL_NO_SURFACE;
    d->display = EGL_NO_DISPLAY;
    d->screen = static_cast<QWinRTScreen *>(screen());
    handleContentOrientationChange(window->contentOrientation());

    d->surfaceFormat.setMajorVersion(3);
    d->surfaceFormat.setMinorVersion(0);
    d->surfaceFormat.setAlphaBufferSize(0);
    d->surfaceFormat.setRedBufferSize(8);
    d->surfaceFormat.setGreenBufferSize(8);
    d->surfaceFormat.setBlueBufferSize(8);
    d->surfaceFormat.setDepthBufferSize(24);
    d->surfaceFormat.setStencilBufferSize(8);
    d->surfaceFormat.setRenderableType(QSurfaceFormat::OpenGLES);
    d->surfaceFormat.setSamples(1);
    d->surfaceFormat.setSwapBehavior(QSurfaceFormat::DoubleBuffer);

    HRESULT hr;
    hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_UI_Xaml_Controls_Canvas).Get(),
                                IID_PPV_ARGS(&d->canvas));
    Q_ASSERT_SUCCEEDED(hr);
    hr = QEventDispatcherWinRT::runOnXamlThread([d]() {
        // Create a new swapchain and place it inside the canvas
        HRESULT hr;
        hr = RoActivateInstance(HString::MakeReference(RuntimeClass_Windows_UI_Xaml_Controls_SwapChainPanel).Get(),
                                &d->swapChainPanel);
        Q_ASSERT_SUCCEEDED(hr);
        hr = d->swapChainPanel.As(&d->uiElement);
        Q_ASSERT_SUCCEEDED(hr);

        ComPtr<Xaml::IFrameworkElement> frameworkElement;
        hr = d->swapChainPanel.As(&frameworkElement);
        Q_ASSERT_SUCCEEDED(hr);
        const QSizeF size = QSizeF(d->screen->geometry().size()) / d->screen->scaleFactor();
        hr = frameworkElement->put_Width(size.width());
        Q_ASSERT_SUCCEEDED(hr);
        hr = frameworkElement->put_Height(size.height());
        Q_ASSERT_SUCCEEDED(hr);

        ComPtr<IDependencyObject> canvas = d->screen->canvas();
        ComPtr<IPanel> panel;
        hr = canvas.As(&panel);
        Q_ASSERT_SUCCEEDED(hr);
        ComPtr<IVector<UIElement *>> children;
        hr = panel->get_Children(&children);
        Q_ASSERT_SUCCEEDED(hr);
        hr = children->Append(d->uiElement.Get());
        Q_ASSERT_SUCCEEDED(hr);
        return S_OK;
    });
    Q_ASSERT_SUCCEEDED(hr);

    setWindowFlags(window->flags());
    setWindowState(window->windowStates());
    setWindowTitle(window->title());

    setGeometry(window->geometry());
}

QWinRTWindow::~QWinRTWindow()
{
    Q_D(QWinRTWindow);
    qCDebug(lcQpaWindows) << __FUNCTION__ << this;

    HRESULT hr;
    hr = QEventDispatcherWinRT::runOnXamlThread([d]() {
        HRESULT hr;
        ComPtr<IDependencyObject> canvas = d->screen->canvas();
        ComPtr<IPanel> panel;
        hr = canvas.As(&panel);
        Q_ASSERT_SUCCEEDED(hr);
        ComPtr<IVector<UIElement *>> children;
        hr = panel->get_Children(&children);
        Q_ASSERT_SUCCEEDED(hr);
        quint32 index;
        boolean found;
        hr = children->IndexOf(d->uiElement.Get(), &index, &found);
        Q_ASSERT_SUCCEEDED(hr);
        if (found) {
            hr = children->RemoveAt(index);
            Q_ASSERT_SUCCEEDED(hr);
        }
        return S_OK;
    });
    RETURN_VOID_IF_FAILED("Failed to completely destroy window resources, likely because the application is shutting down");

    if (d->screen->mouseGrabWindow() == this)
        d->screen->setMouseGrabWindow(this, false);
    if (d->screen->keyboardGrabWindow() == this)
        d->screen->setKeyboardGrabWindow(this, false);

    d->screen->removeWindow(window());

    if (!d->surface)
        return;

    qCDebug(lcQpaWindows) << __FUNCTION__ << ": Destroying surface";

    EGLBoolean value = eglDestroySurface(d->display, d->surface);
    d->surface = EGL_NO_SURFACE;
    if (Q_UNLIKELY(value == EGL_FALSE))
        qCritical("Failed to destroy EGL window surface: 0x%x", eglGetError());
}

QSurfaceFormat QWinRTWindow::format() const
{
    Q_D(const QWinRTWindow);
    return d->surfaceFormat;
}

bool QWinRTWindow::isActive() const
{
    Q_D(const QWinRTWindow);
    return d->screen->topWindow() == window();
}

bool QWinRTWindow::isExposed() const
{
    Q_D(const QWinRTWindow);
    const bool exposed = isActive() && !d->screen->resizePending();
    return exposed;
}

void QWinRTWindow::setGeometry(const QRect &rect)
{
    Q_D(QWinRTWindow);
    qCDebug(lcQpaWindows) << __FUNCTION__ << this << rect;

    const Qt::WindowFlags windowFlags = window()->flags();
    const Qt::WindowFlags windowType = windowFlags & Qt::WindowType_Mask;
    if (window()->isTopLevel() && (windowType == Qt::Window || windowType == Qt::Dialog)) {
        const QRect screenRect = windowFlags & Qt::MaximizeUsingFullscreenGeometryHint
                                    ? d->screen->geometry() : d->screen->availableGeometry();
        qCDebug(lcQpaWindows) << __FUNCTION__ << "top-level, overwrite" << screenRect;
        QPlatformWindow::setGeometry(screenRect);
        QWindowSystemInterface::handleGeometryChange(window(), geometry());
    } else {
        QPlatformWindow::setGeometry(rect);
        QWindowSystemInterface::handleGeometryChange(window(), rect);
    }

    HRESULT hr;
    hr = QEventDispatcherWinRT::runOnXamlThread([this, d]() {
        HRESULT hr;
        const QRect windowGeometry = geometry();
        const QPointF topLeft= QPointF(windowGeometry.topLeft()) / d->screen->scaleFactor();
        hr = d->canvas->SetTop(d->uiElement.Get(), topLeft.y());
        Q_ASSERT_SUCCEEDED(hr);
        hr = d->canvas->SetLeft(d->uiElement.Get(), topLeft.x());
        Q_ASSERT_SUCCEEDED(hr);
        ComPtr<Xaml::IFrameworkElement> frameworkElement;
        hr = d->swapChainPanel.As(&frameworkElement);
        Q_ASSERT_SUCCEEDED(hr);
        const QSizeF size = QSizeF(windowGeometry.size()) / d->screen->scaleFactor();
        hr = frameworkElement->put_Width(size.width());
        Q_ASSERT_SUCCEEDED(hr);
        hr = frameworkElement->put_Height(size.height());
        Q_ASSERT_SUCCEEDED(hr);
        qCDebug(lcQpaWindows) << __FUNCTION__ << "(setGeometry Xaml)" << this
                             << topLeft << size;
        return S_OK;
    });
    Q_ASSERT_SUCCEEDED(hr);
}

void QWinRTWindow::setVisible(bool visible)
{
    Q_D(QWinRTWindow);
    qCDebug(lcQpaWindows) << __FUNCTION__ << this << visible;

    if (!window()->isTopLevel())
        return;
    if (visible) {
        d->screen->addWindow(window());
        setUIElementVisibility(d->uiElement.Get(), d->state != Qt::WindowMinimized);
    } else {
        d->screen->removeWindow(window());
        setUIElementVisibility(d->uiElement.Get(), false);
    }
}

void QWinRTWindow::setWindowTitle(const QString &title)
{
    Q_D(QWinRTWindow);
    d->windowTitle = title;

    if (d->screen->topWindow() == window())
        d->screen->updateWindowTitle(title);
}

void QWinRTWindow::raise()
{
    Q_D(QWinRTWindow);
    qCDebug(lcQpaWindows) << __FUNCTION__ << this;
    if (!window()->isTopLevel())
        return;
    d->screen->raise(window());
}

void QWinRTWindow::lower()
{
    Q_D(QWinRTWindow);
    qCDebug(lcQpaWindows) << __FUNCTION__ << this;
    if (!window()->isTopLevel())
        return;
    d->screen->lower(window());
}

WId QWinRTWindow::winId() const
{
    Q_D(const QWinRTWindow);
    return WId(d->swapChainPanel.Get());
}

qreal QWinRTWindow::devicePixelRatio() const
{
    return screen()->devicePixelRatio();
}

void QWinRTWindow::setWindowState(Qt::WindowStates state)
{
    Q_D(QWinRTWindow);
    qCDebug(lcQpaWindows) << __FUNCTION__ << this << state;

    if (d->state == state)
        return;

    if (state & Qt::WindowMinimized) {
        setUIElementVisibility(d->uiElement.Get(), false);
        d->state = state;
        return;
    }

    if (state & Qt::WindowFullScreen) {
        HRESULT hr;
        boolean success;
        hr = QEventDispatcherWinRT::runOnXamlThread([&hr, &success]() {
            ComPtr<IApplicationViewStatics2> applicationViewStatics;
            hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_UI_ViewManagement_ApplicationView).Get(),
                                        IID_PPV_ARGS(&applicationViewStatics));
            RETURN_HR_IF_FAILED("Could not access application view statics.");
            ComPtr<IApplicationView> view;
            hr = applicationViewStatics->GetForCurrentView(&view);
            RETURN_HR_IF_FAILED("Could not access application view.");
            ComPtr<IApplicationView3> view3;
            hr = view.As(&view3);
            Q_ASSERT_SUCCEEDED(hr);
            hr = view3->TryEnterFullScreenMode(&success);
            return hr;
        });
        if (FAILED(hr) || !success) {
            qCDebug(lcQpaWindows) << "Failed to enter full screen mode.";
            return;
        }
        d->screen->setResizePending();
        d->state = state;
        return;
    }

    if (d->state & Qt::WindowFullScreen) {
        HRESULT hr;
        hr = QEventDispatcherWinRT::runOnXamlThread([&hr]() {
            ComPtr<IApplicationViewStatics2> applicationViewStatics;
            hr = RoGetActivationFactory(HString::MakeReference(RuntimeClass_Windows_UI_ViewManagement_ApplicationView).Get(),
                                        IID_PPV_ARGS(&applicationViewStatics));
            RETURN_HR_IF_FAILED("Could not access application view statics.");
            ComPtr<IApplicationView> view;
            hr = applicationViewStatics->GetForCurrentView(&view);
            RETURN_HR_IF_FAILED("Could not access application view.");
            ComPtr<IApplicationView3> view3;
            hr = view.As(&view3);
            Q_ASSERT_SUCCEEDED(hr);
            hr = view3->ExitFullScreenMode();
            return hr;
        });
        if (FAILED(hr)) {
            qCDebug(lcQpaWindows) << "Failed to exit full screen mode.";
            return;
        }
        d->screen->setResizePending();
    }

    if (d->state & Qt::WindowMinimized || state == Qt::WindowNoState || state == Qt::WindowActive)
        setUIElementVisibility(d->uiElement.Get(), true);

    d->state = state;
}

bool QWinRTWindow::setMouseGrabEnabled(bool grab)
{
    Q_D(QWinRTWindow);
    if (!isActive() && grab) {
        qWarning("%s: Not setting mouse grab for invisible window %s/'%s'",
                 __FUNCTION__, window()->metaObject()->className(),
                 qPrintable(window()->objectName()));
        return false;
    }
    return d->screen->setMouseGrabWindow(this, grab);
}

bool QWinRTWindow::setKeyboardGrabEnabled(bool grab)
{
    Q_D(QWinRTWindow);
    return d->screen->setKeyboardGrabWindow(this, grab);
}

EGLSurface QWinRTWindow::eglSurface() const
{
    Q_D(const QWinRTWindow);
    return d->surface;
}

void QWinRTWindow::createEglSurface(EGLDisplay display, EGLConfig config)
{
    Q_D(QWinRTWindow);
    if (d->surface == EGL_NO_SURFACE) {
        d->display = display;
        QEventDispatcherWinRT::runOnXamlThread([this, d, display, config]() {
            d->surface = eglCreateWindowSurface(display, config,
                                                reinterpret_cast<EGLNativeWindowType>(winId()),
                                                nullptr);
            if (Q_UNLIKELY(d->surface == EGL_NO_SURFACE))
                qCritical("Failed to create EGL window surface: 0x%x", eglGetError());
            return S_OK;
        });
    }
}

QT_END_NAMESPACE