/* ============================================
   PREMIUM VALENTINE EXPERIENCE - MAIN APP
   ============================================ */

// ============================================
// CONFIGURATION - ИЗМЕНИТЕ ВСЕ ТЕКСТЫ ЗДЕСЬ
// ============================================
const CONFIG = {
    // Основные имена
    girlName: "Милана",
    yourName: "Влад",
    
    // Telegram настройки
    telegram: {
        username: "YOUR_USERNAME", // Замените на ваш Telegram username (без @)
        messageYes: "Милана согласилась быть моей Валентинкой! 💘",
        messageShy: "Милана сказала: да, но она стесняется 🙈💘"
    },
    
    // Контактная информация
    contact: {
        phone: "+47XXXXXXXXX", // Замените на ваш номер телефона (формат: +47XXXXXXXXX)
        mapsUrl: "https://www.google.com/maps/search/?api=1&query=Bergen+sentrum"
    },
    
    // Сцены - тексты
    scenes: {
        scene1: {
            line1: "Милана…",
            line2: "Я долго думал, как сделать этот момент особенным.",
            line3: "Поэтому сделал для тебя маленькую историю."
        },
        scene2: {
            typewriterText: "Каждый день я думаю о тебе. О твоей улыбке, о твоих глазах, о том, как ты смеёшься. Ты делаешь мои дни ярче, а мои мысли — светлее. И сегодня я хочу сказать тебе то, что давно хотел сказать...",
            memoryCardText: "Лето 2025 подарило мне многое.\nНо самое прекрасное в нём — это ты 💕"
        },
        scene3: {
            title: "Наши моменты"
        },
        scene4: {
            introText: "Этот момент почему-то всегда напоминает мне нас.",
            videoFile: "assets/video/Milana.mp4"
        },
        scene5: {
            title: "Поймай сердечки",
            target: 10,
            instructions: "Используй стрелки ← → или проведи пальцем, чтобы двигать корзинку"
        },
        scene6: {
            title: "Почему ты особенная",
            backgroundImages: [
                "assets/images/1.JPG",
                "assets/images/2.JPG",
                "assets/images/3.JPG",
                "assets/images/4.JPG",
                "assets/images/5.JPG",
                "assets/images/6.JPG",
                "assets/images/7.JPG",
                "assets/images/8.JPG",
                "assets/images/9.JPG",
                "assets/images/10.JPG",
                "assets/images/11.JPG",
                "assets/images/12.JPG",
                "assets/images/13.JPG",
                "assets/images/14.JPG",
                "assets/images/15.JPG",
                "assets/images/16.jpg",
                "assets/images/17.jpg"
            ],
            reasons: [
                {
                    title: "Твоя улыбка",
                    text: "Иногда ты улыбаешься так,\nчто у меня в голове просто всё становится тише.\nИ в этот момент мне больше ничего не нужно."
                },
                {
                    title: "Твоя доброта",
                    text: "Ты умеешь быть тёплой даже тогда,\nкогда мир не очень.\nИ рядом с тобой почему-то хочется быть лучше."
                },
                {
                    title: "Твоя уникальность",
                    text: "Ты не похожа ни на кого.\nИ я даже не хочу это объяснять —\nмне просто нравится, что ты именно такая."
                },
                {
                    title: "Твоё чувство юмора",
                    text: "Ты можешь рассмешить меня в самый обычный момент.\nИ именно поэтому эти моменты становятся важными."
                },
                {
                    title: "Твоя искренность",
                    text: "С тобой не нужно играть роли\nи что-то из себя изображать.\nС тобой можно просто быть."
                },
                {
                    title: "Ты — это ты",
                    text: "И, если честно,\nмне этого более чем достаточно,\nчтобы хотеть быть рядом с тобой."
                }
            ]
        },
        scene7: {
            question: "Милана, ты станешь моей Валентинкой?"
        },
        ending: {
            yes: "Спасибо, что сказала да! Ты сделала меня самым счастливым человеком на свете. 💘",
            shy: "Спасибо за твой ответ! Я понимаю, что это может быть волнительно. Но я рад, что ты согласилась. 💕",
            think: "Конечно, подумай. Я буду ждать твоего ответа. Но знай — для меня ты уже особенная. 💝",
            backgroundImage: "assets/images/ending-bg.jpg" // Замените на ваше изображение
        }
    },
    
    // Галерея - изображения и подписи
    gallery: [
        {
            image: "assets/images/та самая.jpg",
            title: "Та самая",
            caption: "Это первая твоя фотография, которую я поставил себе на телефон.\nЯ просыпался утром, брал телефон — и видел тебя.\nНаверное, именно в этот момент я понял, что влюбился."
        },
        {
            image: "assets/images/счастливая.JPG",
            title: "Счастливая",
            caption: "В этот день я подарил тебе твою акулу.\nИ именно тогда понял одну простую вещь —\nя хочу видеть тебя счастливой.\nПросто потому, что ты такая."
        },
        {
            image: "assets/images/вавтобусе.JPG",
            title: "В автобусе",
            caption: "Обычный момент.\nНичего особенного.\nНо почему-то именно такие моменты\nмне запоминаются больше всего."
        },
        {
            image: "assets/images/целую руку.jpg",
            title: "Целую руку",
            caption: "Это был весёлый день.\nМне тогда просто хотелось видеть твою улыбку.\nИ, честно, больше ничего не было нужно."
        },
        {
            image: "assets/images/просто шли.JPG",
            title: "Просто шли",
            caption: "Мы просто шли.\nИ в тот момент мне казалось,\nчто дальше можно идти куда угодно.\nГлавное — вместе."
        },
        {
            image: "assets/images/обнимаемся.JPG",
            title: "Обнимаемся",
            caption: "Просто было хорошо.\nИ этого хватало.\nГлавное — вместе."
        },
        {
            image: "assets/images/мы.jpg",
            title: "Поросята",
            caption: "Если вдруг кто-то спросит, как выглядим мы —\nвот примерное объяснение.",
            isLast: true // Флаг для последней фотографии с поросятами
        }
    ],
    
    // Цвета (опционально, можно изменить в CSS)
    colors: {
        primary: "#ff6b9d",
        secondary: "#ff8fb3"
    },
    
    // Аудио (опционально)
    audio: {
        enabled: true, // Включить/выключить аудио
        fileName: "assets/audio/the_twilight_saga_new_moon_08 - Bon Iver & St. Vincent - Rosyln.mp3" // Имя файла аудио
    }
};

// ============================================
// APP STATE
// ============================================
let currentScene = 1;
let totalScenes = 8;
let audioEnabled = false;
let gameScore = 0;
let gameTarget = CONFIG.scenes.scene5.target;
let gameCompleted = false;
let gameHearts = [];
let gameAnimationId = null;
let basketPosition = 50; // percentage
let answerChosen = null;
let noClicks = 0; // Счётчик кликов по кнопке "Нет"

// ============================================
// INITIALIZATION
// ============================================
document.addEventListener('DOMContentLoaded', () => {
    // Отключаем автоматическое восстановление скролла браузером
    if ('scrollRestoration' in history) {
        history.scrollRestoration = 'manual';
    }
    
    setupHashRouting(); // Must be first to read hash
    initializeApp();
    setupEventListeners();
    // Load scene (hash routing may have set currentScene)
    loadScene(currentScene);
});

function initializeApp() {
    // Update progress indicator
    updateProgress(currentScene);
    
    // Setup particles for scene 1
    setupParticles();
    
    // Setup audio
    setupAudio();
    
    // Initialize gallery
    initializeGallery();
    
    // Initialize scene 3 background
    initializeScene3Background();
    
    // Initialize game
    initializeGame();
    
    // Initialize reasons cards
    initializeReasons();
    
    // Initialize cursor trail canvas
    initializeCursorTrailCanvas();
    
    // Update all text content from CONFIG
    updateTextsFromConfig();
}

// Инициализация canvas для линии курсора
function initializeCursorTrailCanvas() {
    const canvas = document.getElementById('cursorTrail');
    if (!canvas) return;
    
    const ctx = canvas.getContext('2d');
    if (!ctx) return;
    
    function resizeCanvas() {
        canvas.width = window.innerWidth;
        canvas.height = window.innerHeight;
    }
    
    resizeCanvas();
    window.addEventListener('resize', resizeCanvas);
}

// ============================================
// HASH ROUTING
// ============================================
function setupHashRouting() {
    // Handle initial hash
    if (window.location.hash) {
        const hash = decodeURIComponent(window.location.hash);
        const match = hash.match(/сцена-(\d+)/);
        if (match) {
            const sceneNum = parseInt(match[1]);
            if (sceneNum >= 1 && sceneNum <= totalScenes) {
                currentScene = sceneNum;
            }
        }
    }
    
    // Отключаем автоматическое восстановление скролла браузером
    if ('scrollRestoration' in history) {
        history.scrollRestoration = 'manual';
    }
    
    // Handle hash changes
    window.addEventListener('hashchange', () => {
        // Сбрасываем скролл сразу при изменении hash
        window.scrollTo({ top: 0, left: 0, behavior: 'instant' });
        
        const hash = decodeURIComponent(window.location.hash);
        const match = hash.match(/сцена-(\d+)/);
        if (match) {
            const sceneNum = parseInt(match[1]);
            if (sceneNum >= 1 && sceneNum <= totalScenes) {
                navigateToScene(sceneNum);
            }
        }
    });
}

function updateHash(sceneNum) {
    window.location.hash = `сцена-${sceneNum}`;
}

// Функция для гарантированного сброса скролла к началу сцены
function resetScrollToScene(sceneEl) {
    if (!sceneEl) return;
    
    // Сбрасываем скролл окна
    window.scrollTo({ top: 0, left: 0, behavior: 'instant' });
    
    // Прокручиваем к началу конкретной сцены
    sceneEl.scrollIntoView({ behavior: 'instant', block: 'start' });
    
    // Дополнительно: сбрасываем скролл у контейнера, если есть
    const mainContainer = document.getElementById('mainContainer');
    if (mainContainer) {
        mainContainer.scrollTop = 0;
    }
    
    // Сбрасываем скролл у самой сцены, если есть
    if (sceneEl.scrollTop !== undefined) {
        sceneEl.scrollTop = 0;
    }
    
    // Сбрасываем скролл у scene-content, если есть
    const sceneContent = sceneEl.querySelector('.scene-content');
    if (sceneContent && sceneContent.scrollTop !== undefined) {
        sceneContent.scrollTop = 0;
    }
}

// ============================================
// SCENE NAVIGATION
// ============================================
function navigateToScene(sceneNum) {
    if (sceneNum < 1 || sceneNum > totalScenes) {
        console.error(`Invalid scene number: ${sceneNum}`);
        return;
    }
    
    const currentSceneEl = document.querySelector(`#scene-${currentScene}`);
    const nextSceneEl = document.querySelector(`#scene-${sceneNum}`);
    
    if (!nextSceneEl) {
        console.error(`Scene ${sceneNum} element not found!`);
        return;
    }
    
    console.log(`Navigating from scene ${currentScene} to scene ${sceneNum}`);
    
    // Exit animation
    if (currentSceneEl && currentScene !== sceneNum) {
        gsap.to(currentSceneEl, {
            opacity: 0,
            scale: 0.95,
            duration: 0.6,
            ease: "power2.inOut",
            onComplete: () => {
                currentSceneEl.classList.remove('active');
                currentSceneEl.style.opacity = '0';
                currentSceneEl.style.visibility = 'hidden';
            }
        });
    } else if (currentSceneEl) {
        currentSceneEl.classList.remove('active');
        currentSceneEl.style.opacity = '0';
        currentSceneEl.style.visibility = 'hidden';
    }
    
    // Enter animation - принудительно активируем сцену
    currentScene = sceneNum;
    nextSceneEl.classList.add('active');
    nextSceneEl.style.opacity = '1';
    nextSceneEl.style.visibility = 'visible';
    nextSceneEl.style.display = 'flex';
    
    // Сбрасываем скролл сразу при активации сцены (до анимации)
    window.scrollTo({ top: 0, left: 0, behavior: 'instant' });
    
    // Анимация входа
    if (typeof gsap !== 'undefined') {
        gsap.fromTo(nextSceneEl, 
            { opacity: 0, scale: 1.05 },
            { 
                opacity: 1, 
                scale: 1, 
                duration: 0.6, 
                ease: "power2.inOut",
                onComplete: () => {
                    // Гарантированный сброс скролла ПОСЛЕ отрисовки и анимации
                    resetScrollToScene(nextSceneEl);
                }
            }
        );
    } else {
        nextSceneEl.style.opacity = '1';
        nextSceneEl.style.transform = 'scale(1)';
        // Гарантированный сброс скролла ПОСЛЕ отрисовки
        requestAnimationFrame(() => {
            requestAnimationFrame(() => {
                resetScrollToScene(nextSceneEl);
            });
        });
    }
    
    updateProgress(sceneNum);
    setupSceneSpecifics(sceneNum);
    // Дополнительный сброс скролла через requestAnimationFrame (на всякий случай)
    requestAnimationFrame(() => {
        requestAnimationFrame(() => {
            resetScrollToScene(nextSceneEl);
        });
    });
}

function loadScene(sceneNum) {
    const sceneEl = document.querySelector(`#scene-${sceneNum}`);
    if (!sceneEl) return;
    
    sceneEl.classList.add('active');
    
    // Сбрасываем скролл сразу при активации сцены
    window.scrollTo({ top: 0, left: 0, behavior: 'instant' });
    
    gsap.fromTo(sceneEl,
        { opacity: 0 },
        { 
            opacity: 1, 
            duration: 0.8, 
            ease: "power2.inOut",
            onComplete: () => {
                // Гарантированный сброс скролла ПОСЛЕ отрисовки и анимации
                resetScrollToScene(sceneEl);
            }
        }
    );
    
    updateHash(sceneNum);
    setupSceneSpecifics(sceneNum);
    
    // Дополнительный сброс скролла через requestAnimationFrame (на всякий случай)
    requestAnimationFrame(() => {
        requestAnimationFrame(() => {
            resetScrollToScene(sceneEl);
        });
    });
}

