// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
import QtQuick
import QtQuick.Controls
import QtQuick.Layouts
import QtQuick.Window
import QtQuick.Dialogs
import QtQuick3D
import QtQuick3D.Helpers

import QtQuick3D.lightmapviewer
import LightmapFile 1.0

ColumnLayout {
    id: root
    anchors.fill: parent

    Pane {
        Layout.alignment: Qt.AlignLeft
        Layout.preferredHeight: 30
        padding: 8

        RowLayout {
            anchors.fill: parent
            spacing: 8

            CheckBox {
                id: cbWasd
                text: "WASD controller"
            }
            CheckBox {
                id: cbBackfaceCulling
                text: "Backface Culling"
                checked: true
            }
            CheckBox {
                id: cbDebugUv
                text: "Debug UV"
            }
            CheckBox {
                id: cbIgnoreScale
                text: "Ignore scale"
                onCheckedChanged: view.recomputeBounds()
            }
        }
    }

    View3D {
        id: view
        Layout.fillWidth: true
        Layout.fillHeight: true

        camera: cbWasd.checked ? wasdCamera : arcballCamera

        property var origBounds: null
        property real boundsDiameter: 0
        property vector3d boundsCenter
        property vector3d boundsSize

        function scaledBounds(orig, scaleVec) {
            if (!orig)
                return

            function mul(v, s) {
                return Qt.vector3d(v.x * s.x, v.y * s.y, v.z * s.z)
            }
            const a = mul(orig.minimum, scaleVec)
            const b = mul(orig.maximum, scaleVec)
            const min = Qt.vector3d(Math.min(a.x, b.x), Math.min(a.y, b.y),
                                    Math.min(a.z, b.z))
            const max = Qt.vector3d(Math.max(a.x, b.x), Math.max(a.y, b.y),
                                    Math.max(a.z, b.z))
            return {
                "minimum": min,
                "maximum": max
            }
        }

        function currentScale() {
            return cbIgnoreScale.checked ? Qt.vector3d(
                                               1, 1,
                                               1) : LightmapFile.getAppliedScaleFor(
                                               selectedKey)
        }

        function recomputeBounds() {
            if (!origBounds)
                return

            const s = currentScale()
            const sb = scaledBounds(origBounds, s)

            boundsSize = Qt.vector3d(sb.maximum.x - sb.minimum.x,
                                     sb.maximum.y - sb.minimum.y,
                                     sb.maximum.z - sb.minimum.z)
            boundsDiameter = Math.max(boundsSize.x, boundsSize.y, boundsSize.z)
            boundsCenter = Qt.vector3d((sb.maximum.x + sb.minimum.x) / 2,
                                       (sb.maximum.y + sb.minimum.y) / 2,
                                       (sb.maximum.z + sb.minimum.z) / 2)

            model.position = Qt.vector3d(-boundsCenter.x, -boundsCenter.y,
                                         -boundsCenter.z)

            arcballCamera.clipNear = Math.max(0.001, boundsDiameter / 100)
            arcballCamera.clipFar = Math.max(arcballCamera.clipNear + 1.0,
                                             boundsDiameter * 10)
            wasdCamera.clipNear = Math.max(0.001, boundsDiameter / 100)
            wasdCamera.clipFar = Math.max(wasdCamera.clipNear + 1.0,
                                          boundsDiameter * 10)

            wasdController.speed = boundsDiameter / 1000.0
            wasdController.shiftSpeed = 3 * wasdController.speed

            resetCamera()
        }

        function updateBounds(bounds) {
            origBounds = bounds
            recomputeBounds()
        }

        function resetCamera() {
            arcballCamera.position = Qt.vector3d(0, 0,
                                                 2 * Math.max(0.001,
                                                              boundsDiameter))
            arcballCamera.eulerRotation = Qt.vector3d(0, 0, 0)
            wasdCamera.position = Qt.vector3d(0, 0,
                                              2 * Math.max(0.001,
                                                           boundsDiameter))
            wasdCamera.eulerRotation = Qt.vector3d(0, 0, 0)
        }

        environment: SceneEnvironment {
            backgroundMode: SceneEnvironment.Color
            clearColor: "darkslategray"
        }

        PerspectiveCamera {
            id: arcballCamera
            z: 300
        }

        PerspectiveCamera {
            id: wasdCamera
            z: 300
        }

        Node {
            id: modelNode

            Model {
                id: model

                scale: view.currentScale()
                onScaleChanged: view.recomputeBounds()

                geometry: LightmapMesh {
                    source: LightmapFile.source
                    key: meshKey
                    onBoundsChanged: view.updateBounds(bounds)
                }
                materials: CustomMaterial {
                    shadingMode: CustomMaterial.Unshaded
                    cullMode: cbBackfaceCulling.checked ? Material.BackFaceCulling : Material.NoCulling

                    property TextureInput baseMap: TextureInput {
                        texture: Texture {
                            tilingModeHorizontal: Texture.ClampToEdge
                            tilingModeVertical: Texture.ClampToEdge

                            textureData: LightmapFile.textureDataFor(
                                             selectedKey, selectedTextureTag)
                        }
                    }
                    property bool debugUV: cbDebugUv.checked

                    vertexShader: "mesh.vert"
                    fragmentShader: "mesh.frag"
                }
            }
        }

        ArcballController {
            id: arcballController
            controlledObject: modelNode
            camera: arcballCamera
            enabled: !cbWasd.checked

            function jumpToAxis(axis) {
                cameraRotation.from = arcballController.controlledObject.rotation
                cameraRotation.to = originGizmo.quaternionForAxis(
                            axis, arcballController.controlledObject.rotation)
                cameraRotation.duration = 200
                cameraRotation.start()
            }

            function jumpToRotation(qRotation) {
                cameraRotation.from = arcballController.controlledObject.rotation
                cameraRotation.to = qRotation
                cameraRotation.duration = 200
                cameraRotation.start()
            }

            QuaternionAnimation {
                id: cameraRotation
                target: arcballController.controlledObject
                property: "rotation"
                type: QuaternionAnimation.Slerp
                running: false
                loops: 1
            }
        }

        WasdController {
            id: wasdController
            controlledObject: wasdCamera
            enabled: cbWasd.checked
        }

        OriginGizmo {
            id: originGizmo
            anchors.top: parent.top
            anchors.right: parent.right
            anchors.margins: 10
            width: 120
            height: 120
            targetNode: modelNode
            onAxisClicked: axis => {
                               arcballController.jumpToAxis(axis)
                           }
        }

        Keys.onPressed: event => {
                            if (!arcballController.enabled) return

                            if (event.key === Qt.Key_Space) {
                                let rotation = originGizmo.quaternionAlign(
                                    arcballController.controlledObject.rotation)
                                arcballController.jumpToRotation(rotation)
                            } else if (event.key === Qt.Key_A) {
                                let rotation = originGizmo.rotateYawLeft(
                                    arcballController.controlledObject.rotation)
                                arcballController.jumpToRotation(rotation)
                            } else if (event.key === Qt.Key_D) {
                                let rotation = originGizmo.rotateYawRight(
                                    arcballController.controlledObject.rotation)
                                arcballController.jumpToRotation(rotation)
                            } else if (event.key === Qt.Key_W) {
                                let rotation = originGizmo.rotatePitchUp(
                                    arcballController.controlledObject.rotation)
                                arcballController.jumpToRotation(rotation)
                            } else if (event.key === Qt.Key_S) {
                                let rotation = originGizmo.rotatePitchDown(
                                    arcballController.controlledObject.rotation)
                                arcballController.jumpToRotation(rotation)
                            } else if (event.key === Qt.Key_Q) {
                                let rotation = originGizmo.rotateRollLeft(
                                    arcballController.controlledObject.rotation)
                                arcballController.jumpToRotation(rotation)
                            } else if (event.key === Qt.Key_E) {
                                let rotation = originGizmo.rotateRollRight(
                                    arcballController.controlledObject.rotation)
                                arcballController.jumpToRotation(rotation)
                            }
                        }
    }
}