import QtQuick 2.15
import QtQuick.Controls 2.15
import QtQuick3D 6.5

import "maze"

// A small first-person maze. This is an embeddable Item, not a Window.
Item {
    id: game
    width: 800
    height: 650
    focus: true

    property real playerX: 0
    property real playerZ: 7
    property real heading: 0
    property real cameraPitch: 0
    property bool running: true
    property bool finished: false
    property int steps: 0
    property real moveStep: 0.38
    property real moveSpeed: 5.2
    property real mouseSensitivity: 0.22
    property real stepAccumulator: 0
    property int currentLevel: 1
    readonly property int totalLevels: 5
    property real finishRadius: 1.15
    property var mazeWalls: level1.walls

    property bool forwardPressed: false
    property bool backwardPressed: false
    property bool leftPressed: false
    property bool rightPressed: false

    MazeLevel1 { id: level1 }
    MazeLevel2 { id: level2 }
    MazeLevel3 { id: level3 }
    MazeLevel4 { id: level4 }
    MazeLevel5 { id: level5 }

    function activate() { forceActiveFocus() }

    function levelDefinition(level) {
        if (level === 1) return level1
        if (level === 2) return level2
        if (level === 3) return level3
        if (level === 4) return level4
        return level5
    }

    function configureLevel(level) {
        currentLevel = Math.max(1, Math.min(totalLevels, level))
        var definition = levelDefinition(currentLevel)
        moveSpeed = definition.moveSpeed
        finishRadius = definition.finishRadius
        mazeWalls = definition.walls
    }

    function nextLevel() {
        if (currentLevel >= totalLevels)
            return
        configureLevel(currentLevel + 1)
        restart()
    }

    function restartGame() {
        configureLevel(1)
        restart()
    }

    function intersectsWall(x, z) {
        var playerRadius = 0.28
        if (x < -8.4 || x > 8.4 || z < -8.4 || z > 8.4) return true
        for (var i = 0; i < mazeWalls.length; ++i) {
            var wall = mazeWalls[i]
            if (x > wall.x - wall.sx / 2 - playerRadius
                    && x < wall.x + wall.sx / 2 + playerRadius
                    && z > wall.z - wall.sz / 2 - playerRadius
                    && z < wall.z + wall.sz / 2 + playerRadius)
                return true
        }
        return false
    }

    function resetInput() {
        forwardPressed = false
        backwardPressed = false
        leftPressed = false
        rightPressed = false
    }

    function movePlayer(forward, right, deltaSeconds) {
        if (!running || (forward === 0 && right === 0)) return

        var length = Math.sqrt(forward * forward + right * right)
        if (length > 1) {
            forward /= length
            right /= length
        }

        var radians = heading * Math.PI / 180.0
        var distance = moveSpeed * deltaSeconds
        var deltaX = (-Math.sin(radians) * forward
                      + Math.cos(radians) * right) * distance
        var deltaZ = (-Math.cos(radians) * forward
                      - Math.sin(radians) * right) * distance
        var moved = false

        // Check the axes separately so the player can slide along a wall.
        if (!intersectsWall(playerX + deltaX, playerZ)) {
            playerX += deltaX
            moved = true
        }
        if (!intersectsWall(playerX, playerZ + deltaZ)) {
            playerZ += deltaZ
            moved = true
        }

        if (moved) {
            stepAccumulator += distance
            while (stepAccumulator >= moveStep) {
                steps++
                stepAccumulator -= moveStep
            }
            if (Math.abs(playerX - 6.2) < finishRadius
                    && Math.abs(playerZ + 6.2) < finishRadius) {
                finished = true
                running = false
            }
        }
    }

    function look(deltaX, deltaY) {
        if (!running) return
        heading = (heading - deltaX * mouseSensitivity + 360) % 360
        cameraPitch = Math.max(-70, Math.min(70,
                                             cameraPitch - deltaY * mouseSensitivity))
    }

    function restart() {
        resetInput()
        playerX = 0; playerZ = 7; heading = 0; cameraPitch = 0
        steps = 0; stepAccumulator = 0; finished = false; running = true
        forceActiveFocus()
    }

    Keys.onPressed: function(event) {
        if (event.key === Qt.Key_W || event.key === Qt.Key_Up) forwardPressed = true
        else if (event.key === Qt.Key_S || event.key === Qt.Key_Down) backwardPressed = true
        else if (event.key === Qt.Key_A || event.key === Qt.Key_Left) leftPressed = true
        else if (event.key === Qt.Key_D || event.key === Qt.Key_Right) rightPressed = true
        else if (event.key === Qt.Key_P && !finished) {
            running = !running
            resetInput()
        }
        else if (event.key === Qt.Key_R) restart()
        else return
        event.accepted = true
    }

    Keys.onReleased: function(event) {
        if (event.key === Qt.Key_W || event.key === Qt.Key_Up) forwardPressed = false
        else if (event.key === Qt.Key_S || event.key === Qt.Key_Down) backwardPressed = false
        else if (event.key === Qt.Key_A || event.key === Qt.Key_Left) leftPressed = false
        else if (event.key === Qt.Key_D || event.key === Qt.Key_Right) rightPressed = false
        else return
        event.accepted = true
    }

    onActiveFocusChanged: {
        if (!activeFocus)
            resetInput()
    }

    onRunningChanged: {
        if (!running)
            resetInput()
    }

    Timer {
        interval: 16
        repeat: true
        running: game.running && (game.forwardPressed || game.backwardPressed
                                  || game.leftPressed || game.rightPressed)
        onTriggered: game.movePlayer((game.forwardPressed ? 1 : 0)
                                     - (game.backwardPressed ? 1 : 0),
                                     (game.rightPressed ? 1 : 0)
                                     - (game.leftPressed ? 1 : 0),
                                     interval / 1000.0)
    }

    View3D {
        anchors.fill: parent
        renderMode: View3D.Offscreen
        environment: SceneEnvironment {
            clearColor: "#D9EEF7"
            backgroundMode: SceneEnvironment.Color
        }

        PerspectiveCamera {
            position: Qt.vector3d(game.playerX, 1.65, game.playerZ)
            eulerRotation: Qt.vector3d(game.cameraPitch, game.heading, 0)
            clipNear: 0.1
            clipFar: 100
        }

        DirectionalLight {
            eulerRotation.x: -38
            eulerRotation.y: -28
            brightness: 1.2
            castsShadow: true
        }

        Model {
            source: "#Cube"
            position: Qt.vector3d(0, -0.12, 0)
            scale: Qt.vector3d(0.18, 0.002, 0.18)
            materials: PrincipledMaterial { baseColor: "#A9C7B0"; roughness: 0.88 }
        }

        // Boundary and internal maze walls.
        Repeater3D {
            model: [
                { x: 0, z: -9, sx: 18, sz: 0.5 },
                { x: 0, z: 9, sx: 18, sz: 0.5 },
                { x: -9, z: 0, sx: 0.5, sz: 18 },
                { x: 9, z: 0, sx: 0.5, sz: 18 }
            ].concat(game.mazeWalls)
            delegate: Model {
                required property var modelData
                source: "#Cube"
                position: Qt.vector3d(modelData.x, 1, modelData.z)
                scale: Qt.vector3d(modelData.sx / 100, 0.02, modelData.sz / 100)
                materials: PrincipledMaterial { baseColor: "#64748B"; roughness: 0.78 }
            }
        }

        Model {
            source: "#Sphere"
            position: Qt.vector3d(6.2, 0.7, -6.2)
            scale: Qt.vector3d(0.012, 0.012, 0.012)
            materials: PrincipledMaterial {
                baseColor: "#7C3AED"
                emissiveFactor: Qt.vector3d(0.24, 0.08, 0.46)
                roughness: 0.25
            }
        }
        PointLight {
            position: Qt.vector3d(6.2, 2.2, -6.2)
            color: "#7C3AED"
            brightness: 28
        }
    }

    MouseArea {
        id: cameraMouseArea

        anchors.fill: parent
        acceptedButtons: Qt.LeftButton
        hoverEnabled: true
        cursorShape: pressed ? Qt.ClosedHandCursor : Qt.OpenHandCursor

        property real previousX: 0
        property real previousY: 0

        onPressed: function(mouse) {
            previousX = mouse.x
            previousY = mouse.y
            game.forceActiveFocus()
            mouse.accepted = true
        }

        onPositionChanged: function(mouse) {
            if (!pressed)
                return
            var deltaX = mouse.x - previousX
            var deltaY = mouse.y - previousY
            previousX = mouse.x
            previousY = mouse.y
            game.look(deltaX, deltaY)
        }
    }

    Rectangle {
        anchors.left: parent.left; anchors.top: parent.top; anchors.margins: 18
        width: 430; height: 108; radius: 10
        color: "#FFFFFF"; opacity: 0.94
        border.width: 1
        border.color: "#D5DEE8"
        Column {
            anchors.centerIn: parent; spacing: 5
            Label { renderType: Text.NativeRendering; text: "ТРЁХМЕРНЫЙ ЛАБИРИНТ"; color: "#111827"; font.bold: true; font.pixelSize: 17 }
            Label { renderType: Text.NativeRendering; text: "Шаги: " + steps; color: "#1F2D3D"; font.pixelSize: 14 }
            Label { renderType: Text.NativeRendering; text: "Уровень " + currentLevel + " из " + totalLevels; color: "#405164"; font.pixelSize: 13 }
            Label { renderType: Text.NativeRendering; text: "Найдите фиолетовую сферу"; color: "#6D28D9"; font.pixelSize: 13 }
            Label { renderType: Text.NativeRendering; text: "Клавиши W, A, S, D — движение · Левая кнопка мыши — обзор"; color: "#405164"; font.pixelSize: 12 }
        }
    }

    Rectangle {
        anchors.fill: parent
        visible: !running
        z: 4
        color: "#E7ECF2"; opacity: 0.9

        MouseArea {
            anchors.fill: parent
            acceptedButtons: Qt.AllButtons
        }

        Column {
            anchors.centerIn: parent; spacing: 12
            Label {
                renderType: Text.NativeRendering
                anchors.horizontalCenter: parent.horizontalCenter
                text: finished ? "Цель найдена!" : "Пауза"
                color: "#111827"; font.pixelSize: 29; font.bold: true
            }
            Label {
                renderType: Text.NativeRendering
                anchors.horizontalCenter: parent.horizontalCenter
                visible: finished
                text: currentLevel < totalLevels
                      ? "Уровень " + currentLevel + " пройден · шагов: " + steps
                      : "Все 5 уровней пройдены · шагов на уровне: " + steps
                color: "#6D28D9"; font.pixelSize: 17
            }
            BeautifulButton {
                anchors.horizontalCenter: parent.horizontalCenter
                lightTheme: true
                text: !finished
                      ? "Продолжить"
                      : currentLevel < totalLevels
                        ? "Следующий уровень" : "Начать заново"
                onClicked: {
                    if (!finished) {
                        running = true
                        game.forceActiveFocus()
                    } else if (currentLevel < totalLevels) {
                        nextLevel()
                    } else {
                        restartGame()
                    }
                }
            }
        }
    }

    BeautifulButton {
        anchors.right: parent.right; anchors.bottom: parent.bottom; anchors.margins: 18
        lightTheme: true
        text: running ? "Пауза" : "Продолжить"
        visible: !finished
        onClicked: {
            running = !running
            resetInput()
            game.forceActiveFocus()
        }
    }
}