function setupSceneSpecifics(sceneNum) {
    console.log(`setupSceneSpecifics called for scene ${sceneNum}`);
    
    // Очищаем эффекты предыдущей сцены
    cleanupSceneEffects();
    
    // Управление скроллом: разрешён только на сценах 3, 4 и 5
    const scrollableScenes = [3, 4, 5];
    if (scrollableScenes.includes(sceneNum)) {
        document.body.style.overflow = 'auto'; // Разрешаем скролл
        document.body.style.overflowY = 'auto'; // Разрешаем вертикальный скролл
    } else {
        document.body.style.overflow = 'hidden'; // Запрещаем скролл
        document.body.style.overflowY = 'hidden';
    }
    
    // Принудительный скролл в начало при переходе на любую сцену
    window.scrollTo({top: 0, left: 0, behavior: 'instant'});
    
    switch(sceneNum) {
        case 1:
            animateScene1();
            break;
        case 2:
            animateScene2();
            break;
        case 3:
            animateScene3();
            break;
        case 4:
            animateScene4();
            break;
        case 5:
            resetGame();
            break;
        case 6:
            // Добавляем небольшую задержку для гарантии рендеринга
            setTimeout(() => {
                animateScene6Reasons();
            }, 100);
            break;
        case 7:
            animateScene7();
            break;
        case 8:
            animateScene8();
            break;
    }
    
    // Show sound toggle from scene 2 onwards
    const soundToggle = document.getElementById('soundToggle');
    if (soundToggle) {
        if (sceneNum >= 2) {
            soundToggle.classList.add('visible');
        } else {
            soundToggle.classList.remove('visible');
        }
    }
    
    // Update navigation
}

// Навигация удалена - переходы только через кнопки внутри сцен

// Очистка эффектов сцены
function cleanupSceneEffects() {
    console.log('🧹 Cleaning up scene effects, currentScene:', currentScene);
    
    // Скрываем кнопку "Далее" из сцены 4 при переходе на другую сцену
    const cinemaNextBtn = document.getElementById('cinemaNextBtn');
    if (cinemaNextBtn && currentScene !== 4) {
        cinemaNextBtn.style.display = 'none';
        cinemaNextBtn.style.visibility = 'hidden';
        cinemaNextBtn.style.opacity = '0';
        cinemaNextBtn.style.pointerEvents = 'none';
        cinemaNextBtn.classList.remove('visible');
    }
    
    // Скрываем fallback кнопку при переходе на другую сцену
    const scene4NextBtnFallback = document.getElementById('scene4NextBtnFallback');
    if (scene4NextBtnFallback) {
        if (currentScene === 4) {
            // Показываем на сцене 4
            scene4NextBtnFallback.style.display = 'flex';
            scene4NextBtnFallback.style.visibility = 'visible';
            scene4NextBtnFallback.style.opacity = '1';
            scene4NextBtnFallback.style.pointerEvents = 'auto';
        } else {
            // Скрываем на других сценах
            scene4NextBtnFallback.style.display = 'none';
            scene4NextBtnFallback.style.visibility = 'hidden';
            scene4NextBtnFallback.style.opacity = '0';
            scene4NextBtnFallback.style.pointerEvents = 'none';
        }
    }
    
    // Останавливаем игровой цикл если выходим со сцены 5
    if (currentScene !== 5) {
        if (gameAnimationId) {
            console.log('🧹 Stopping game loop');
            cancelAnimationFrame(gameAnimationId);
            gameAnimationId = null;
        }
        
        // Очищаем все эффекты "+1" из мини-игры
        const catchEffects = document.querySelectorAll('.catch-effect');
        catchEffects.forEach(effect => {
            gsap.killTweensOf(effect);
            if (effect.parentElement) {
                effect.remove();
            }
        });
        console.log(`🧹 Removed ${catchEffects.length} catch effects`);
        
        // Очищаем сердечки из игры
        const gameArea = document.getElementById('gameArea');
        if (gameArea) {
            const hearts = gameArea.querySelectorAll('.game-heart');
            hearts.forEach(h => {
                gsap.killTweensOf(h);
                h.remove();
            });
        }
    }
    
    // Очищаем canvas для линии курсора
    const canvas = document.getElementById('cursorTrail');
    if (canvas) {
        canvas.classList.remove('active');
        const ctx = canvas.getContext('2d');
        if (ctx) {
            ctx.clearRect(0, 0, canvas.width, canvas.height);
        }
    }
    
    // Очищаем фоновые фотографии ТОЛЬКО если выходим со сцены 6
    if (currentScene !== 6) {
        const memoriesBg = document.getElementById('memoriesBackground');
        if (memoriesBg) {
            console.log('🧹 Clearing memories background (leaving scene 6)');
            // Останавливаем все CSS анимации и удаляем фотографии
            const photos = memoriesBg.querySelectorAll('.flying-photo');
            photos.forEach(photo => {
                photo.style.animation = 'none';
                if (photo.parentElement) {
                    photo.remove();
                }
            });
            memoriesBg.innerHTML = '';
            // КОНТРОЛЬ УНИКАЛЬНОСТИ: очищаем список активных изображений при выходе со сцены
            // Это гарантирует, что при следующем входе не будет конфликтов
            if (typeof window.activeImagePaths !== 'undefined') {
                window.activeImagePaths.clear();
            }
        }
    } else {
        console.log('✅ Staying on scene 6, keeping memories background');
    }
    
}

// ============================================
// PROGRESS INDICATOR
// ============================================
function updateProgress(sceneNum) {
    const progressText = document.getElementById('progressText');
    const progressDots = document.getElementById('progressDots');
    
    if (progressText) {
        progressText.textContent = `${sceneNum}/${totalScenes}`;
    }
    
    if (progressDots) {
        progressDots.innerHTML = '';
        for (let i = 1; i <= totalScenes; i++) {
            const dot = document.createElement('div');
            dot.className = 'progress-dot';
            if (i === sceneNum) {
                dot.classList.add('active');
            }
            progressDots.appendChild(dot);
        }
    }
}

// ============================================
// SCENE 1: Атмосфера / Вход
// ============================================
function animateScene1() {
    const lines = document.querySelectorAll('.reveal-line');
    const hint = document.querySelector('.hint-text');
    
    lines.forEach((line, index) => {
        const delay = parseInt(line.dataset.delay) || 0;
        gsap.fromTo(line,
            { opacity: 0, y: 30 },
            { opacity: 1, y: 0, duration: 1, delay: delay / 1000, ease: "power2.out" }
        );
    });
    
    if (hint) {
        gsap.to(hint, {
            opacity: 1,
            duration: 0.8,
            delay: 2.5,
            ease: "power2.out"
        });
    }
}

function setupParticles() {
    const container = document.getElementById('particles1');
    if (!container) return;
    
    // Create hearts
    for (let i = 0; i < 15; i++) {
        createParticle(container, 'heart', '💕');
    }
    
    // Create dust particles
    for (let i = 0; i < 20; i++) {
        createParticle(container, 'dust');
    }
}

function createParticle(container, type, emoji = null) {
    const particle = document.createElement('div');
    particle.className = `particle ${type}`;
    
    if (type === 'heart' && emoji) {
        particle.textContent = emoji;
    }
    
    const startX = Math.random() * 100;
    const delay = Math.random() * 8;
    const duration = 8 + Math.random() * 4;
    
    particle.style.left = `${startX}%`;
    particle.style.bottom = '-50px';
    particle.style.animationDelay = `${delay}s`;
    particle.style.animationDuration = `${duration}s`;
    
    container.appendChild(particle);
}

// ============================================
// SCENE 2: Тайна
// ============================================
function animateScene2() {
    const typewriterEl = document.getElementById('typewriterText');
    if (!typewriterEl) return;
    
    typewriterEl.innerHTML = '';
    const text = CONFIG.scenes.scene2.typewriterText;
    let index = 0;
    
    function type() {
        if (index < text.length) {
            typewriterEl.textContent = text.substring(0, index + 1);
            index++;
            setTimeout(type, 50);
        } else {
            // Add cursor
            const cursor = document.createElement('span');
            cursor.className = 'typewriter-cursor';
            typewriterEl.appendChild(cursor);
        }
    }
    
    setTimeout(type, 500);
    
    // Setup memory card
    const memoryCard = document.getElementById('memoryCard');
    if (memoryCard) {
        memoryCard.addEventListener('click', () => {
            memoryCard.classList.toggle('flipped');
        });
    }
}

// ============================================
// SCENE 3: POLAROID GALLERY
// ============================================

// Инициализация анимированного фона с сердечками
function initializeScene3Background() {
    const bgContainer = document.getElementById('scene3Bg');
    if (!bgContainer) return;
    
    // Очищаем контейнер
    bgContainer.innerHTML = '';
    
    // Определяем количество сердечек (12-18, меньше на мобилках)
    const isMobile = window.innerWidth < 768;
    const heartCount = isMobile ? 12 : 18;
    
    // Размеры и opacity
    const sizes = ['small', 'medium', 'large'];
    const opacities = ['low', 'medium', 'high'];
    
    // Создаём сердечки
    for (let i = 0; i < heartCount; i++) {
        const heart = document.createElement('div');
        heart.className = 'bg-heart';
        
        // Случайный размер (чаще маленькие и средние)
        const sizeRandom = Math.random();
        let sizeClass = 'size-small';
        if (sizeRandom > 0.7) {
            sizeClass = 'size-medium';
        }
        if (sizeRandom > 0.95) {
            sizeClass = 'size-large';
        }
        heart.classList.add(sizeClass);
        
        // Случайная opacity
        const opacityRandom = Math.random();
        let opacityClass = 'opacity-low';
        if (opacityRandom > 0.6) {
            opacityClass = 'opacity-medium';
        }
        if (opacityRandom > 0.85) {
            opacityClass = 'opacity-high';
        }
        heart.classList.add(opacityClass);
        
        // Случайная начальная позиция по горизонтали
        const startX = Math.random() * 100; // 0-100%
        heart.style.left = `${startX}%`;
        heart.style.bottom = '-50px'; // Начинаем снизу экрана
        
        bgContainer.appendChild(heart);
        
        // Анимация через GSAP
        const duration = 20 + Math.random() * 15; // 20-35 секунд
        const delay = Math.random() * 5; // Задержка до 5 секунд
        const xOffset = (Math.random() - 0.5) * 100; // Случайное смещение по X
        
        // Выбираем направление движения
        const direction = Math.random();
        let xMovement = 0;
        if (direction < 0.33) {
            xMovement = -30 - Math.random() * 20; // Влево
        } else if (direction < 0.66) {
            xMovement = 30 + Math.random() * 20; // Вправо
        }
        // Иначе прямо вверх
        
        // Определяем финальную opacity из класса
        let finalOpacity = 0.06;
        if (heart.classList.contains('opacity-medium')) {
            finalOpacity = 0.12;
        } else if (heart.classList.contains('opacity-high')) {
            finalOpacity = 0.16;
        }
        
        // Создаём бесконечную анимацию
        function animateHeart() {
            gsap.fromTo(heart,
                {
                    opacity: 0,
                    y: window.innerHeight + 50,
                    x: 0,
                    scale: 0.5
                },
                {
                    opacity: finalOpacity,
                    y: -100,
                    x: xMovement,
                    scale: 1,
                    duration: duration,
                    ease: "none",
                    onComplete: animateHeart // Повторяем анимацию
                }
            );
        }
        
        // Запускаем анимацию с задержкой
        setTimeout(animateHeart, delay * 1000);
        
        // Добавляем лёгкое покачивание для естественности
        gsap.to(heart, {
            rotation: (Math.random() - 0.5) * 20,
            duration: 3 + Math.random() * 2,
            repeat: -1,
            yoyo: true,
            ease: "sine.inOut",
            delay: delay
        });
    }
}

function initializeGallery() {
    const container = document.getElementById('polaroidContainer');
    if (!container) return;
    
    container.innerHTML = '';
    
    // Создаём polaroid фото для всех изображений
    CONFIG.gallery.forEach((item, index) => {
        const polaroid = document.createElement('div');
        polaroid.className = 'polaroid-photo';
        polaroid.dataset.index = index;
        
        // Добавляем класс для последней фотографии
        if (item.isLast) {
            polaroid.classList.add('is-last');
        }
        
        const img = document.createElement('img');
        img.src = item.image;
        img.alt = item.title || item.caption || `Фотография ${index + 1}`;
        img.onerror = function() {
            // Placeholder if image doesn't exist
            this.style.background = 'linear-gradient(135deg, #ff6b9d, #ff8fb3)';
            this.style.display = 'flex';
            this.style.alignItems = 'center';
            this.style.justifyContent = 'center';
            this.style.color = 'white';
            this.style.fontSize = '2rem';
            this.textContent = '💕';
        };
        
        polaroid.appendChild(img);
        polaroid.addEventListener('click', () => openGalleryModal(index));
        container.appendChild(polaroid);
    });
}

function openGalleryModal(index) {
    const modal = document.getElementById('galleryModal');
    const modalImage = document.getElementById('modalImage');
    const modalTitle = document.getElementById('modalTitle');
    const modalText = document.getElementById('modalText');
    const modalBackdrop = document.getElementById('modalBackdrop');
    
    if (!modal || !modalImage || !modalTitle || !modalText) return;
    
    const item = CONFIG.gallery[index];
    modalImage.src = item.image;
    modalTitle.textContent = item.title || '';
    modalText.textContent = item.caption || '';
    
    // Показываем модальное окно
    modal.classList.add('active');
    
    // Анимация появления: затемнение фона + увеличение фото
    gsap.set(modalBackdrop, { opacity: 0 });
    gsap.set(modalImage, { scale: 0.8, opacity: 0 });
    gsap.set([modalTitle, modalText], { opacity: 0, y: 20 });
    
    gsap.to(modalBackdrop, {
        opacity: 1,
        duration: 0.4,
        ease: "power2.out"
    });
    
    gsap.to(modalImage, {
        scale: 1,
        opacity: 1,
        duration: 0.5,
        ease: "back.out(1.2)",
        delay: 0.1
    });
    
    gsap.to(modalTitle, {
        opacity: 1,
        y: 0,
        duration: 0.4,
        ease: "power2.out",
        delay: 0.3
    });
    
    gsap.to(modalText, {
        opacity: 1,
        y: 0,
        duration: 0.4,
        ease: "power2.out",
        delay: 0.4
    });
}

function closeGalleryModal() {
    const modal = document.getElementById('galleryModal');
    const modalImage = document.getElementById('modalImage');
    const modalTitle = document.getElementById('modalTitle');
    const modalText = document.getElementById('modalText');
    const modalBackdrop = document.getElementById('modalBackdrop');
    
    if (!modal) return;
    
    // Анимация закрытия
    gsap.to([modalBackdrop, modalImage, modalTitle, modalText], {
        opacity: 0,
        duration: 0.3,
        ease: "power2.in",
        onComplete: () => {
            modal.classList.remove('active');
        }
    });
    
    gsap.to(modalImage, {
        scale: 0.8,
        duration: 0.3,
        ease: "power2.in"
    });
}

function animateScene3() {
    // Инициализируем фон с сердечками, если ещё не инициализирован
    const bgContainer = document.getElementById('scene3Bg');
    if (bgContainer && bgContainer.children.length === 0) {
        initializeScene3Background();
    }
    
    const container = document.getElementById('polaroidContainer');
    if (!container) return;
    
    const polaroids = container.querySelectorAll('.polaroid-photo');
    if (polaroids.length === 0) return;
    
    // Определяем, сколько фото показывать одновременно (3-5)
    const maxVisible = Math.min(5, polaroids.length);
    const lastPolaroid = Array.from(polaroids).find(p => p.classList.contains('is-last'));
    
    // Собираем видимые фотографии: первые maxVisible, исключая последнюю (если она там есть)
    const visiblePolaroids = Array.from(polaroids)
        .filter(p => !p.classList.contains('is-last'))
        .slice(0, maxVisible - (lastPolaroid ? 1 : 0)); // Оставляем место для последней
    
    // Анимация появления обычных фото: снизу вверх + fade-in с stagger
    visiblePolaroids.forEach((polaroid, index) => {
        // Случайный поворот от -3° до +3°
        const rotation = -3 + Math.random() * 6;
        polaroid.style.transform = `rotate(${rotation}deg)`;
        
        // Анимация: снизу вверх + fade-in
        gsap.fromTo(polaroid,
            {
                opacity: 0,
                y: 100,
                scale: 0.8
            },
            {
                opacity: 1,
                y: 0,
                scale: 1,
                duration: 0.8,
                delay: index * 0.15, // Stagger эффект
                ease: "back.out(1.2)"
            }
        );
    });
    
    // Особенная анимация для последней фотографии (с поросятами)
    if (lastPolaroid) {
        // Случайный поворот
        const rotation = -3 + Math.random() * 6;
        lastPolaroid.style.transform = `rotate(${rotation}deg)`;
        
        // Появляется последней с bounce-анимацией
        const lastIndex = Array.from(polaroids).indexOf(lastPolaroid);
        const delay = lastIndex * 0.15 + 0.5; // Задержка после остальных
        
        gsap.fromTo(lastPolaroid,
            {
                opacity: 0,
                y: 100,
                scale: 0.5,
                rotation: rotation - 10
            },
            {
                opacity: 1,
                y: 0,
                scale: 1,
                rotation: rotation,
                duration: 1,
                delay: delay,
                ease: "elastic.out(1, 0.5)", // Bounce эффект
                onComplete: () => {
                    // Небольшой bounce после появления
                    gsap.to(lastPolaroid, {
                        scale: 1.05,
                        duration: 0.2,
                        yoyo: true,
                        repeat: 1,
                        ease: "power2.inOut"
                    });
                }
            }
        );
    }
    
    // Управление видимостью: показываем только 3-5 фото одновременно
    // Остальные скрываем, но они в DOM для возможного скролла
    polaroids.forEach((polaroid) => {
        const isVisible = visiblePolaroids.includes(polaroid) || polaroid.classList.contains('is-last');
        if (!isVisible) {
            polaroid.style.display = 'none';
        } else {
            polaroid.style.display = 'block';
        }
    });
}

// ============================================
// SCENE 4: Мини-игра
// ============================================
function initializeGame() {
    const gameArea = document.getElementById('gameArea');
    if (!gameArea) return;
    
    // Keyboard controls
    document.addEventListener('keydown', (e) => {
        if (currentScene !== 5) return;
        
        if (e.key === 'ArrowLeft' || e.key === 'a' || e.key === 'A') {
            moveBasket(-5);
        } else if (e.key === 'ArrowRight' || e.key === 'd' || e.key === 'D') {
            moveBasket(5);
        }
    });
    
    // Touch controls
    let touchStartX = 0;
    gameArea.addEventListener('touchstart', (e) => {
        touchStartX = e.touches[0].clientX;
    });
    
    gameArea.addEventListener('touchmove', (e) => {
        if (!touchStartX) return;
        const touchX = e.touches[0].clientX;
        const diff = touchX - touchStartX;
        moveBasket(diff / 10);
        touchStartX = touchX;
    });
    
    // Mouse controls
    gameArea.addEventListener('mousemove', (e) => {
        if (currentScene !== 5) return;
        const rect = gameArea.getBoundingClientRect();
        const mouseX = e.clientX - rect.left;
        basketPosition = (mouseX / rect.width) * 100;
        updateBasketPosition();
    });
}

function resetGame() {
    gameScore = 0;
    gameCompleted = false;
    gameHearts = [];
    basketPosition = 50;
    
    const gameScoreEl = document.getElementById('gameScore');
    const gameCompleteEl = document.getElementById('gameComplete');
    const gameNextBtn = document.getElementById('gameNextBtn');
    
    if (gameScoreEl) gameScoreEl.textContent = '0';
    if (gameCompleteEl) {
        gameCompleteEl.classList.remove('show');
    }
    if (gameNextBtn) {
        gameNextBtn.style.display = 'none';
    }
    
    // Clear existing hearts
    const gameArea = document.getElementById('gameArea');
    if (gameArea) {
        const hearts = gameArea.querySelectorAll('.game-heart');
        hearts.forEach(h => h.remove());
    }
    
    // Обновляем позицию корзинки
    updateBasketPosition();
    
    // Start game
    if (currentScene === 5) {
        // Небольшая задержка перед запуском для плавности
        setTimeout(() => {
            startGame();
        }, 300);
    }
}

function startGame() {
    // Останавливаем предыдущую анимацию если есть
    if (gameAnimationId) {
        cancelAnimationFrame(gameAnimationId);
    }
    
    // Сбрасываем состояние игры
    gameCompleted = false;
    gameHearts = [];
    
    function gameLoop() {
        // ВАЖНО: Проверяем, что мы всё ещё на сцене 5
        if (currentScene !== 5) {
            console.log('⚠️ Game loop stopped: not on scene 5');
            if (gameAnimationId) {
                cancelAnimationFrame(gameAnimationId);
                gameAnimationId = null;
            }
            return;
        }
        
        // Спавним сердечки случайным образом
        if (Math.random() < 0.04 && !gameCompleted) {
            spawnHeart();
        }
        
        // Обновляем позиции сердечек
        updateHearts();
        
        // Продолжаем цикл если игра не завершена И мы на сцене 5
        if (!gameCompleted && currentScene === 5) {
            gameAnimationId = requestAnimationFrame(gameLoop);
        } else {
            // Останавливаем анимацию при завершении или выходе со сцены
            if (gameAnimationId) {
                cancelAnimationFrame(gameAnimationId);
                gameAnimationId = null;
            }
        }
    }
    
    // Запускаем игровой цикл
    gameLoop();
}

function spawnHeart() {
    // Проверяем, что мы на сцене 5
    if (currentScene !== 5) {
        return;
    }
    
    const gameArea = document.getElementById('gameArea');
    if (!gameArea) return;
    
    const heart = document.createElement('div');
    heart.className = 'game-heart';
    heart.textContent = '💕';
    heart.style.left = `${Math.random() * 85 + 7.5}%`;
    heart.style.top = '-50px';
    heart.style.position = 'absolute';
    heart.style.zIndex = '5';
    
    const fallSpeed = 2.5 + Math.random() * 2.5; // Скорость падения
    heart.dataset.speed = fallSpeed;
    heart.dataset.startTime = Date.now();
    
    gameArea.appendChild(heart);
    gameHearts.push(heart);
}

function updateHearts() {
    // Проверяем, что мы на сцене 5
    if (currentScene !== 5) {
        return;
    }
    
    const gameArea = document.getElementById('gameArea');
    const basket = document.getElementById('gameBasket');
    if (!gameArea || !basket) return;
    
    const basketRect = basket.getBoundingClientRect();
    const areaRect = gameArea.getBoundingClientRect();
    
    // Обновляем в обратном порядке, чтобы правильно удалять элементы
    for (let i = gameHearts.length - 1; i >= 0; i--) {
        const heart = gameHearts[i];
        if (!heart || !heart.parentElement) {
            gameHearts.splice(i, 1);
            continue;
        }
        
        const startTime = parseInt(heart.dataset.startTime) || Date.now();
        const speed = parseFloat(heart.dataset.speed) || 3;
        const elapsed = (Date.now() - startTime) / 16.67; // frames
        const top = -50 + elapsed * speed;
        
        // Обновляем позицию
        heart.style.top = `${top}px`;
        heart.style.transform = `rotate(${elapsed * 2}deg)`;
        
        // Проверяем коллизию
        const heartRect = heart.getBoundingClientRect();
        if (
            heartRect.bottom >= basketRect.top &&
            heartRect.top <= basketRect.bottom &&
            heartRect.left >= basketRect.left - 30 &&
            heartRect.right <= basketRect.right + 30
        ) {
            // Поймано!
            heart.remove();
            gameHearts.splice(i, 1);
            gameScore++;
            updateGameScore();
            
            // Создаём эффект поимки
            createCatchEffect(heartRect.left + heartRect.width / 2, heartRect.top);
            continue;
        }
        
        // Удаляем если вышло за границы
        if (top > areaRect.height + 50) {
            heart.remove();
            gameHearts.splice(i, 1);
        }
    }
}

function moveBasket(delta) {
    basketPosition = Math.max(5, Math.min(95, basketPosition + delta));
    updateBasketPosition();
}

function updateBasketPosition() {
    const basket = document.getElementById('gameBasket');
    if (!basket) return;
    basket.style.left = `${basketPosition}%`;
}

function updateGameScore() {
    const scoreEl = document.getElementById('gameScore');
    if (scoreEl) {
        scoreEl.textContent = gameScore;
    }
    
    if (gameScore >= gameTarget && !gameCompleted) {
        completeGame();
    }
}

function completeGame() {
    gameCompleted = true;
    const gameCompleteEl = document.getElementById('gameComplete');
    const gameNextBtn = document.getElementById('gameNextBtn');
    
    if (gameCompleteEl) {
        gameCompleteEl.classList.add('show');
    }
    
    if (gameNextBtn) {
        setTimeout(() => {
            gameNextBtn.style.display = 'inline-block';
            gsap.fromTo(gameNextBtn,
                { opacity: 0, y: 20 },
                { opacity: 1, y: 0, duration: 0.5 }
            );
        }, 500);
    }
    
    // Create celebration effect
    createCelebrationEffect();
}

function createCatchEffect(x, y) {
    // Проверяем, что мы на сцене 5 (мини-игра)
    if (currentScene !== 5) {
        console.warn('⚠️ createCatchEffect called outside scene 5, ignoring');
        return;
    }
    
    const effect = document.createElement('div');
    effect.className = 'catch-effect';
    effect.style.position = 'fixed';
    effect.style.left = `${x}px`;
    effect.style.top = `${y}px`;
    effect.style.fontSize = '2rem';
    effect.style.color = '#ff6b9d';
    effect.style.pointerEvents = 'none';
    effect.style.zIndex = '1000';
    effect.textContent = '+1';
    
    document.body.appendChild(effect);
    
    gsap.to(effect, {
        y: y - 50,
        opacity: 0,
        duration: 0.8,
        onComplete: () => {
            if (effect.parentElement) {
                effect.remove();
            }
        }
    });
}

function createCelebrationEffect() {
    const gameArea = document.getElementById('gameArea');
    if (!gameArea) return;
    
    for (let i = 0; i < 20; i++) {
        setTimeout(() => {
            const heart = document.createElement('div');
            heart.className = 'game-heart';
            heart.textContent = '💕';
            heart.style.left = `${Math.random() * 100}%`;
            heart.style.top = `${Math.random() * 100}%`;
            heart.style.position = 'absolute';
            heart.style.animation = 'confetti-fall 2s ease-out forwards';
            
            gameArea.appendChild(heart);
            
            setTimeout(() => heart.remove(), 2000);
        }, i * 100);
    }
}

// ============================================
// SCENE 5: Нарастание эмоций
// ============================================
function initializeReasons() {
    const container = document.getElementById('reasonsContainer');
    if (!container) {
        console.error('reasonsContainer not found');
        return;
    }
    
    container.innerHTML = '';
    
    const reasons = CONFIG.scenes.scene6.reasons || [];
    if (reasons.length === 0) {
        console.warn('No reasons configured for scene 6');
        return;
    }
    
    console.log(`Creating ${reasons.length} reason cards`);
    
    reasons.forEach((reason, index) => {
        const card = document.createElement('div');
        card.className = 'reason-card';
        
        // Сразу делаем видимым
        card.style.opacity = '1';
        card.style.transform = 'translateY(0)';
        card.style.visibility = 'visible';
        card.style.display = 'block';
        
        const title = document.createElement('div');
        title.className = 'reason-title';
        title.textContent = reason.title || '';
        title.style.color = 'var(--accent)';
        
        const text = document.createElement('div');
        text.className = 'reason-text';
        // Заменяем \n на <br> для корректного отображения переносов строк
        const textWithBreaks = (reason.text || '').replace(/\n/g, '<br>');
        text.innerHTML = textWithBreaks;
        text.style.color = 'var(--text-muted)';
        
        card.appendChild(title);
        card.appendChild(text);
        container.appendChild(card);
        
        console.log(`Created card ${index + 1}: ${reason.title}`);
    });
    
    console.log(`Initialized ${reasons.length} reason cards`);
    
    // Принудительно показываем контейнер
    container.style.display = 'grid';
    container.style.opacity = '1';
    container.style.visibility = 'visible';
}

function animateScene6Reasons() {
    console.log('=== animateScene6Reasons START ===');
    console.log('currentScene:', currentScene);
    
    // Проверяем, что сцена активна
    const scene6 = document.getElementById('scene-6');
    if (!scene6) {
        console.error('❌ Scene 6 element not found!');
        return;
    }
    
    console.log('✅ Scene 6 element found');
    scene6.classList.add('active');
    
    // Принудительно показываем сцену через cssText для максимального приоритета
    scene6.style.cssText = `
        opacity: 1 !important;
        visibility: visible !important;
        display: flex !important;
        position: absolute !important;
        top: 0 !important;
        left: 0 !important;
        width: 100% !important;
        height: 100vh !important;
        z-index: 10 !important;
        background: linear-gradient(135deg, #2d1b3d 0%, #1a1a2e 50%, #0a0a0f 100%) !important;
    `;
    
    // Убеждаемся, что карточки инициализированы
    initializeReasons();
    
    // Принудительно показываем контент
    const reasonsScene = document.querySelector('#scene-6 .reasons-scene');
    if (reasonsScene) {
        reasonsScene.style.cssText = `
            opacity: 1 !important;
            visibility: visible !important;
            display: flex !important;
            position: relative !important;
            z-index: 10 !important;
            width: 100% !important;
            max-width: 900px !important;
            flex-direction: column !important;
            justify-content: center !important;
        `;
        console.log('✅ reasons-scene found and styled');
    } else {
        console.error('❌ reasons-scene not found!');
    }
    
    // Принудительно показываем заголовок
    const title = document.querySelector('#scene-6 .scene-title');
    if (title) {
        title.style.cssText = `
            opacity: 1 !important;
            visibility: visible !important;
            display: block !important;
            color: white !important;
            font-size: clamp(2rem, 6vw, 3.5rem) !important;
            margin-bottom: 2rem !important;
        `;
        console.log('✅ Title found and styled:', title.textContent);
    } else {
        console.error('❌ Title not found!');
    }
    
    // Принудительно показываем контейнер карточек
    const container = document.getElementById('reasonsContainer');
    if (container) {
        container.style.cssText = `
            opacity: 1 !important;
            visibility: visible !important;
            display: grid !important;
            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)) !important;
            gap: 1rem !important;
            margin: 2rem 0 !important;
            position: relative !important;
            z-index: 10 !important;
        `;
        console.log('✅ Container found and styled');
    } else {
        console.error('❌ reasonsContainer not found!');
    }
    
    // Animate bokeh background
    try {
        setupBokeh();
    } catch (error) {
        console.error('Error setting up bokeh:', error);
    }
    
    // Initialize cursor trail
    try {
        setupCursorTrail();
    } catch (error) {
        console.error('Error setting up cursor trail:', error);
    }
    
    // Initialize memories background (не блокирует рендеринг карточек)
    console.log('🔧 Calling setupMemoriesBackground...');
    try {
        setupMemoriesBackground();
        console.log('✅ setupMemoriesBackground called successfully');
    } catch (error) {
        console.error('❌ Error setting up memories background:', error);
        console.error('Error stack:', error.stack);
    }
    
    // Показываем карточки сразу без задержек
    setTimeout(() => {
        const cards = document.querySelectorAll('.reason-card');
        console.log(`Found ${cards.length} reason cards`);
        
        if (cards.length === 0) {
            console.warn('⚠️ No reason cards found, reinitializing...');
            initializeReasons();
            
            // Повторная попытка
            setTimeout(() => {
                const retryCards = document.querySelectorAll('.reason-card');
                console.log(`Retry: Found ${retryCards.length} reason cards`);
                retryCards.forEach(card => {
                    card.style.cssText = `
                        opacity: 1 !important;
                        transform: translateY(0) !important;
                        visibility: visible !important;
                        display: block !important;
                        background: rgba(255, 255, 255, 0.1) !important;
                        backdrop-filter: blur(20px) !important;
                        border: 1px solid rgba(255, 255, 255, 0.1) !important;
                        border-radius: 16px !important;
                        padding: 1rem !important;
                        color: white !important;
                        position: relative !important;
                        z-index: 10 !important;
                    `;
                    card.classList.add('visible');
                });
            }, 100);
            return;
        }
        
        // Сразу показываем все карточки с принудительными стилями
        cards.forEach((card, index) => {
            card.style.cssText = `
                opacity: 1 !important;
                transform: translateY(0) !important;
                visibility: visible !important;
                display: block !important;
                background: rgba(255, 255, 255, 0.1) !important;
                backdrop-filter: blur(20px) !important;
                border: 1px solid rgba(255, 255, 255, 0.1) !important;
                border-radius: 16px !important;
                padding: 1rem !important;
                color: white !important;
                position: relative !important;
                z-index: 10 !important;
            `;
            card.classList.add('visible');
            
            console.log(`✅ Card ${index + 1} styled:`, card.querySelector('.reason-title')?.textContent);
            
            // Анимация только для эффекта
            if (typeof gsap !== 'undefined') {
                gsap.fromTo(card,
                    { opacity: 0, y: 30 },
                    { opacity: 1, y: 0, duration: 0.8, delay: index * 0.1, ease: "power2.out" }
                );
            }
        });
        
        // Animate final line
        const finalLine = document.getElementById('finalLine');
        if (finalLine) {
            setTimeout(() => {
                finalLine.style.cssText = `
                    opacity: 1 !important;
                    transform: translateY(0) !important;
                    visibility: visible !important;
                    display: block !important;
                    color: white !important;
                    font-size: clamp(1.5rem, 4vw, 2.5rem) !important;
                    margin-top: 2rem !important;
                `;
                finalLine.classList.add('visible');
                
                if (typeof gsap !== 'undefined') {
                    gsap.fromTo(finalLine,
                        { opacity: 0, y: 20 },
                        { opacity: 1, y: 0, duration: 1, ease: "power2.out" }
                    );
                }
            }, cards.length * 100 + 500);
        }
        
        console.log('=== animateScene6Reasons END ===');
    }, 100);
}

// Навигация удалена - переходы только через кнопки внутри сцен

// ============================================
// CURSOR TRAIL EFFECT
// ============================================
function setupCursorTrail() {
    const canvas = document.getElementById('cursorTrail');
    if (!canvas) return;
    
    const ctx = canvas.getContext('2d');
    if (!ctx) return;
    
    // Устанавливаем размеры canvas
    function resizeCanvas() {
        canvas.width = window.innerWidth;
        canvas.height = window.innerHeight;
    }
    resizeCanvas();
    window.addEventListener('resize', resizeCanvas);
    
    // Активируем canvas только на сцене 6
    if (currentScene === 6) {
        canvas.classList.add('active');
    } else {
        canvas.classList.remove('active');
    }
    
    let points = [];
    let isDrawing = false;
    const maxPoints = 50; // Максимальное количество точек для плавности
    const fadeSpeed = 0.05; // Скорость исчезновения
    
    // Сохраняем точки движения мыши
    function addPoint(x, y) {
        points.push({ x, y, life: 1.0 });
        if (points.length > maxPoints) {
            points.shift();
        }
    }
    
    // Рисуем плавную линию
    function drawTrail() {
        if (currentScene !== 6) {
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            points = [];
            requestAnimationFrame(drawTrail);
            return;
        }
        
        // Очищаем canvas БЕЗ затемнения (прозрачно)
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        
        if (points.length < 2) {
            requestAnimationFrame(drawTrail);
            return;
        }
        
        // Рисуем плавную кривую через точки
        ctx.beginPath();
        ctx.strokeStyle = 'rgba(255, 107, 157, 0.4)';
        ctx.lineWidth = 2;
        ctx.lineCap = 'round';
        ctx.lineJoin = 'round';
        
        // Используем quadraticCurveTo для плавных изгибов
        for (let i = 0; i < points.length - 1; i++) {
            const point = points[i];
            const nextPoint = points[i + 1];
            
            // Уменьшаем прозрачность по мере старения точки
            point.life -= fadeSpeed;
            
            if (point.life <= 0) {
                points.splice(i, 1);
                i--;
                continue;
            }
            
            const alpha = point.life * 0.4;
            ctx.strokeStyle = `rgba(255, 107, 157, ${alpha})`;
            ctx.lineWidth = 2 * point.life;
            
            if (i === 0) {
                ctx.moveTo(point.x, point.y);
            } else {
                const midX = (point.x + nextPoint.x) / 2;
                const midY = (point.y + nextPoint.y) / 2;
                ctx.quadraticCurveTo(point.x, point.y, midX, midY);
            }
        }
        
        // Добавляем свечение
        ctx.shadowBlur = 15;
        ctx.shadowColor = 'rgba(255, 107, 157, 0.6)';
        ctx.stroke();
        ctx.shadowBlur = 0;
        
        requestAnimationFrame(drawTrail);
    }
    
    // Обработчики событий мыши
    function handleMouseMove(e) {
        if (currentScene !== 6) return;
        addPoint(e.clientX, e.clientY);
    }
    
    function handleMouseEnter() {
        if (currentScene === 6) {
            isDrawing = true;
            canvas.classList.add('active');
        }
    }
    
    function handleMouseLeave() {
        isDrawing = false;
    }
    
    // Привязываем события только к сцене 6
    const scene6 = document.getElementById('scene-6');
    if (scene6) {
        scene6.addEventListener('mousemove', handleMouseMove);
        scene6.addEventListener('mouseenter', handleMouseEnter);
        scene6.addEventListener('mouseleave', handleMouseLeave);
    }
    
    // Запускаем анимацию
    drawTrail();
}

// ============================================
// MEMORIES BACKGROUND EFFECT
// ============================================
function setupMemoriesBackground() {
    console.log('=== setupMemoriesBackground START ===');
    console.log('Current scene:', currentScene);
    
    const container = document.getElementById('memoriesBackground');
    if (!container) {
        console.error('❌ Container not found!');
        return;
    }
    
    console.log('✅ Container found');
    
    // Принудительно показываем контейнер
    container.style.cssText = `
        position: fixed !important;
        top: 0 !important;
        left: 0 !important;
        width: 100vw !important;
        height: 100vh !important;
        overflow: visible !important;
        z-index: 1 !important;
        pointer-events: none !important;
        visibility: visible !important;
        opacity: 1 !important;
        display: block !important;
        background: transparent !important;
    `;
    
    // Проверяем видимость контейнера
    const computedStyle = window.getComputedStyle(container);
    console.log('Container computed styles:', {
        display: computedStyle.display,
        visibility: computedStyle.visibility,
        opacity: computedStyle.opacity,
        zIndex: computedStyle.zIndex,
        position: computedStyle.position,
        width: computedStyle.width,
        height: computedStyle.height
    });
    
    const images = CONFIG.scenes.scene6.backgroundImages || [];
    if (images.length === 0) {
        console.error('❌ No images found in CONFIG');
        return;
    }
    
    console.log(`✅ Found ${images.length} images in CONFIG:`, images);
    
    // Очищаем контейнер
    container.innerHTML = '';
    
    // КОНТРОЛЬ УНИКАЛЬНОСТИ: очищаем список активных изображений при входе в сцену
    // (на случай повторного входа или если предыдущие фото не успели завершить анимацию)
    if (typeof window.activeImagePaths !== 'undefined' && window.activeImagePaths) {
        window.activeImagePaths.clear();
    }
    
    // DEBUG MODE: флаг для включения debug режима (10 секунд)
    const DEBUG_MODE = true; // Установить false для отключения
    const DEBUG_DURATION = 10000; // 10 секунд
    
    // Создаём тестовую фотографию для проверки видимости (только в debug режиме)
    function createTestPhoto() {
        if (!DEBUG_MODE) return;
        
        const testImg = images[0];
        console.log('🧪 [DEBUG] Creating TEST photo:', testImg);
        const testPhoto = document.createElement('img');
        testPhoto.src = testImg;
        testPhoto.className = 'flying-photo test-photo';
        testPhoto.style.cssText = `
            position: fixed !important;
            left: 50% !important;
            top: 50% !important;
            transform: translate(-50%, -50%) !important;
            width: 200px !important;
            height: 200px !important;
            object-fit: cover !important;
            border-radius: 10px !important;
            opacity: 0.9 !important;
            filter: none !important;
            z-index: 9999 !important;
            visibility: visible !important;
            display: block !important;
            border: 4px solid red !important;
            box-shadow: 0 0 20px rgba(255, 0, 0, 0.8) !important;
        `;
        container.appendChild(testPhoto);
        
        testPhoto.onload = function() {
            console.log('✅✅✅ [DEBUG] TEST PHOTO LOADED!');
            console.log('[DEBUG] Test photo computed opacity:', window.getComputedStyle(this).opacity);
            console.log('[DEBUG] Test photo computed visibility:', window.getComputedStyle(this).visibility);
            console.log('[DEBUG] Test photo computed display:', window.getComputedStyle(this).display);
            console.log('[DEBUG] Test photo computed zIndex:', window.getComputedStyle(this).zIndex);
            
            // Удаляем тестовую фотографию через DEBUG_DURATION
            setTimeout(() => {
                if (this.parentElement) {
                    this.remove();
                    console.log('[DEBUG] Test photo removed');
                }
            }, DEBUG_DURATION);
        };
        
        testPhoto.onerror = function() {
            console.error('❌ [DEBUG] TEST PHOTO FAILED TO LOAD!');
            console.error('[DEBUG] Image path:', testImg);
            console.error('[DEBUG] Full src:', this.src);
            console.error('[DEBUG] Container children:', container.children.length);
        };
    }
    
    // Создаём тестовую фотографию (только в debug режиме)
    if (DEBUG_MODE) {
        createTestPhoto();
    }
    
    let activePhotos = []; // DOM элементы активных фотографий
    // КОНТРОЛЬ УНИКАЛЬНОСТИ: отслеживаем пути к изображениям, которые сейчас летят на экране
    // Используем window для доступа из других функций (например, cleanupSceneEffects)
    if (!window.activeImagePaths) {
        window.activeImagePaths = new Set();
    }
    const activeImagePaths = window.activeImagePaths; // Локальная ссылка для удобства
    // УВЕЛИЧЕНО: Максимум одновременно видимых фотографий (было 4, стало 5 для более живого потока)
    const maxActive = 5;
    let spawnIntervalId = null;
    
    function spawnFlyingPhoto() {
        // Проверяем, что мы на сцене 6
        if (currentScene !== 6) {
            console.log('⚠️ Not on scene 6, stopping spawn');
            if (spawnIntervalId) {
                clearInterval(spawnIntervalId);
                spawnIntervalId = null;
            }
            return;
        }
        
        // Проверяем лимит активных фотографий
        if (activePhotos.length >= maxActive) {
            return;
        }
        
        // КОНТРОЛЬ УНИКАЛЬНОСТИ: выбираем изображение, которое сейчас не летит на экране
        // Исключаем из выбора те изображения, что уже активны
        const availableImages = images.filter(img => !activeImagePaths.has(img));
        
        // Если все изображения активны, используем все (но это маловероятно)
        const imagesToChooseFrom = availableImages.length > 0 ? availableImages : images;
        
        // Выбираем случайное изображение из доступных
        const randomImage = imagesToChooseFrom[Math.floor(Math.random() * imagesToChooseFrom.length)];
        console.log(`📸 Spawning photo: ${randomImage} (active: ${activeImagePaths.size}/${images.length})`);
        
        // Добавляем путь в множество активных изображений
        activeImagePaths.add(randomImage);
        
        const photo = document.createElement('img');
        photo.src = randomImage;
        photo.alt = 'Memory';
        photo.className = 'flying-photo';
        
        // Случайная позиция по горизонтали (избегаем центр 30-70%)
        let leftPos;
        if (Math.random() < 0.5) {
            leftPos = Math.random() * 30; // Левая сторона 0-30%
        } else {
            leftPos = 70 + Math.random() * 30; // Правая сторона 70-100%
        }
        
        // УВЕЛИЧЕН РАЗМЕР: было 100-160px, стало 120-195px (+25% для лучшей читаемости)
        const size = 120 + Math.random() * 75; // 120-195px (увеличено на ~25%)
        
        // Случайная длительность анимации
        const duration = 15 + Math.random() * 10; // 15-25 секунд
        
        // DEBUG MODE: временно увеличиваем opacity и убираем blur
        const debugOpacity = DEBUG_MODE ? 0.6 : 0.25;
        const debugBlur = DEBUG_MODE ? 'blur(1px)' : 'blur(4px)';
        
        // Применяем стили
        photo.style.cssText = `
            position: fixed !important;
            left: ${leftPos}% !important;
            top: -200px !important;
            width: ${size}px !important;
            height: ${size}px !important;
            object-fit: cover !important;
            border-radius: 8px !important;
            opacity: ${debugOpacity} !important;
            filter: ${debugBlur} !important;
            -webkit-filter: ${debugBlur} !important;
            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.4) !important;
            pointer-events: none !important;
            z-index: 1 !important;
            visibility: visible !important;
            display: block !important;
            animation: photo-fall ${duration}s linear forwards !important;
        `;
        
        // В DEBUG MODE через 10 секунд возвращаем нормальные стили
        if (DEBUG_MODE) {
            setTimeout(() => {
                if (photo.parentElement) {
                    photo.style.opacity = '0.25';
                    photo.style.filter = 'blur(4px)';
                    photo.style.webkitFilter = 'blur(4px)';
                }
            }, DEBUG_DURATION);
        }
        
        // Обработка ошибок загрузки
        photo.onerror = function() {
            console.error('❌ [FAILED] Photo failed to load:', randomImage);
            console.error('[FAILED] Full path:', this.src);
            console.error('[FAILED] Check if file exists at:', this.src);
            if (this.parentElement) {
                this.remove();
            }
            activePhotos = activePhotos.filter(p => p !== photo);
            // КОНТРОЛЬ УНИКАЛЬНОСТИ: убираем путь из активных при ошибке загрузки
            activeImagePaths.delete(randomImage);
        };
        
        // Обработка успешной загрузки
        photo.onload = function() {
            console.log('✅ [LOADED] Photo loaded successfully:', randomImage);
            console.log('[LOADED] Photo in DOM:', this.parentElement === container);
            console.log('[LOADED] Total active photos:', activePhotos.length);
            if (DEBUG_MODE) {
                const computed = window.getComputedStyle(this);
                console.log('[DEBUG] Photo computed styles:', {
                    opacity: computed.opacity,
                    visibility: computed.visibility,
                    display: computed.display,
                    zIndex: computed.zIndex,
                    position: computed.position
                });
            }
        };
        
        // Добавляем обработчик завершения анимации
        photo.addEventListener('animationend', function() {
            console.log('✅ Animation ended for:', randomImage);
            if (this.parentElement) {
                this.remove();
            }
            activePhotos = activePhotos.filter(p => p !== photo);
            // КОНТРОЛЬ УНИКАЛЬНОСТИ: убираем путь из активных после завершения анимации
            // Теперь это изображение может быть использовано снова
            activeImagePaths.delete(randomImage);
        });
        
        // Добавляем фото в контейнер
        container.appendChild(photo);
        activePhotos.push(photo);
        
        console.log(`✅ Photo added to DOM. Total active: ${activePhotos.length}`);
        console.log('Container children count:', container.children.length);
        
        // Проверяем через небольшую задержку
        setTimeout(() => {
            const photosInDOM = container.querySelectorAll('.flying-photo:not(.test-photo)');
            console.log(`Photos in DOM after 500ms: ${photosInDOM.length}`);
            photosInDOM.forEach((p, i) => {
                const computed = window.getComputedStyle(p);
                console.log(`Photo ${i}: opacity=${computed.opacity}, visibility=${computed.visibility}, display=${computed.display}, zIndex=${computed.zIndex}`);
            });
        }, 500);
    }
    
    // ВОЛНОВОЙ СПАВН: иногда спавним несколько фото подряд для эффекта "волны воспоминаний"
    function spawnWave() {
        // Определяем количество фото в волне (1-3, чаще 1-2)
        const waveSize = Math.random() < 0.3 ? 3 : (Math.random() < 0.6 ? 2 : 1);
        console.log(`🌊 Spawning wave of ${waveSize} photos`);
        
        // Спавним фото одно за другим с небольшой задержкой
        for (let i = 0; i < waveSize; i++) {
            setTimeout(() => {
                if (currentScene === 6 && activePhotos.length < maxActive) {
                    spawnFlyingPhoto();
                }
            }, i * 400); // Задержка 400ms между фото в волне
        }
    }
    
    // Запускаем спавн фотографий с поддержкой волнового эффекта
    function startSpawning() {
        if (currentScene !== 6) {
            if (spawnIntervalId) {
                clearInterval(spawnIntervalId);
                spawnIntervalId = null;
            }
            return;
        }
        
        // ВОЛНОВОЙ СПАВН: используем функцию волны вместо одиночного спавна
        spawnWave();
        
        // УВЕЛИЧЕНА ЧАСТОТА: интервал спавна уменьшен для более плотного потока
        // Было: 3000-5000ms (3-5 сек), стало: 2000-3500ms (2-3.5 сек) - примерно на 30% чаще
        const nextSpawn = 2000 + Math.random() * 1500; // 2-3.5 секунды (более живой поток)
        spawnIntervalId = setTimeout(startSpawning, nextSpawn);
    }
    
    // Начинаем спавн сразу
    console.log('🚀 Starting photo spawning...');
    startSpawning();
    
    // УСКОРЕН СТАРТ: первая волна воспоминаний появляется быстрее для более живого потока
    // Было: 1000ms, стало: 500ms
    setTimeout(() => {
        if (currentScene === 6) {
            spawnWave(); // Используем волновой спавн для старта
        }
    }, 500);
    
    console.log('✅ Memories background setup complete');
    console.log('=== setupMemoriesBackground END ===');
}

function setupBokeh() {
    const container = document.getElementById('bokehBackground');
    if (!container) return;
    
    container.innerHTML = '';
    
    for (let i = 0; i < 8; i++) {
        const circle = document.createElement('div');
        circle.className = 'bokeh-circle';
        const size = 100 + Math.random() * 200;
        circle.style.width = `${size}px`;
        circle.style.height = `${size}px`;
        circle.style.left = `${Math.random() * 100}%`;
        circle.style.top = `${Math.random() * 100}%`;
        circle.style.animationDelay = `${Math.random() * 20}s`;
        container.appendChild(circle);
    }
}

// ============================================
// SCENE 4: Кино-момент
// ============================================
function animateScene4() {
    console.log('=== animateScene4 START ===');
    
    // ПРОСТОЕ И НАДЁЖНОЕ РЕШЕНИЕ: Создаём кнопку "Далее" программно
    let scene4NextBtn = document.getElementById('scene4NextBtnFallback');
    if (!scene4NextBtn) {
        scene4NextBtn = document.createElement('button');
        scene4NextBtn.id = 'scene4NextBtnFallback';
        scene4NextBtn.textContent = 'Далее →';
        scene4NextBtn.style.cssText = `
            position: fixed !important;
            bottom: 40px !important;
            left: 50% !important;
            transform: translateX(-50%) !important;
            z-index: 99999 !important;
            display: flex !important;
            align-items: center !important;
            justify-content: center !important;
            padding: 12px 32px !important;
            min-width: 220px !important;
            font-size: 1.2rem !important;
            font-weight: 600 !important;
            color: #fff !important;
            background: #ff6b9d !important;
            border: 2px solid #ff8fb3 !important;
            border-radius: 50px !important;
            cursor: pointer !important;
            box-shadow: 0 8px 32px rgba(255, 107, 157, 0.6) !important;
            backdrop-filter: blur(20px) !important;
            -webkit-backdrop-filter: blur(20px) !important;
            transition: all 0.3s ease !important;
            pointer-events: auto !important;
            visibility: visible !important;
            opacity: 1 !important;
        `;
        
        // Обработчик клика
        scene4NextBtn.onclick = function(e) {
            e.preventDefault();
            e.stopPropagation();
            console.log('✅ Кнопка "Далее" (fallback) кликнута, переходим на сцену 5');
            window.scrollTo({ top: 0, left: 0, behavior: 'instant' });
            setTimeout(() => {
                navigateToScene(5);
            }, 50);
        };
        
        // Hover эффект
        scene4NextBtn.onmouseenter = function() {
            this.style.background = '#ff8fb3';
            this.style.transform = 'translateX(-50%) translateY(-2px)';
            this.style.boxShadow = '0 12px 40px rgba(255, 107, 157, 0.7)';
        };
        scene4NextBtn.onmouseleave = function() {
            this.style.background = '#ff6b9d';
            this.style.transform = 'translateX(-50%)';
            this.style.boxShadow = '0 8px 32px rgba(255, 107, 157, 0.6)';
        };
        
        // Добавляем в body
        document.body.appendChild(scene4NextBtn);
        console.log('✅ Кнопка "Далее" (fallback) создана и добавлена в body');
    } else {
        // Если кнопка уже есть, просто показываем её
        scene4NextBtn.style.display = 'flex';
        scene4NextBtn.style.visibility = 'visible';
        scene4NextBtn.style.opacity = '1';
        scene4NextBtn.style.pointerEvents = 'auto';
        console.log('✅ Кнопка "Далее" (fallback) уже существует, показываем');
    }
    
    const scene4 = document.getElementById('scene-4');
    const cinemaIntro = document.getElementById('cinemaIntro');
    const cinemaText = document.getElementById('cinemaText');
    const videoContainer = document.getElementById('videoContainer');
    const cinemaVideo = document.getElementById('cinemaVideo');
    
    // ДИАГНОСТИКА: проверяем видимость элементов
    if (scene4) {
        const scene4Rect = scene4.getBoundingClientRect();
        console.log('Scene 4 rect:', scene4Rect);
        console.log('Scene 4 computed styles:', {
            display: window.getComputedStyle(scene4).display,
            visibility: window.getComputedStyle(scene4).visibility,
            opacity: window.getComputedStyle(scene4).opacity,
            zIndex: window.getComputedStyle(scene4).zIndex
        });
    }
    
    if (videoContainer) {
        const containerRect = videoContainer.getBoundingClientRect();
        console.log('Video container rect:', containerRect);
        console.log('Video container computed styles:', {
            display: window.getComputedStyle(videoContainer).display,
            visibility: window.getComputedStyle(videoContainer).visibility,
            opacity: window.getComputedStyle(videoContainer).opacity,
            zIndex: window.getComputedStyle(videoContainer).zIndex,
            width: window.getComputedStyle(videoContainer).width,
            height: window.getComputedStyle(videoContainer).height
        });
    }
    
    if (cinemaVideo) {
        const videoRect = cinemaVideo.getBoundingClientRect();
        console.log('Video rect:', videoRect);
        console.log('Video computed styles:', {
            display: window.getComputedStyle(cinemaVideo).display,
            visibility: window.getComputedStyle(cinemaVideo).visibility,
            opacity: window.getComputedStyle(cinemaVideo).opacity,
            width: window.getComputedStyle(cinemaVideo).width,
            height: window.getComputedStyle(cinemaVideo).height
        });
    }
    
    // Принудительно показываем сцену 4
    if (scene4) {
        scene4.style.cssText += `
            display: flex !important;
            visibility: visible !important;
            opacity: 1 !important;
            z-index: 10 !important;
        `;
    }
    
    // Принудительно показываем контент
    const cinemaScene = scene4?.querySelector('.cinema-scene');
    if (cinemaScene) {
        cinemaScene.style.cssText += `
            display: flex !important;
            visibility: visible !important;
            opacity: 1 !important;
            z-index: 5 !important;
        `;
    }
    
    if (!cinemaVideo || !CONFIG.scenes.scene4.videoFile) {
        console.error('❌ Video element or video file not found');
        return;
    }
    
    // Reset states - полностью сбрасываем состояние при входе в сцену
    if (videoContainer) {
        videoContainer.classList.remove('visible', 'playing');
    }
    if (cinemaIntro) {
        cinemaIntro.classList.remove('visible');
    }
    
    // Останавливаем видео и сбрасываем источник
    if (cinemaVideo) {
        cinemaVideo.pause();
        cinemaVideo.currentTime = 0;
        cinemaVideo.removeAttribute('src');
        cinemaVideo.load();
    }
    
    // Set video source
    cinemaVideo.src = CONFIG.scenes.scene4.videoFile;
    cinemaVideo.load();
    
    // Show intro text with pause
    if (cinemaText) {
        cinemaText.textContent = CONFIG.scenes.scene4.introText;
    }
    
    // Плавное появление текста с паузой
    if (cinemaIntro) {
        setTimeout(() => {
            cinemaIntro.classList.add('visible');
        }, 500);
    }
    
    // ПРИНУДИТЕЛЬНЫЙ ФОЛЛБЕК: Создаём/находим кнопку и гарантируем её наличие
    let btn = document.getElementById('cinemaNextBtn');
    if (!btn) {
        console.log('⚠️ Кнопка не найдена в DOM, создаём программно');
        btn = document.createElement('button');
        btn.id = 'cinemaNextBtn';
        btn.className = 'cta-button primary cinema-next';
        btn.setAttribute('data-next', '5');
        btn.textContent = 'Далее →';
        document.body.appendChild(btn);
        console.log('✅ Кнопка создана и добавлена в body');
    }
    
    // Принудительно устанавливаем стили для кнопки (fixed позиционирование)
    // ВАЖНО: кнопка должна быть видна СРАЗУ при входе в сцену
    btn.style.cssText = `
        position: fixed !important;
        left: 50% !important;
        bottom: 50px !important;
        transform: translateX(-50%) translateY(0) !important;
        z-index: 99999 !important;
        display: flex !important;
        visibility: visible !important;
        opacity: 1 !important;
        pointer-events: auto !important;
        min-width: 220px !important;
        padding: 12px 32px !important;
        font-size: 1.2rem !important;
        font-weight: 600 !important;
        background: #ff6b9d !important;
        border: 2px solid #ff8fb3 !important;
        border-radius: 50px !important;
        color: #fff !important;
        cursor: pointer !important;
        backdrop-filter: blur(20px) !important;
        -webkit-backdrop-filter: blur(20px) !important;
        box-shadow: 0 8px 32px rgba(255, 107, 157, 0.6) !important;
        transition: opacity 0.3s ease, transform 0.3s ease !important;
        align-items: center !important;
        justify-content: center !important;
    `;
    
    // Добавляем обработчик клика для перехода на сцену 5
    btn.onclick = function(e) {
        e.preventDefault();
        e.stopPropagation();
        console.log('✅ Кнопка "Далее" кликнута, переходим на сцену 5');
        window.scrollTo({top: 0, left: 0, behavior: 'instant'});
        setTimeout(() => {
            navigateToScene(5);
        }, 100);
    };
    
    // Обновляем ссылку на кнопку
    const cinemaNextBtn = btn;
    
    // ПРИНУДИТЕЛЬНАЯ ПРОВЕРКА ВИДИМОСТИ: убеждаемся, что кнопка видна
    requestAnimationFrame(() => {
        requestAnimationFrame(() => {
            const rect = cinemaNextBtn.getBoundingClientRect();
            const computed = window.getComputedStyle(cinemaNextBtn);
            console.log('🔍 Проверка кнопки:', {
                exists: !!cinemaNextBtn,
                display: computed.display,
                visibility: computed.visibility,
                opacity: computed.opacity,
                zIndex: computed.zIndex,
                position: computed.position,
                bottom: computed.bottom,
                left: computed.left,
                rect: rect,
                inViewport: rect.top >= 0 && rect.left >= 0 && rect.bottom <= window.innerHeight && rect.right <= window.innerWidth
            });
            
            // Принудительно показываем кнопку, если она скрыта
            if (computed.display === 'none' || computed.visibility === 'hidden' || parseFloat(computed.opacity) < 0.1) {
                console.log('⚠️ Кнопка скрыта, принудительно показываем');
                cinemaNextBtn.style.cssText += `
                    display: flex !important;
                    visibility: visible !important;
                    opacity: 1 !important;
                    pointer-events: auto !important;
                `;
            }
        });
    });
    
    // Кнопка уже видна через inline стили выше, но делаем дополнительную проверку
    // Флаг для отслеживания, показана ли уже кнопка
    let buttonShown = false;
    
    // Функция для показа кнопки (с защитой от повторных вызовов)
    function showNextButton() {
        if (cinemaNextBtn && !buttonShown) {
            buttonShown = true;
            console.log('✅ Showing next button');
            // Принудительно показываем кнопку
            cinemaNextBtn.style.cssText += `
                display: flex !important;
                visibility: visible !important;
                opacity: 1 !important;
                pointer-events: auto !important;
                transform: translateX(-50%) translateY(0) !important;
            `;
            cinemaNextBtn.classList.add('visible');
            
            // Очищаем все таймауты, так как кнопка уже показана
            if (fallbackTimeout) clearTimeout(fallbackTimeout);
            if (checkInterval) clearInterval(checkInterval);
        }
    }
    
    // Показываем кнопку СРАЗУ при входе в сцену (не ждём таймаутов)
    buttonShown = true;
    showNextButton();
    
    // Переменные для таймаутов (для очистки при необходимости)
    let fallbackTimeout = null;
    let checkInterval = null;
    
    // Дополнительная проверка через 0.5 секунды (на всякий случай)
    setTimeout(() => {
        const computed = window.getComputedStyle(cinemaNextBtn);
        if (computed.display === 'none' || computed.visibility === 'hidden' || parseFloat(computed.opacity) < 0.1) {
            console.log('⚠️ Кнопка скрыта, принудительно показываем');
            cinemaNextBtn.style.cssText += `
                display: flex !important;
                visibility: visible !important;
                opacity: 1 !important;
                pointer-events: auto !important;
                transform: translateX(-50%) translateY(0) !important;
            `;
            cinemaNextBtn.classList.add('visible');
        }
    }, 500);
    
    // Показываем видео после текста с паузой (fade-in + scale)
    const videoShowDelay = 3000; // 3 секунды после текста
    setTimeout(() => {
        if (videoContainer) {
            videoContainer.classList.add('visible');
            
            // Запускаем fallback таймаут: показываем кнопку через 5 секунд после появления видео
            // (3 сек задержка показа видео + 5 сек = 8 сек от начала, но логичнее отсчитывать от появления видео)
            fallbackTimeout = setTimeout(() => {
                if (!buttonShown) {
                    console.log('Fallback: showing next button 5 seconds after video appeared');
                    showNextButton();
                }
            }, 5000); // 5 секунд после появления видео
            
            // Play video
            cinemaVideo.play()
                .then(() => {
                    console.log('Video started playing');
                    // Запускаем cinematic zoom-in
                    videoContainer.classList.add('playing');
                })
                .catch((error) => {
                    console.log('Video play failed:', error);
                    // If autoplay fails, show next button immediately
                    if (!buttonShown) {
                        setTimeout(() => {
                            showNextButton();
                        }, 2000);
                    }
                });
        }
    }, videoShowDelay);
    
    // Handle video end - пауза тишины перед кнопкой
    cinemaVideo.addEventListener('ended', () => {
        console.log('Video ended, showing next button');
        // Убираем zoom анимацию
        if (videoContainer) {
            videoContainer.classList.remove('playing');
        }
        
        // Пауза тишины перед показом кнопки
        setTimeout(() => {
            showNextButton();
        }, 1500); // Пауза 1.5 секунды после окончания видео
    }, { once: true });
    
    // Показываем кнопку когда видео почти закончилось (через timeupdate)
    cinemaVideo.addEventListener('timeupdate', () => {
        if (cinemaVideo.duration && cinemaVideo.currentTime && !buttonShown) {
            const timeLeft = cinemaVideo.duration - cinemaVideo.currentTime;
            // Показываем кнопку за 3 секунды до конца или если видео закончилось
            if (timeLeft <= 3 || cinemaVideo.ended) {
                showNextButton();
            }
        }
    });
    
    // Показываем кнопку при первом клике по видео (любое взаимодействие)
    let videoClicked = false;
    cinemaVideo.addEventListener('click', () => {
        if (!videoClicked) {
            videoClicked = true;
            // Если видео на паузе - возобновляем, если играет - паузим
            if (cinemaVideo.paused) {
                cinemaVideo.play();
                if (videoContainer) {
                    videoContainer.classList.add('playing');
                }
            } else {
                cinemaVideo.pause();
                if (videoContainer) {
                    videoContainer.classList.remove('playing');
                }
            }
            
            // Показываем кнопку при первом клике (если ещё не показана)
            if (!buttonShown) {
                console.log('First video click, showing next button');
                showNextButton();
            }
        }
    });
    
    // Allow click to play/pause video
    cinemaVideo.addEventListener('click', () => {
        if (cinemaVideo.paused) {
            cinemaVideo.play();
            if (videoContainer) {
                videoContainer.classList.add('playing');
            }
        } else {
            cinemaVideo.pause();
            if (videoContainer) {
                videoContainer.classList.remove('playing');
            }
        }
    });
    
    // Обработка паузы пользователем
    cinemaVideo.addEventListener('pause', () => {
        if (videoContainer && !cinemaVideo.ended) {
            videoContainer.classList.remove('playing');
        }
    });
    
    // Обработка возобновления воспроизведения
    cinemaVideo.addEventListener('play', () => {
        if (videoContainer && !cinemaVideo.ended) {
            videoContainer.classList.add('playing');
        }
    });
}

// ============================================
// SCENE 7: Вопрос
// ============================================
function animateScene7() {
    const question = document.querySelector('.big-question');
    const buttons = document.querySelectorAll('.answer-btn');
    const errorMessage = document.getElementById('errorMessage');
    
    // Сбрасываем счётчик кликов при входе на сцену
    noClicks = 0;
    
    // Восстанавливаем кнопку "Нет", если она была заменена
    const allButtons = document.querySelectorAll('.answer-btn');
    if (allButtons.length >= 2) {
        const secondButton = allButtons[1];
        // Проверяем, не является ли это заменённой кнопкой (имеет data-answer="yes", но должна быть "no")
        if (secondButton.dataset.answer === 'yes' && secondButton.classList.contains('yes-btn') && secondButton.classList.contains('no-btn') === false) {
            // Восстанавливаем кнопку "Нет"
            secondButton.dataset.answer = 'no';
            secondButton.classList.remove('yes-btn');
            secondButton.classList.add('no-btn');
            const buttonSpan = secondButton.querySelector('span');
            if (buttonSpan) {
                buttonSpan.textContent = 'Нет';
            } else {
                secondButton.textContent = 'Нет';
            }
        }
    }
    
    // Скрываем сообщение об ошибке при входе на сцену
    if (errorMessage) {
        errorMessage.classList.remove('visible', 'minimized');
        errorMessage.style.opacity = '0';
        errorMessage.style.transform = 'scale(0.9)';
        
        // Восстанавливаем исходный текст сообщения
        const errorTitle = errorMessage.querySelector('.error-title');
        const errorText = errorMessage.querySelector('.error-text');
        const errorHint = errorMessage.querySelector('.error-hint');
        if (errorTitle) errorTitle.textContent = 'Ошибка 404: "Нет" не найдено';
        if (errorText) errorText.textContent = 'Такого варианта ответа не существует 😄';
        if (errorHint) {
            errorHint.textContent = 'Доступные варианты: Да ✅';
            errorHint.style.display = 'block';
        }
    }
    
    if (question) {
        gsap.fromTo(question,
            { opacity: 0, scale: 0.9 },
            { opacity: 1, scale: 1, duration: 1, ease: "power2.out" }
        );
    }
    
    buttons.forEach((btn, index) => {
        gsap.fromTo(btn,
            { opacity: 0, y: 30 },
            { opacity: 1, y: 0, duration: 0.6, delay: 0.5 + index * 0.2, ease: "power2.out" }
        );
    });
}

function handleAnswer(answer) {
    // Если нажали "Нет" - показать ошибку и не переходить дальше
    if (answer === 'no') {
        noClicks++;
        
        // Если кликов >= 5, заменяем кнопку "Нет" на "Да"
        if (noClicks >= 5) {
            replaceNoButtonWithYes();
            return;
        }
        
        showErrorMessage(noClicks);
        shakeNoButton();
        return; // Не устанавливаем answerChosen, не переходим дальше
    }
    
    // Если уже выбран ответ, игнорируем
    if (answerChosen) return;
    
    // Обработка ответа "Да" (включая заменённую кнопку)
    if (answer === 'yes') {
        answerChosen = answer;
        
        const buttons = document.querySelectorAll('.answer-btn');
        buttons.forEach(btn => {
            if (btn.dataset.answer !== answer) {
                gsap.to(btn, { opacity: 0.3, scale: 0.9, duration: 0.3 });
            }
        });
        
        // Create effects
        createHeartBurst();
        
        // Show ending after delay
        setTimeout(() => {
            showEnding(answer);
        }, 2000);
    }
}

// Функция для показа сообщения об ошибке с разным текстом в зависимости от количества кликов
function showErrorMessage(clicks) {
    const errorMessage = document.getElementById('errorMessage');
    if (!errorMessage) return;
    
    const errorTitle = errorMessage.querySelector('.error-title');
    const errorText = errorMessage.querySelector('.error-text');
    const errorHint = errorMessage.querySelector('.error-hint');
    
    // Определяем текст в зависимости от количества кликов
    let title = '';
    let text = '';
    let hint = '';
    
    switch(clicks) {
        case 1:
            title = 'Ошибка 404: "Нет" не найдено';
            text = 'Такого варианта ответа не существует 😌';
            hint = 'Доступные варианты: Да ✅';
            break;
        case 2:
            title = 'Системное предупреждение';
            text = 'Ты серьёзно нажала "Нет" ещё раз? 🙂';
            hint = '';
            break;
        case 3:
            title = 'Критическая ошибка';
            text = 'Зачем ты сюда опять нажала… ты же знаешь, что "Нет" не работает 😭';
            hint = '';
            break;
        case 4:
            title = 'Доступ ограничен';
            text = 'Слушай, я сейчас обижусь. Выбирай нормально 😅';
            hint = '';
            break;
        case 5:
            title = 'Режим "исправление реальности"';
            text = 'Ладно. Я понял(а). "Нет" больше не существует.';
            hint = '';
            break;
        default:
            title = 'Ошибка 404: "Нет" не найдено';
            text = 'Такого варианта ответа не существует 😌';
            hint = 'Доступные варианты: Да ✅';
    }
    
    // Обновляем текст через textContent (не innerHTML)
    if (errorTitle) errorTitle.textContent = title;
    if (errorText) errorText.textContent = text;
    if (errorHint) {
        errorHint.textContent = hint;
        // Скрываем hint, если он пустой
        if (hint === '') {
            errorHint.style.display = 'none';
        } else {
            errorHint.style.display = 'block';
        }
    }
    
    // Показываем сообщение
    errorMessage.classList.add('visible');
    
    // Анимация появления
    if (typeof gsap !== 'undefined') {
        gsap.fromTo(errorMessage,
            { opacity: 0, y: -20, scale: 0.9 },
            { opacity: 1, y: 0, scale: 1, duration: 0.4, ease: "back.out(1.7)" }
        );
    }
    
    // Скрываем сообщение через 2 секунды (или оставляем маленькой строкой)
    setTimeout(() => {
        errorMessage.classList.remove('visible');
        errorMessage.classList.add('minimized');
        
        if (typeof gsap !== 'undefined') {
            gsap.to(errorMessage, {
                opacity: 0.5,
                scale: 0.95,
                duration: 0.3,
                ease: "power2.inOut"
            });
        }
    }, 2000);
}

// Функция для shake анимации кнопки "Нет"
function shakeNoButton() {
    const noButton = document.querySelector('.answer-btn[data-answer="no"]');
    if (!noButton) return;
    
    if (typeof gsap !== 'undefined') {
        gsap.to(noButton, {
            x: -10,
            duration: 0.1,
            ease: "power2.inOut",
            yoyo: true,
            repeat: 5,
            onComplete: () => {
                gsap.set(noButton, { x: 0 });
            }
        });
    }
}

// Функция для замены кнопки "Нет" на "Да" после 5 кликов
function replaceNoButtonWithYes() {
    const noButton = document.querySelector('.answer-btn[data-answer="no"]');
    if (!noButton) return;
    
    // Shake анимация перед заменой
    shakeNoButton();
    
    // Небольшая задержка для завершения shake
    setTimeout(() => {
        // Меняем data-answer на "yes"
        noButton.dataset.answer = 'yes';
        
        // Меняем классы
        noButton.classList.remove('no-btn');
        noButton.classList.add('yes-btn');
        
        // Меняем текст кнопки
        const buttonSpan = noButton.querySelector('span');
        if (buttonSpan) {
            buttonSpan.textContent = 'Да';
        } else {
            noButton.textContent = 'Да';
        }
        
        // Анимация изменения
        if (typeof gsap !== 'undefined') {
            gsap.fromTo(noButton,
                { scale: 0.8, rotation: -5 },
                { scale: 1, rotation: 0, duration: 0.5, ease: "back.out(1.7)" }
            );
        }
    }, 500);
}

function createHeartBurst() {
    const container = document.getElementById('effectsContainer');
    if (!container) return;
    
    for (let i = 0; i < 50; i++) {
        setTimeout(() => {
            const heart = document.createElement('div');
            heart.className = 'confetti-heart';
            heart.textContent = '💕';
            heart.style.left = `${Math.random() * 100}%`;
            heart.style.top = `${Math.random() * 100}%`;
            container.appendChild(heart);
            
            setTimeout(() => heart.remove(), 3000);
        }, i * 50);
    }
}

function createShyEffect() {
    const container = document.getElementById('effectsContainer');
    if (!container) return;
    
    // Gentle blush glow
    const glow = document.createElement('div');
    glow.style.position = 'absolute';
    glow.style.top = '50%';
    glow.style.left = '50%';
    glow.style.width = '200px';
    glow.style.height = '200px';
    glow.style.borderRadius = '50%';
    glow.style.background = 'radial-gradient(circle, rgba(255, 107, 157, 0.4) 0%, transparent 70%)';
    glow.style.transform = 'translate(-50%, -50%)';
    glow.style.pointerEvents = 'none';
    container.appendChild(glow);
    
    gsap.to(glow, {
        scale: 3,
        opacity: 0,
        duration: 2,
        onComplete: () => glow.remove()
    });
    
    // Floating hearts
    for (let i = 0; i < 20; i++) {
        setTimeout(() => {
            const heart = document.createElement('div');
            heart.className = 'confetti-heart';
            heart.textContent = '💕';
            heart.style.left = `${50 + (Math.random() - 0.5) * 20}%`;
            heart.style.top = `${50 + (Math.random() - 0.5) * 20}%`;
            container.appendChild(heart);
            
            setTimeout(() => heart.remove(), 3000);
        }, i * 100);
    }
}

function createThinkEffect() {
    const container = document.getElementById('effectsContainer');
    if (!container) return;
    
    // Playful animation
    for (let i = 0; i < 15; i++) {
        setTimeout(() => {
            const heart = document.createElement('div');
            heart.className = 'confetti-heart';
            heart.textContent = '💝';
            heart.style.left = `${Math.random() * 100}%`;
            heart.style.top = `${Math.random() * 100}%`;
            container.appendChild(heart);
            
            setTimeout(() => heart.remove(), 3000);
        }, i * 150);
    }
}

function showEnding(answer) {
    const endingScene = document.getElementById('ending-scene');
    const endingBackground = document.getElementById('endingBackground');
    const contractContainer = document.getElementById('contractContainer');
    
    if (!endingScene) return;
    
    // Показываем контракт только если ответ "yes"
    if (answer === 'yes' && contractContainer) {
        // Set background image if available
        if (endingBackground && CONFIG.scenes.ending.backgroundImage) {
            endingBackground.style.backgroundImage = `url(${CONFIG.scenes.ending.backgroundImage})`;
        }
        
        // Show ending scene
        document.querySelectorAll('.scene').forEach(s => s.classList.remove('active'));
        endingScene.classList.add('active');
        
        // Инициализируем контракт (canvas, обработчики)
        initializeContract();
        
        // Animate in
        if (typeof gsap !== 'undefined') {
            gsap.fromTo(contractContainer,
                { opacity: 0, y: 30 },
                { opacity: 1, y: 0, duration: 1, delay: 0.3, ease: "power2.out" }
            );
        }
    } else {
        // Для других ответов показываем старое сообщение (если нужно)
        const endingMessage = document.getElementById('endingMessage');
        if (endingMessage) {
            let message = '';
            if (answer === 'shy') {
                message = CONFIG.scenes.ending.shy;
            } else {
                message = CONFIG.scenes.ending.think;
            }
            endingMessage.textContent = message;
        }
        
        // Show ending scene
        document.querySelectorAll('.scene').forEach(s => s.classList.remove('active'));
        endingScene.classList.add('active');
    }
}

function sendToTelegram(answer) {
    const username = CONFIG.telegram.username;
    if (!username || username === 'YOUR_USERNAME') {
        alert('Пожалуйста, укажите ваш Telegram username в CONFIG.telegram.username');
        return;
    }
    
    let message = '';
    if (answer === 'yes') {
        message = CONFIG.telegram.messageYes;
    } else if (answer === 'shy') {
        message = CONFIG.telegram.messageShy;
    } else {
        message = CONFIG.scenes.ending.think;
    }
    
    const encodedMessage = encodeURIComponent(message);
    const telegramUrl = `https://t.me/${username}?text=${encodedMessage}`;
    
    window.open(telegramUrl, '_blank');
}

// ============================================
// CONTRACT FUNCTIONALITY
// ============================================

// Состояние контракта
let signatureDrawn = false;
let signatureSigned = false;
let secretWordSelected = null;
let secretWordCorrect = false;

// Инициализация контракта
function initializeContract() {
    // Сбрасываем состояние
    signatureDrawn = false;
    signatureSigned = false;
    secretWordSelected = null;
    secretWordCorrect = false;
    
    // Инициализируем canvas для подписи
    initializeSignatureCanvas();
    
    // Настраиваем кнопки
    setupContractButtons();
    
    // Настраиваем секретное слово
    setupSecretWord();
    
    // Обновляем состояние кнопки подтверждения
    updateConfirmButton();
}

// Инициализация canvas для подписи
function initializeSignatureCanvas() {
    const canvas = document.getElementById('signatureCanvas');
    if (!canvas) return;
    
    const ctx = canvas.getContext('2d');
    if (!ctx) return;
    
    // Функция для настройки размеров canvas
    function setupCanvasSize() {
        const rect = canvas.getBoundingClientRect();
        const dpr = window.devicePixelRatio || 1;
        canvas.width = rect.width * dpr;
        canvas.height = rect.height * dpr;
        ctx.scale(dpr, dpr);
        
        // Устанавливаем размеры для отображения
        canvas.style.width = rect.width + 'px';
        canvas.style.height = rect.height + 'px';
        
        // Восстанавливаем стили после изменения размеров
        ctx.strokeStyle = '#ff6b9d';
        ctx.lineWidth = 2;
        ctx.lineCap = 'round';
        ctx.lineJoin = 'round';
    }
    
    // Настраиваем размеры при инициализации
    // Используем небольшую задержку, чтобы canvas был отрисован
    setTimeout(() => {
        setupCanvasSize();
    }, 100);
    
    ctx.strokeStyle = '#ff6b9d';
    ctx.lineWidth = 2;
    ctx.lineCap = 'round';
    ctx.lineJoin = 'round';
    
    let isDrawing = false;
    let lastX = 0;
    let lastY = 0;
    
    // Функция для начала рисования
    function startDrawing(e) {
        if (signatureSigned) return; // Нельзя рисовать после подписания
        isDrawing = true;
        const rect = canvas.getBoundingClientRect();
        const x = (e.touches ? e.touches[0].clientX : e.clientX) - rect.left;
        const y = (e.touches ? e.touches[0].clientY : e.clientY) - rect.top;
        lastX = x;
        lastY = y;
    }
    
    // Функция для рисования
    function draw(e) {
        if (!isDrawing || signatureSigned) return;
        e.preventDefault();
        
        const rect = canvas.getBoundingClientRect();
        const x = (e.touches ? e.touches[0].clientX : e.clientX) - rect.left;
        const y = (e.touches ? e.touches[0].clientY : e.clientY) - rect.top;
        
        ctx.beginPath();
        ctx.moveTo(lastX, lastY);
        ctx.lineTo(x, y);
        ctx.stroke();
        
        lastX = x;
        lastY = y;
        
        // Отмечаем, что подпись нарисована
        if (!signatureDrawn) {
            signatureDrawn = true;
            updateSignButton();
        }
    }
    
    // Функция для окончания рисования
    function stopDrawing() {
        if (isDrawing) {
            isDrawing = false;
        }
    }
    
    // Обработчики для мыши
    canvas.addEventListener('mousedown', startDrawing);
    canvas.addEventListener('mousemove', draw);
    canvas.addEventListener('mouseup', stopDrawing);
    canvas.addEventListener('mouseout', stopDrawing);
    
    // Обработчики для touch
    canvas.addEventListener('touchstart', (e) => {
        e.preventDefault();
        startDrawing(e);
    });
    canvas.addEventListener('touchmove', (e) => {
        e.preventDefault();
        draw(e);
    });
    canvas.addEventListener('touchend', stopDrawing);
    canvas.addEventListener('touchcancel', stopDrawing);
}

// Настройка кнопок контракта
function setupContractButtons() {
    const clearBtn = document.getElementById('clearSignatureBtn');
    const signBtn = document.getElementById('signContractBtn');
    const confirmBtn = document.getElementById('confirmContractBtn');
    
    // Кнопка "Очистить подпись"
    if (clearBtn) {
        clearBtn.addEventListener('click', () => {
            clearSignature();
        });
    }
    
    // Кнопка "Подписать контракт"
    if (signBtn) {
        signBtn.addEventListener('click', () => {
            signContract();
        });
    }
    
    // Кнопка "Подтвердить контракт"
    if (confirmBtn) {
        confirmBtn.addEventListener('click', () => {
            confirmContract();
        });
    }
}

// Очистка подписи
function clearSignature() {
    if (signatureSigned) return; // Нельзя очистить после подписания
    
    const canvas = document.getElementById('signatureCanvas');
    if (!canvas) return;
    
    const ctx = canvas.getContext('2d');
    if (!ctx) return;
    
    // Очищаем весь canvas
    const rect = canvas.getBoundingClientRect();
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    
    signatureDrawn = false;
    updateSignButton();
    
    const status = document.getElementById('signatureStatus');
    if (status) {
        status.textContent = '';
        status.classList.remove('signed');
    }
}

// Обновление состояния кнопки "Подписать контракт"
function updateSignButton() {
    const signBtn = document.getElementById('signContractBtn');
    if (signBtn) {
        signBtn.disabled = !signatureDrawn || signatureSigned;
    }
}

// Подписание контракта
function signContract() {
    if (!signatureDrawn || signatureSigned) return;
    
    signatureSigned = true;
    const canvas = document.getElementById('signatureCanvas');
    const status = document.getElementById('signatureStatus');
    
    if (canvas) {
        canvas.classList.add('signed');
        canvas.style.cursor = 'default';
    }
    
    if (status) {
        status.textContent = 'Подписано ✅';
        status.classList.add('signed');
        
        // Анимация появления штампа
        if (typeof gsap !== 'undefined') {
            gsap.fromTo(status,
                { scale: 0, rotation: -180 },
                { scale: 1, rotation: 0, duration: 0.6, ease: "back.out(1.7)" }
            );
        }
    }
    
    updateSignButton();
    updateConfirmButton();
}

// Настройка секретного слова
function setupSecretWord() {
    const wordButtons = document.querySelectorAll('.secret-word-btn');
    const status = document.getElementById('secretWordStatus');
    
    wordButtons.forEach(btn => {
        btn.addEventListener('click', () => {
            if (secretWordCorrect) return; // Нельзя менять после правильного выбора
            
            const word = btn.dataset.word;
            secretWordSelected = word;
            
            // Убираем выделение с других кнопок
            wordButtons.forEach(b => {
                b.classList.remove('selected', 'wrong');
            });
            
            // Проверяем правильность
            if (word === 'поросёнок') {
                secretWordCorrect = true;
                btn.classList.add('selected');
                
                if (status) {
                    status.textContent = 'Контракт принят! ✅';
                    status.classList.add('correct');
                    status.classList.remove('wrong');
                }
                
                // Анимация успеха
                if (typeof gsap !== 'undefined') {
                    gsap.fromTo(btn,
                        { scale: 1 },
                        { scale: 1.1, duration: 0.2, yoyo: true, repeat: 1, ease: "power2.inOut" }
                    );
                }
            } else {
                secretWordCorrect = false;
                btn.classList.add('wrong');
                
                if (status) {
                    status.textContent = 'Хмм… нет, это не то 😌';
                    status.classList.add('wrong');
                    status.classList.remove('correct');
                }
                
                // Shake анимация
                if (typeof gsap !== 'undefined') {
                    gsap.to(btn, {
                        x: -10,
                        duration: 0.1,
                        ease: "power2.inOut",
                        yoyo: true,
                        repeat: 5,
                        onComplete: () => {
                            gsap.set(btn, { x: 0 });
                        }
                    });
                }
            }
            
            updateConfirmButton();
        });
    });
}

// Обновление состояния кнопки "Подтвердить контракт"
function updateConfirmButton() {
    const confirmBtn = document.getElementById('confirmContractBtn');
    if (confirmBtn) {
        // Кнопка активна только если подпись поставлена И выбрано правильное слово
        const canConfirm = signatureSigned && secretWordCorrect;
        confirmBtn.disabled = !canConfirm;
    }
}

// Подтверждение контракта
function confirmContract() {
    if (!signatureSigned || !secretWordCorrect) return;
    
    // Переходим на сцену 8 после подтверждения контракта
    setTimeout(() => {
        navigateToScene(8);
    }, 500);
}

// Финальное сообщение после подтверждения контракта
function showFinalMessage() {
    const contractContainer = document.getElementById('contractContainer');
    
    if (!contractContainer) return;
    
    // Создаём финальное сообщение
    const finalMessage = document.createElement('div');
    finalMessage.className = 'ending-message';
    finalMessage.textContent = CONFIG.scenes.ending.yes || 'Спасибо, что сказала да! Ты сделала меня самым счастливым человеком на свете. 💘';
    
    const actions = document.createElement('div');
    actions.className = 'ending-actions';
    actions.innerHTML = `
        <button class="cta-button primary" id="telegramBtn">Отправить ответ в Телеграм</button>
        <button class="cta-button secondary" id="restartBtn">Посмотреть ещё раз</button>
    `;
    
    contractContainer.innerHTML = '';
    contractContainer.appendChild(finalMessage);
    contractContainer.appendChild(actions);
    
    // Анимация появления
    if (typeof gsap !== 'undefined') {
        gsap.fromTo(finalMessage,
            { opacity: 0, y: 30 },
            { opacity: 1, y: 0, duration: 1, delay: 0.3, ease: "power2.out" }
        );
        
        gsap.fromTo(actions,
            { opacity: 0, y: 30 },
            { opacity: 1, y: 0, duration: 1, delay: 0.8, ease: "power2.out" }
        );
    }
    
    // Настраиваем кнопку Telegram
    const telegramBtn = document.getElementById('telegramBtn');
    if (telegramBtn) {
        telegramBtn.addEventListener('click', () => {
            sendToTelegram('yes');
        });
    }
    
    // Настраиваем кнопку перезапуска
    const restartBtn = document.getElementById('restartBtn');
    if (restartBtn) {
        restartBtn.addEventListener('click', () => {
            answerChosen = null;
            gameCompleted = false;
            noClicks = 0;
            navigateToScene(1);
        });
    }
}

// ============================================
// AUDIO
// ============================================
function setupAudio() {
    const audio = document.getElementById('backgroundAudio');
    const soundToggle = document.getElementById('soundToggle');
    const soundIcon = soundToggle?.querySelector('.sound-icon');
    const soundLabel = soundToggle?.querySelector('.sound-label');
    
    if (!audio || !soundToggle) return;
    
    // Set audio source if enabled
    if (CONFIG.audio.enabled && CONFIG.audio.fileName) {
        audio.src = CONFIG.audio.fileName;
        audio.volume = 0.5; // Set volume to 50% for comfortable listening
        
        // Try to preload and play audio automatically
        audio.load();
        
        // Try to play immediately
        const tryPlay = () => {
            audio.play()
                .then(() => {
                    // Successfully started playing
                    audioEnabled = true;
                    if (soundIcon) soundIcon.textContent = '🔊';
                    if (soundLabel) soundLabel.textContent = 'Звук: вкл';
                })
                .catch((error) => {
                    // Autoplay blocked - try again after user interaction
                    console.log('Autoplay blocked, will try after user interaction');
                    audioEnabled = false;
                    
                    // Try to enable on first user interaction
                    const enableOnInteraction = () => {
                        audio.play()
                            .then(() => {
                                audioEnabled = true;
                                if (soundIcon) soundIcon.textContent = '🔊';
                                if (soundLabel) soundLabel.textContent = 'Звук: вкл';
                            })
                            .catch(() => {
                                audioEnabled = false;
                            });
                        // Remove listeners after first attempt
                        document.removeEventListener('click', enableOnInteraction);
                        document.removeEventListener('touchstart', enableOnInteraction);
                        document.removeEventListener('keydown', enableOnInteraction);
                    };
                    
                    // Listen for any user interaction
                    document.addEventListener('click', enableOnInteraction, { once: true });
                    document.addEventListener('touchstart', enableOnInteraction, { once: true });
                    document.addEventListener('keydown', enableOnInteraction, { once: true });
                });
        };
        
        // Try to play when audio is ready
        audio.addEventListener('canplaythrough', tryPlay, { once: true });
        
        // Also try immediately (in case audio is already loaded)
        setTimeout(tryPlay, 100);
    }
    
    soundToggle.addEventListener('click', () => {
        audioEnabled = !audioEnabled;
        
        if (audioEnabled) {
            audio.play().catch((error) => {
                // Play failed
                console.log('Audio play failed:', error);
                audioEnabled = false;
            });
            if (soundIcon) soundIcon.textContent = '🔊';
            if (soundLabel) soundLabel.textContent = 'Звук: вкл';
        } else {
            audio.pause();
            if (soundIcon) soundIcon.textContent = '🔇';
            if (soundLabel) soundLabel.textContent = 'Звук: выкл';
        }
    });
}

// ============================================
// EVENT LISTENERS
// ============================================
function setupEventListeners() {
    // Navigation buttons
    // Навигация удалена - переходы только через кнопки внутри сцен
    
    // Next buttons
    document.querySelectorAll('[data-next]').forEach(btn => {
        btn.addEventListener('click', (e) => {
            createRipple(e, btn);
            const nextScene = parseInt(btn.dataset.next);
            navigateToScene(nextScene);
        });
    });
    
    // Answer buttons
    document.querySelectorAll('.answer-btn').forEach(btn => {
        btn.addEventListener('click', (e) => {
            createRipple(e, btn);
            const answer = btn.dataset.answer;
            handleAnswer(answer);
        });
    });
    
    // Gallery modal close
    const modalClose = document.getElementById('modalClose');
    const modalBackdrop = document.getElementById('modalBackdrop');
    
    if (modalClose) {
        modalClose.addEventListener('click', closeGalleryModal);
    }
    
    if (modalBackdrop) {
        modalBackdrop.addEventListener('click', closeGalleryModal);
    }
    
    // Restart button
    const restartBtn = document.getElementById('restartBtn');
    if (restartBtn) {
        restartBtn.addEventListener('click', () => {
            answerChosen = null;
            gameCompleted = false;
            noClicks = 0; // Сбрасываем счётчик кликов
            navigateToScene(1);
        });
    }
    
    // Keyboard navigation
    document.addEventListener('keydown', (e) => {
        if (e.key === 'Escape') {
            closeGalleryModal();
        }
    });
}

// ============================================
// UTILITY FUNCTIONS
// ============================================
function createRipple(event, element) {
    const ripple = document.createElement('span');
    const rect = element.getBoundingClientRect();
    const size = Math.max(rect.width, rect.height);
    const x = event.clientX - rect.left - size / 2;
    const y = event.clientY - rect.top - size / 2;
    
    ripple.style.width = ripple.style.height = `${size}px`;
    ripple.style.left = `${x}px`;
    ripple.style.top = `${y}px`;
    ripple.className = 'ripple';
    
    element.style.position = 'relative';
    element.style.overflow = 'hidden';
    element.appendChild(ripple);
    
    setTimeout(() => ripple.remove(), 600);
}

function updateTextsFromConfig() {
    // Scene 1
    const line1 = document.querySelector('#scene-1 .reveal-line[data-delay="0"]');
    const line2 = document.querySelector('#scene-1 .reveal-line[data-delay="800"]');
    const line3 = document.querySelector('#scene-1 .reveal-line[data-delay="1600"]');
    
    if (line1) line1.textContent = CONFIG.scenes.scene1.line1;
    if (line2) line2.textContent = CONFIG.scenes.scene1.line2;
    if (line3) line3.textContent = CONFIG.scenes.scene1.line3;
    
    // Scene 2
    const memoryCardText = document.getElementById('memoryCardText');
    if (memoryCardText) {
        // Заменяем \n на <br> для корректного отображения переноса строки
        const textWithBreaks = CONFIG.scenes.scene2.memoryCardText.replace(/\n/g, '<br>');
        memoryCardText.innerHTML = textWithBreaks;
    }
    
    // Scene 3
    const scene3Title = document.querySelector('#scene-3 .scene-title');
    if (scene3Title) {
        scene3Title.textContent = CONFIG.scenes.scene3.title;
    }
    
    // Scene 4 - Кино-момент (текст уже установлен в animateScene4)
    
    // Scene 5 - Мини-игра
    const scene5Title = document.querySelector('#scene-5 .scene-title');
    const gameTargetEl = document.getElementById('gameTarget');
    const gameInstructions = document.querySelector('.game-instructions p');
    
    if (scene5Title) scene5Title.textContent = CONFIG.scenes.scene5.title;
    if (gameTargetEl) gameTargetEl.textContent = CONFIG.scenes.scene5.target;
    if (gameInstructions) gameInstructions.textContent = CONFIG.scenes.scene5.instructions;
    
    // Scene 6 - Причины
    const scene6Title = document.querySelector('#scene-6 .scene-title');
    if (scene6Title) {
        scene6Title.textContent = CONFIG.scenes.scene6.title;
    }
    
    // Scene 7 - Вопрос
    const bigQuestion = document.querySelector('.big-question');
    if (bigQuestion) {
        bigQuestion.textContent = CONFIG.scenes.scene7.question;
    }
}

// ============================================
// EXPORT FOR DEBUGGING (optional)
// ============================================
if (typeof window !== 'undefined') {
    window.VALENTINE_APP = {
        CONFIG,
        navigateToScene,
        currentScene: () => currentScene
    };
}
