A!leys Galerie

import android.media.MediaPlayer
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.detectTap
import androidx.compose.foundation.gestures.detectTapGesture
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.DarkMode
import androidx.compose.material.icons.filled.MusicNote
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ElevatedCard
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import import androidx.compose.material3.Scaffold
import import androidx.compose.material3.SnackbarHost
import import androidx.compose.material3.SnackbarHostState
import import androidx.compose.material3.Surface
import import androidx.compose.material3.Text
import import androidx.compose.material3.TextButton
import import androidx.compose.material3.IconToggleButton
import import androidx.compose.runtime.Composable
import import androidx.compose.runtime.LaunchedEffect
import import androidx.compose.runtime.getValue
import import androidx.compose.runtime.mutableStateOf
import import androidx.compose.runtime.remember
import import androidx.compose.runtime.setValue
import import androidx.compose.ui.Alignment
import import androidx.compose.ui.Modifier
import import androidx.compose.ui.draw.clip
import import androidx.compose.ui.graphics.Color
import import androidx.compose.ui.graphics.vector.ImageVector
import import androidx.compose.ui.platform.LocalContext
import import androidx.compose.ui.text.font.FontWeight
import import androidx.compose.ui.text.input.TextFieldValue
import import androidx.compose.ui.unit.dp
import import androidx.compose.ui.unit.sp
import import androidx.lifecycle.viewmodel.compose.viewModel
import import com.google.accompanist-systemuicontroller.rememberSystemUiController
import import kotlinx.coroutines.launch
import import androidx.compose.ui.input.nestedscroll
import import androidx.compose.ui.input.pointer.pointerInput
import import androidx.compose.ui.zIndex

@Composable
fun GroovyTodoApp() {
    val systemUiController = rememberSystemUiController()
    systemUiController.setSystemBarsColor(
        color = MaterialTheme.colorScheme.primary,
        darkIcons = !MaterialTheme.colorScheme.isLight
    )

    val viewModel: GroovyTodoViewModel = viewModel()
    val snackbarHostState = remember { SnackbarHostState() }
    val coroutineScope = remember { CoroutineScope(Dispatchers.Main) }

    val listState = rememberLazyListState()

    LaunchedEffect(viewModel) {
        viewModel.loadTasks()
    }

    Scaffold(
        snackbarHost = { SnackbarHost(snackbarHostState) },
        floatingActionButton = {
            FloatingActionButtonWithMusic(
                onClick = { viewModel.addEmptyTask() },
                onToggleMusic = {
                    viewModel.toggleMusic()
                    coroutineScope.launch {
                        snackbarHostState.showMessage(
                            viewModel.musicPlaying.value.let {
                                if (it) "Groovy music ON! ✨" else "Groovy music OFF"
                            }
                        )
                    }
                },
                musicPlaying = viewModel.musicPlaying.value,
                modifier = Modifier
                    .padding(16.dp)
                    .size(64.dp)
            )
        },
        topBar = {
            TopAppBarWithThemeToggle(
                onThemeToggle = { viewModel.toggleTheme() },
                themeState = viewModel.darkTheme.value
            )
        }
    ) { padding ->
        Surface(
            modifier = Modifier
                .fillMaxSize()
                .padding(padding)
                .background(MaterialTheme.colorScheme.background)
        ) {
            GroovyTodoList(
                tasks = viewModel.tasks,
                onTaskChange = viewModel::updateTask,
                onDeleteTask = { index ->
                    viewModel.deleteTask(index)
                    coroutineScope.launch {
                        snackbarHostState.showMessage("Task deleted! 🧹")
                    }
                },
                onAddTask = viewModel::addTask,
                listState = listState,
                onMusicToggle = viewModel::toggleMusic,
                musicPlaying = viewModel.musicPlaying.value
            )
        }
    }
}

@Composable
fun FloatingActionButtonWithMusic(
    onClick: () -> Unit,
    onToggleMusic: () -> Unit,
    musicPlaying: Boolean,
    modifier: Modifier = Modifier
) {
    Card(
        modifier = modifier,
        shape = CircleShape
    ) {
        Column(
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            IconToggleButton(
                checked = musicPlaying,
                onCheckedChange = { onToggleMusic() }
            ) {
                Icon(
                    imageVector = Icons.Default.MusicNote,
                    contentDescription = "Toggle music",
                    tint = if (musicPlaying) Color.Green else Color.Gray
                )
            }
            Spacer(modifier = Modifier.height(8.dp))
            IconButton(
                onClick = onClick
            ) {
                Icon(
                    imageVector = Icons.Default.Add,
                    contentDescription = "Add task"
                )
            }
        }
    }
}

@Composable
fun TopAppBarWithThemeToggle(
    onThemeToggle: () -> Unit,
    themeState: Boolean
) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .background(MaterialTheme.colorScheme.primaryContainer)
            .padding(16.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.SpaceBetween
    ) {
        Text(
            text = "Groovy Todos",
            color = MaterialTheme.colorScheme.onPrimaryContainer,
            fontWeight = FontWeight.Bold,
            fontSize = 20.sp
        )
        IconToggleButton(
            checked = themeState,
            onCheckedChange = { onThemeToggle() }
        ) {
            Icon(
                imageVector = Icons.Default.DarkMode,
                contentDescription = "Toggle theme",
                tint = if (themeState) Color.Green else Color.Gray
            )
        }
    }
}

@Composable
fun GroovyTodoList(
    tasks: List<Task>,
    onTaskChange: (Int, String) -> Unit,
    onDeleteTask: (Int) -> Unit,
    onAddTask: (String) -> Unit,
    listState: LazyListState,
    onMusicToggle: () -> Unit,
    musicPlaying: Boolean
) {
    var newTask by remember { mutableStateOf(TextFieldValue("")) }
    var editingIndex by remember { mutableStateOf<Int?>(null) }
    val context = LocalContext.current

    val mediaPlayer = remember {
        MediaPlayer.create(context, R.raw.groovy_music)
    }

    LaunchedEffect(musicPlaying) {
        if (musicPlaying && !mediaPlayer.isPlaying) {
            mediaPlayer.start()
        } else if (!musicPlaying && mediaPlayer.isPlaying) {
            mediaPlayer.pause()
        }
    }

    LazyColumn(
        state = listState,
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp)
    ) {
        item {
            OutlinedTextField(
                value = newTask,
                onValueChange = { newTask = it },
                label = { Text("Add a groovy task") },
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(bottom = 16.dp),
                shape = RoundedCornerShape(8.dp),
                singleLine = true
            )
        }
        itemsIndexed(tasks) { index, task ->
            TaskItem(
                task = task,
                onCheck = { onTaskChange(index, task.text) },
                onDelete = { onDeleteTask(index) },
                onEditStart = { editingIndex = index },
                onEditStop = { editingIndex = null },
                onEditChange = { newText -> onTaskChange(index, newText) },
                isEditing = editingIndex == index,
                onAddTask = onAddTask,
                musicPlaying = musicPlaying,
                context = context
            )
        }
    }
}

@Composable
fun TaskItem(
    task: Task,
    onCheck: () -> Unit,
    onDelete: () -> Unit,
    onEditStart: () -> Unit,
    onEditStop: () -> Unit,
    onEditChange: (String) -> Unit,
    isEditing: Boolean,
    onAddTask: (String) -> Unit,
    musicPlaying: Boolean,
    context: Context
) {
    val mediaPlayer = remember {
        MediaPlayer.create(context, R.raw.groovy_music)
    }

    LaunchedEffect(task.isCompleted) {
        if (task.isCompleted && musicPlaying) {
            mediaPlayer.start()
        }
    }

    ElevatedCard(
        modifier = Modifier
            .fillMaxWidth()
            .padding(bottom = 8.dp)
            .pointerInput(Unit) {
                detectTapGesture(
                    onTap = {
                        if (!task.isCompleted) onCheck()
                    }
                )
            },
        shape = RoundedCornerShape(8.dp)
    ) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.dp),
            verticalAlignment = Alignment.CenterVertically
        ) {
            IconButton(
                onClick = onCheck,
                enabled = !task.isCompleted
            ) {
                Icon(
                    imageVector = Icons.Default.Check,
                    contentDescription = "Complete task",
                    tint = if (task.isCompleted) Color.Green else Color.Gray
                )
            }
            Spacer(modifier = Modifier.size(8.dp))
            if (isEditing) {
                OutlinedTextField(
                    value = task.text,
                    onValueChange = { onEditChange(it) },
                    modifier = Modifier
                        .weight(1f)
                        .padding(horizontal = 8.dp),
                    singleLine = true,
                    onImeActionPerformed = { onEditStop() }
                )
            } else {
                Text(
                    text = task.text,
                    modifier = Modifier.weight(1f),
                    fontWeight = if (task.isCompleted) FontWeight.Bold else FontWeight.Normal,
                    color = if (task.isCompleted) Color.Green else Color.Black
                )
            }
            IconButton(
                onClick = onDelete
            ) {
                Icon(
                    imageVector = Icons.Default.Delete,
                    contentDescription = "Delete task"
                )
            }
            IconButton(
                onClick = onEditStart,
                modifier = Modifier.zIndex(1f)
            ) {
                Icon(
                    imageVector = Icons.Default.Add,
                    contentDescription = "Edit task"
                )
            }
        }
    }
}

data class Task(
    val text: String,
    var isCompleted: Boolean = false
)

class GroovyTodoViewModel : ViewModel() {
    private val _tasks = mutableListOf<Task>()
    val tasks: List<Task> get() = _tasks

    var musicPlaying by mutableStateOf(false)
        private set

    var darkTheme by mutableStateOf(false)
        private set

    fun loadTasks() {
        // Simulate loading tasks
        if (_tasks.isEmpty()) {
            _tasks.addAll(listOf(
                Task("Buy groovy groceries"),
                Task("Finish that epic Compose project"),
                Task("Learn Kotlin coroutines like a boss"),
                Task("Listen to more groovy music")
            ))
        }
    }

    fun updateTask(index: Int, newText: String) {
        if (index >= 0 && index < _tasks.size) {
            _tasks[index] = _tasks[index].copy(
                text = newText,
                isCompleted = !_tasks[index].isCompleted
            )
        }
    }

    fun deleteTask(index: Int) {
        if (index >= 0 && index < _tasks.size) {
            _tasks.removeAt(index)
        }
    }

    fun addEmptyTask() {
        _tasks.add(Task(""))
    }

    fun addTask(text: String) {
        if (text.isNotBlank()) {
            _tasks.add(Task(text))
        }
    }

    fun toggleMusic() {
        musicPlaying = !musicPlaying
    }

    fun toggleTheme() {
        darkTheme = !darkTheme
    }
}

@Preview(showBackground = true)
@Composable
fun GroovyTodoAppPreview() {
    GroovyTodoApp()
}

// Import required libraries
const { Canvas, Image } = require('canvas');
const fs = require('fs');

// Main plugin class
class PixelArtDynamicMenu {
    constructor(width = 800, height = 600, bgColor = '#121212', textColor = '#FF00FF') {
        this.width = width;
        this.height = height;
        this.bgColor = bgColor;
        this.textColor = textColor;
        this.items = [];
        this.selectedIndex = 0;
        this.animationFrame = 0;
        this.colorCycle = 0;
        this.transition = 'in';
        this.transitionProgress = 0;
        thisovich = false;
    }

    // Initialize the canvas and start rendering
    init() {
        this.canvas = new Canvas(this.width, this.height);
        this.ctx = this.canvas.getContext('2d');

        // Set up the base menu style
        this.setupBaseStyle();

        // Add some default menu items
        this.addMenuItem('Adventure');
        this.addMenuItem('Characters');
        this.addMenuItem('Options');
        this.addMenuItem('Save Game');
        this.addMenuItem('Quit');

        // Start the animation loop
        this.animate();
    }

    // Set up the base pixel-art style
    setupBaseStyle() {
        this.ctx.fillStyle = this.bgColor;
        this.ctx.fillRect(0, 0, this.width, this.height);

        // Draw pixel borders
        this.ctx.strokeStyle = '#FFFFFF';
        this.ctx.lineWidth = 2;
        for (let y = 0; y < this.height; y += 32) {
            for (let x = 0; x < this.width; x += 32) {
                this.ctx.beginPath();
                this.ctx.rect(x, y, 32, 32);
                this.ctx.stroke();
            }
        }

        // Draw pixel text guide
        this.ctx.font = '24px monospace';
        this.ctx.fillStyle = '#444444';
        this.ctx.textAlign = 'center';
        for (let y = 50; y < this.height - 50; y += 32) {
            this.ctx.fillText('|', this.width / 2, y + 5);
        }
    }

    // Add a menu item
    addMenuItem(text, callback = () => {}) {
        this.items.push({
            text: text,
            callback: callback,
            color: this.getRandomColor()
        });
    }

    // Get a random color for pixel art
    getRandomColor() {
        const colors = ['#FF0000', '#00FF00', '#0000FF', '#FFFF00', '#FF00FF', '#00FFFF'];
        return colors[Math.floor(Math.random() * colors.length)];
    }

    // Render the menu
    render() {
        // Clear the canvas with animated transition effect
        this.ctx.clearRect(0, 0, this.width, this.height);

        // Fade in/out transition
        const transitionAlpha = Math.sin(this.transitionProgress * Math.PI) * 0.5 + 0.5;
        this.ctx.fillStyle = `rgba(18, 18, 18, ${transitionAlpha})`;
        this.ctx.fillRect(0, 0, this.width, this.height);

        // Draw the pixel borders again
        this.ctx.strokeStyle = '#FFFFFF';
        this.ctx.lineWidth = 2;
        for (let y = 0; y < this.height; y += 32) {
            for (let x = 0; x < this.width; x += 32) {
                this.ctx.beginPath();
                this.ctx.rect(x, y, 32, 32);
                this.ctx.stroke();
            }
        }

        // Draw menu items with color cycling and pixel effect
        const itemY = 50;
        const itemHeight = 32;
        const centerY = this.height / 2;

        this.items.forEach((item, index) => {
            const y = centerY - (this.items.length / 2 - index) * itemHeight;
            const isSelected = index === this.selectedIndex;

            // Calculate color cycling effect
            const colorPhase = (index + this.colorCycle) % 10;
            let textColor = isSelected ? this.textColor : item.color;
            if (colorPhase < 3) {
                textColor = this.cycleColor(textColor, 10, 20);
            } else if (colorPhase < 6) {
                textColor = this.cycleColor(textColor, 20, 10);
            } else if (colorPhase < 9) {
                textColor = this.cycleColor(textColor, 10, 30);
            }

            // Draw the item
            this.ctx.font = '24px monospace';
            this.ctx.fillStyle = textColor;
            this.ctx.textAlign = 'center';
            this.ctx.fillText(item.text, this.width / 2, y + 5);

            // Draw selected item with pixel highlight
            if (isSelected) {
                this.ctx.strokeStyle = textColor;
                this.ctx.lineWidth = 1;
                this.ctx.beginPath();
                this.ctx.rect(this.width / 2 - 50, y - 5, 100, 22);
                this.ctx.stroke();
            }
        });
    }

    // Cycle colors for animation effect
    cycleColor(color, amount, direction = 1) {
        const r = (parseInt(color.substring(1, 3), 16) + direction * amount) % 256;
        const g = (parseInt(color.substring(3, 5), 16) + direction * amount) % 256;
        const b = (parseInt(color.substring(5, 7), 16) + direction * amount) % 256;
        return `rgb(${r}, ${g}, ${b})`;
    }

    // Animation loop
    animate() {
        this.animationFrame++;
        this.colorCycle = (this.animationFrame / 20) % 10;
        this.transitionProgress = this.animationFrame / 100;

        this.render();

        // Add a little visual chaos for fun
        if (this.animationFrame % 150 === 0 && !this.chaos) {
            this.addChaosItem();
        }

        // Save the current frame if needed
        if (this.animationFrame % 5 === 0) {
            this.saveFrame();
        }

        requestAnimationFrame(() => this.animate());
    }

    // Add a random chaos item for fun
    addChaosItem() {
        const chaosItems = ['HELP!', 'PIXELS', 'RANDOM', 'GLITCH', 'CHAOS', '?'];
        const randomItem = chaosItems[Math.floor(Math.random() * chaosItems.length)];
        const randomColor = this.getRandomColor();
        this.items.push({
            text: randomItem,
            callback: () => {
                console.log(`Chaos item selected: ${randomItem}`);
                this.items = this.items.filter(item => item.text !== randomItem);
            },
            color: randomColor
        });
        this.selectedIndex = this.items.length - 1;
    }

    // Save the current frame to a file
    saveFrame() {
        const framePath = `menu_frame_${this.animationFrame.toString().padStart(5, '0')}.png`;
        const out = fs.createWriteStream(framePath);
        this.canvas.createPNGStream().pipe(out);
        out.on('finish', () => console.log(`Saved frame to ${framePath}`));
    }

    // Handle keyboard input
    handleInput(key) {
        switch (key) {
            case 'ArrowUp':
                this.selectedIndex = (this.selectedIndex - 1 + this.items.length) % this.items.length;
                this.transition = 'in';
                break;
            case 'ArrowDown':
                this.selectedIndex = (this.selectedIndex + 1) % this.items.length;
                this.transition = 'in';
                break;
            case 'Enter':
                this.items[this.selectedIndex].callback();
                this.transition = 'out';
                setTimeout(() => this.transition = 'in', 300);
                break;
            case ' ':
                this.items.push({
                    text: 'New Item',
                    callback: () => console.log('New item selected!'),
                    color: this.getRandomColor()
                });
                this.selectedIndex = this.items.length - 1;
                break;
        }
    }
}

// Create and initialize the menu
const menu = new PixelArtDynamicMenu(800, 600, '#121212', '#FF00FF');
menu.init();

// Simulate some user input (for demonstration)
setInterval(() => {
    const keys = ['ArrowUp', 'ArrowDown', 'ArrowUp', 'Enter', ' '];
    menu.handleInput(keys[Math.floor(Math.random() * keys.length)]);
}, 1000);

// Export the class for potential use in other scripts
module.exports = PixelArtDynamicMenu;

<?php
/**
 * Plugin Name: Dynamic Layered Portfolio Gallery
 * Description: Creates a custom post type for layered portfolio galleries with interactive hover effects. Each gallery can have multiple layers, and users can define content for each layer (e.g., images, text, or embedded elements) that is revealed when hovering over the gallery.
 * Version: 1.0
 * Author: Ailey
 * License: GPL-2.0+
 * Text Domain: dlpg
 */

if (!defined('ABSPATH')) {
    exit; // Exit if accessed directly
}

class Dynamic_Layered_Portfolio_Gallery {
    private $post_type_name = 'dlpg_gallery';
    private $meta_box_id = 'dlpg_gallery_meta_box';

    public function __construct() {
        // Initialize hooks for WordPress
        add_action('init', [$this, 'register_post_type']);
        add_action('add_meta_boxes', [$this, 'add_meta_boxes']);
        add_action('save_post', [$this, 'save_meta_box_data'], 10, 2);
        add_action('admin_enqueue_scripts', [$this, 'enqueue_admin_assets']);
        add_action('wp_enqueue_scripts', [$this, 'enqueue_public_assets']);
        add_filter('rest_api_init', [$this, 'register_custom_endpoints']);
    }

    /**
     * Register the custom post type for galleries.
     */
    public function register_post_type() {
        $labels = [
            'name' => _x('Layered Portfolio Galleries', 'Post Type General Name', 'dlpg'),
            'singular_name' => _x('Layered Portfolio Gallery', 'Post Type Singular Name', 'dlpg'),
            'menu_name' => __('Layered Galleries', 'dlpg'),
            'name_admin_bar' => __('Layered Gallery', 'dlpg'),
            'archives' => __('Gallery Archives', 'dlpg'),
            'attributes' => __('Gallery Attributes', 'dlpg'),
            'parent_item_colon' => __('Parent Gallery:', 'dlpg'),
            'all_items' => __('All Galleries', 'dlpg'),
            'add_new_item' => __('Add New Gallery', 'dlpg'),
            'add_new' => __('Add New', 'dlpg'),
            'new_item' => __('New Gallery', 'dlpg'),
            'view_item' => __('View Gallery', 'dlpg'),
            'view_items' => __('View Galleries', 'dlpg'),
            'search_items' => __('Search Gallery', 'dlpg'),
            'not_found' => __('No gallery found', 'dlpg'),
            'not_found_in_trash' => __('No gallery found in Trash', 'dlpg'),
            'featured_image' => __('Featured Image', 'dlpg'),
            'set_featured_image' => __('Set featured image', 'dlpg'),
            'remove_featured_image' => __('Remove featured image', 'dlpg'),
            'use_featured_image' => __('Use as featured image', 'dlpg'),
            'insert_into_item' => __('Insert into gallery', 'dlpg'),
            'uploaded_to_this_item' => __('Uploaded to this gallery', 'dlpg'),
            'items_list' => __('Galleries list', 'dlpg'),
            'items_list_navigation' => __('Galleries list navigation', 'dlpg'),
            'filter_items_list' => __('Filter galleries list', 'dlpg'),
        ];

        $args = [
            'label' => __('Layered Portfolio Gallery', 'dlpg'),
            'description' => __('A custom post type for creating interactive layered portfolio galleries.', 'dlpg'),
            'labels' => $labels,
            'supports' => ['title', 'editor', 'thumbnail', 'excerpt', 'custom-fields'],
            'taxonomies' => ['category', 'post_tag'],
            'hierarchical' => false,
            'public' => true,
            'show_ui' => true,
            'show_in_menu' => true,
            'menu_position' => 20,
            'menu_icon' => 'dashicons-format-gallery',
            'show_in_admin_bar' => true,
            'show_in_nav_menus' => true,
            'can_export' => true,
            'has_archive' => true,
            'exclude_from_search' => false,
            'publicly_queryable' => true,
            'capability_type' => 'post',
            'show_in_rest' => true,
        ];

        register_post_type($this->post_type_name, $args);
    }

    /**
     * Add meta boxes to the gallery post type.
     */
    public function add_meta_boxes() {
        add_meta_box(
            $this->meta_box_id,
            __('Gallery Layers', 'dlpg'),
            [$this, 'render_meta_box'],
            $this->post_type_name,
            'normal',
            'high'
        );
    }

    /**
     * Render the meta box for adding layers to the gallery.
     */
    public function render_meta_box($post) {
        wp_nonce_field('dlpg_save_meta_box_data', 'dlpg_nonce_field');
        $layers = get_post_meta($post->ID, 'dlpg_layers', true);
        if (empty($layers)) {
            $layers = [];
        }
        ?>
        <div class="dlpg-meta-box-container">
            <div class="dlpg-layer-list">
                <?php foreach ($layers as $index => $layer) : ?>
                    <div class="dlpg-layer" data-index="<?php echo esc_attr($index); ?>">
                        <div class="dlpg-layer-header">
                            <span class="dlpg-layer-title">Layer <?php echo esc_html($index + 1); ?></span>
                            <a href="#" class="dlpg-remove-layer button button-small" data-index="<?php echo esc_attr($index); ?>">Remove</a>
                        </div>
                        <div class="dlpg-layer-content">
                            <label for="dlpg_layer_image_<?php echo esc_attr($index); ?>">
                                <?php _e('Layer Image:', 'dlpg'); ?>
                            </label>
                            <input type="hidden" name="dlpg_layers[<?php echo esc_attr($index); ?>][image]" value="<?php echo esc_attr($layer['image'] ?? ''); ?>">
                            <?php echo wp_get_attachment_image($layer['image'], 'medium', ['class' => 'dlpg-layer-image-preview']); ?>
                            <input type="button" class="dlpg-upload-image button" value="<?php _e('Upload Image', 'dlpg'); ?>" data-index="<?php echo esc_attr($index); ?>">
                            <br>
                            <label for="dlpg_layer_content_<?php echo esc_attr($index); ?>">
                                <?php _e('Layer Content (HTML allowed):', 'dlpg'); ?>
                            </label>
                            <textarea name="dlpg_layers[<?php echo esc_attr($index); ?>][content]" class="large-text dlpg-layer-content-text"><?php echo esc_textarea(trim($layer['content'] ?? '')); ?></textarea>
                            <br>
                            <label for="dlpg_layer_effect_<?php echo esc_attr($index); ?>">
                                <?php _e('Hover Effect:', 'dlpg'); ?>
                            </label>
                            <select name="dlpg_layers[<?php echo esc_attr($index); ?>][effect]" class="dlpg-layer-effect">
                                <option value="fade" <?php selected($layer['effect'] ?? '', 'fade'); ?>>Fade</option>
                                <option value="slide-up" <?php selected($layer['effect'] ?? '', 'slide-up'); ?>>Slide Up</option>
                                <option value="slide-left" <?php selected($layer['effect'] ?? '', 'slide-left'); ?>>Slide Left</option>
                                <option value="slide-right" <?php selected($layer['effect'] ?? '', 'slide-right'); ?>>Slide Right</option>
                                <option value="scale" <?php selected($layer['effect'] ?? '', 'scale'); ?>>Scale</option>
                            </select>
                        </div>
                    </div>
                <?php endforeach; ?>
            </div>
            <input type="button" class="dlpg-add-layer button" value="<?php _e('Add New Layer', 'dlpg'); ?>">
        </div>
        <?php
    }

    /**
     * Save meta box data.
     */
    public function save_meta_box_data($post_id) {
        if (!isset($_POST['dlpg_nonce_field']) || !wp_verify_nonce($_POST['dlpg_nonce_field'], 'dlpg_save_meta_box_data')) {
            return;
        }
        if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
            return;
        }
        if (!current_user_can('edit_post', $post_id)) {
            return;
        }

        $layers = [];
        if (isset($_POST['dlpg_layers'])) {
            foreach ($_POST['dlpg_layers'] as $index => $layer) {
                $layers[$index] = [
                    'image' => $layer['image'],
                    'content' => $layer['content'],
                    'effect' => $layer['effect'],
                ];
            }
        }
        update_post_meta($post_id, 'dlpg_layers', $layers);
    }

    /**
     * Enqueue admin scripts and styles.
     */
    public function enqueue_admin_assets() {
        wp_enqueue_script('dlpg-admin', plugins_url('assets/js/admin.js', __FILE__), ['jquery'], '1.0', true);
        wp_enqueue_style('dlpg-admin', plugins_url('assets/css/admin.css', __FILE__));
    }

    /**
     * Enqueue public scripts and styles.
     */
    public function enqueue_public_assets() {
        wp_enqueue_script('dlpg-public', plugins_url('assets/js/public.js', __FILE__), ['jquery'], '1.0', true);
        wp_enqueue_style('dlpg-public', plugins_url('assets/css/public.css', __FILE__));
    }

    /**
     * Register custom REST API endpoints for gallery data.
     */
    public function register_custom_endpoints() {
        register_rest_route('dlpg/v1', '/galleries/(?P<id>\d+)', [
            'methods' => 'GET',
            'callback' => [$this, 'get_gallery_data'],
            'permission_callback' => function () {
                return current_user_can('read');
            },
        ]);
    }

    /**
     * Get gallery data for the REST API.
     */
    public function get_gallery_data($request) {
        $id = $request->get_param('id');
        $post = get_post($id);
        if (!$post || $post->post_type !== $this->post_type_name) {
            return new WP_REST_Response(['error' => __('Gallery not found.', 'dlpg')], 404);
        }

        $layers = get_post_meta($post->ID, 'dlpg_layers', true);
        $featured_image_id = get_post_thumbnail_id($post->ID);
        $featured_image = wp_get_attachment_image_url($featured_image_id, 'full');

        $response = [
            'id' => $id,
            'title' => $post->post_title,
            'excerpt' => $post->post_excerpt,
            'featured_image' => $featured_image,
            'layers' => $layers,
        ];

        return new WP_REST_Response($response, 200);
    }

    /**
     * Shortcode to display the gallery on the frontend.
     */
    public function gallery_shortcode($atts) {
        $atts = shortcode_atts([
            'id' => '',
            'style' => 'default',
        ], $atts, 'dlpg_gallery');

        if (empty($atts['id'])) {
            return '';
        }

        $post = get_post($atts['id']);
        if (!$post || $post->post_type !== $this->post_type_name) {
            return '';
        }

        $layers = get_post_meta($post->ID, 'dlpg_layers', true);
        $featured_image_id = get_post_thumbnail_id($post->ID);
        $featured_image = wp_get_attachment_image($featured_image_id, 'large', ['class' => 'dlpg-featured-image']);

        ob_start();
        ?>
        <div class="dlpg-gallery dlpg-gallery-<?php echo esc_attr($atts['style']); ?>">
            <?php if (!empty($featured_image)) : ?>
                <div class="dlpg-featured-image-container">
                    <?php echo $featured_image; ?>
                </div>
            <?php endif; ?>
            <div class="dlpg-gallery-container">
                <?php foreach ($layers as $index => $layer) : ?>
                    <div class="dlpg-layer dlpg-layer-<?php echo esc_attr($index); ?>" data-effect="<?php echo esc_attr($layer['effect'] ?? 'fade'); ?>">
                        <?php if (!empty($layer['image'])) : ?>
                            <img src="<?php echo esc_url(wp_get_attachment_image_url($layer['image'], 'large')); ?>" alt="<?php _e('Layer Image', 'dlpg'); ?>" class="dlpg-layer-image">
                        <?php endif; ?>
                        <div class="dlpg-layer-content">
                            <?php echo wp_kses_post($layer['content'] ?? ''); ?>
                        </div>
                    </div>
                <?php endforeach; ?>
            </div>
        </div>
        <?php
        return ob_get_clean();
    }
}

// Initialize the plugin
new Dynamic_Layered_Portfolio_Gallery();

// Register shortcode
add_shortcode('dlpg_gallery', ['Dynamic_Layered_Portfolio_Gallery', 'gallery_shortcode']);

extends CharacterBody2D

# Quantum Enemy AI - Probabilistic State Machine
# Features quantum superposition states, observation collapse, and entanglement between enemies

@export var walk_speed: float = 150.0
@export var run_speed: float = 300.0
@export var detection_range: float = 600.0
@export var attack_range: float = 150.0
@export var vision_angle: float = 60.0 * (Math.PI / 180)  # in radians
@export var attack_cooldown: float = 1.0
@export var quantum_observation_chance: float = 0.3  # 30% chance to observe player
@export var entanglement_chance: float = 0.2  # 20% chance to entangle with another enemy

enum State {
	IDLE,
	WANDER,
	DETECTED,
	ATTACK,
	FLEE,
	ENTANGLED  # Special state for quantum entanglement
}

enum Direction {
	LEFT,
	RIGHT,
	UP,
	DOWN
}

class_name: "QuantumEnemyAI"
onready var player: Node2D = get_node("/root/Player")
onready var animation_player: AnimationPlayer = $AnimationPlayer
onready var sprite: Sprite2D = $Sprite2D
onready var health_bar: ProgressBar = $HealthBar
onready var _health: int = 100

var current_state: State = State.IDLE
var next_state: State = State.IDLE
var current_direction: Direction = Direction.RIGHT
var wander_target: Vector2 = Vector2.ZERO
var last_attack_time: float = 0.0
var entangled_with: QuantumEnemyAI? = null
var quantum_probabilities: Dictionary = {
	IDLE: 0.1,
	WANDER: 0.4,
	DETECTED: 0.3,
	ATTACK: 0.2,
	FLEE: 0.0,
	ENTANGLED: 0.0
}
var observation_collapsed: bool = false

func _ready() -> void:
	# Initialize random seed based on position
	randi().seed(int(get_global_mouse_position().x) + int(get_global_mouse_position().y))

	# Set initial animation
	animation_player.play("idle")

	# Set initial wander target
	update_wander_target()

	# Register for entanglement signals if needed
	if Input.is_action_pressed("ui_accept"):
		# Debug: Force entanglement when pressing E (for testing)
		for enemy in get_tree().get_nodes_in_group("enemies"):
			if enemy != self and randf() < 0.5:
				entanglement_collapsed()
				break

func _process(delta: float) -> void:
	match current_state:
		State.IDLE:
			idle_state(delta)
		State.WANDER:
			wander_state(delta)
		State.DETECTED:
			detected_state(delta)
		State.ATTACK:
			attack_state(delta)
		State.FLEE:
			flee_state(delta)
		State.ENTANGLED:
			entangled_state(delta)

	# Handle state transitions with quantum probabilities
	if not observation_collapsed:
		quantum_state_transition()

	# Handle observation collapse
	if observation_collapsed and randf() < quantum_observation_chance:
		quantum_observation_collapse()

	# Update health bar
	health_bar.value = _health / 100.0

func quantum_state_transition() -> void:
	# Quantum superposition - maintain multiple possible states
	var possible_states = [
		State.IDLE, State.WANDER, State.DETECTED,
		State.ATTACK, State.FLEE, State.ENTANGLED
	]

	# Calculate weighted probabilities (some states may be unavailable)
	var available_states = []
	var total_weight = 0.0
	for state in possible_states:
		var weight = quantum_probabilities.get(state, 0.0)
		if weight > 0.0:
			available_states.append(state)
			total_weight += weight

	if total_weight > 0.0:
		# Normalize weights
		for i in range(available_states.size()):
			quantum_probabilities[available_states[i]] /= total_weight

		# Select next state based on probabilities
		var random_value = randf()
		var cumulative = 0.0
		for state in available_states:
			cumulative += quantum_probabilities[state]
			if random_value <= cumulative:
				next_state = state
				break

func quantum_observation_collapse() -> void:
	# When observed, collapse to a definite state
	observation_collapsed = true
	if randf() < 0.5 and can_detect_player():
		next_state = State.DETECTED
	else:
		next_state = State.WANDER

func idle_state(delta: float) -> void:
	# Idle behavior - transition to wander after a while
	if randf() < 0.02:  # 2% chance per frame
		next_state = State.WANDER

	# Face current direction
	velocity = Vector2.ZERO
	animation_player.play("idle")

func wander_state(delta: float) -> void:
	# Wander toward target point
	var target_pos = global_position + (wander_target - global_position).normalized() * walk_speed * delta
	var new_pos = move_toward(target_pos, walk_speed * delta)

	if new_pos.distance_to(wander_target) < 20:
		update_wander_target()

	# Check if player is detected
	if can_detect_player():
		next_state = State.DETECTED

	# Update animation based on direction
	update_animation_state(velocity)

func detected_state(delta: float) -> void:
	# Move toward player if not in attack range
	if global_position.distance_to(player.global_position) > attack_range:
		velocity = (player.global_position - global_position).normalized() * run_speed
		velocity = move_and_slide(velocity, Vector2.UP, false)
		animation_player.play("run")

		# Face player
		current_direction = get_direction_to_player()

		# Check if player is in attack range
		if global_position.distance_to(player.global_position) <= attack_range:
			next_state = State.ATTACK
	else:
		next_state = State.ATTACK

func attack_state(delta: float) -> void:
	# Attack cooldown
	if Time.get_ticks_msec() - last_attack_time > attack_cooldown * 1000:
		# Perform attack
		attack()
		last_attack_time = Time.get_ticks_msec()

		# After attack, decide next state
		next_state = State.IDLE

	# Update animation
	animation_player.play("attack")

func flee_state(delta: float) -> void:
	# Flee from player in random direction
	var flee_direction = Vector2(randf_range(-1, 1), randf_range(-1, 1)).normalized()
	velocity = flee_direction * run_speed
	velocity = move_and_slide(velocity, Vector2.UP, false)
	animation_player.play("run")

	# Check if fleeing is over (player not detected for a while)
	if not can_detect_player() and randf() < 0.01:
		next_state = State.IDLE

func entangled_state(delta: float) -> void:
	# When entangled, move in sync with the other enemy
	if entangled_with:
		velocity = (entanglement_calculate_velocity())
		velocity = move_and_slide(velocity, Vector2.UP, false)
		animation_player.play("idle")

		# After some time, entanglement breaks
		if randf() < 0.005:  # 0.5% chance per frame to break
			entanglement_break()
	else:
		entanglement_break()

	# Update direction to match entangled enemy
	if entangled_with:
		current_direction = entangled_with.current_direction

func can_detect_player() -> bool:
	# Check if player is in detection range and angle
	var to_player = player.global_position - global_position
	var distance = to_player.length()
	if distance > detection_range:
		return false

	var angle = to_player.angle()
	var player_angle = player.global_position - global_position
	var vision_half_angle = vision_angle / 2.0
	var vision_start_angle = player_angle - vision_half_angle
	var vision_end_angle = player_angle + vision_half_angle

	# Normalize angles
	var my_angle = global_position - player.global_position
	my_angle = my_angle.angle()

	# Check if player is in front of the enemy
	return (my_angle >= vision_start_angle and my_angle <= vision_end_angle)

func get_direction_to_player() -> Direction:
	var to_player = player.global_position - global_position
	var angle = to_player.angle()

	if abs(angle) < Math.PI / 4:
		return Direction.RIGHT
	elif abs(angle - Math.PI) < Math.PI / 4:
		return Direction.LEFT
	elif abs(angle - Math.PI / 2) < Math.PI / 4:
		return Direction.UP
	else:
		return Direction.DOWN

func update_wander_target() -> void:
	# Set a new random wander target within detection range
	wander_target = global_position + Vector2(
		randf_range(-detection_range, detection_range),
		randf_range(-detection_range, detection_range)
	)

func update_animation_state(velocity: Vector2) -> void:
	# Update animation based on movement direction
	if velocity.length() > 0:
		var direction = velocity.normalized()
		if abs(direction.x) > abs(direction.y):
			if direction.x > 0:
				current_direction = Direction.RIGHT
				animation_player.play("run")
				sprite.flip_h = false
			else:
				current_direction = Direction.LEFT
				animation_player.play("run")
				sprite.flip_h = true
		else:
			if direction.y > 0:
				current_direction = Direction.UP
				animation_player.play("run")
			else:
				current_direction = Direction.DOWN
				animation_player.play("run")
	else:
		animation_player.play("idle")

func attack() -> void:
	# Simple attack - can be expanded with particle effects, etc.
	print("Enemy attacks! Player health: ", player.get("health", 100) - 10)
	player.call("take_damage", 10)

func entanglement_collapsed() -> void:
	# Find another enemy to entangle with
	for enemy in get_tree().get_nodes_in_group("enemies"):
		if enemy != self and enemy is QuantumEnemyAI and randf() < entanglement_chance:
			entanglement_initialize(enemy)
			enemy.entanglement_initialize(self)
			break

func entanglement_initialize(enemy: QuantumEnemyAI) -> void:
	# Initialize entanglement with another enemy
	entanglement_break()  # Clear any existing entanglement
	entanglement_break()  # Clear on both sides (called twice in collapsed)

	entanglement_with = enemy
	enemy.entanglement_with = self
	current_state = State.ENTANGLED
	next_state = State.ENTANGLED
	quantum_probabilities[State.ENTANGLED] = 0.5  # High probability to stay entangled

func entanglement_calculate_velocity() -> Vector2:
	# Calculate velocity based on entangled enemy's position
	if not entangled_with:
		return Vector2.ZERO

	# Move toward the average position of both enemies
	var avg_pos = (global_position + entangled_with.global_position) / 2.0
	var direction = (avg_pos - global_position).normalized()
	return direction * walk_speed * 0.5  # Move at half speed toward center

func entanglement_break() -> void:
	# Break entanglement
	entanglement_with = null
	quantum_probabilities[State.ENTANGLED] = 0.0
	next_state = State.IDLE

func take_damage(amount: int) -> void:
	_health -= amount
	if _health <= 0:
		die()

func die() -> void:
	# Remove from scene when dead
	queue_free()

# Connect to signals in the editor
@onready var _on_player_detected: SignalTool = null
@onready var _on_attack: SignalTool = null

func _ready() -> void:
	_on_player_detected = call_deferred("_on_player_detected_handler")
	_on_attack = call_deferred("_on_attack_handler")

func _on_player_detected_handler() -> void:
	if can_detect_player():
		next_state = State.DETECTED

func _on_attack_handler() -> void:
	if current_state == State.ATTACK:
		attack()

```kotlin
import android.Manifest
import android.annotation.SuppressLint
import android.content.ClipData
import android.content.ClipboardManager
import android.content.Context
import android.graphics.Color
import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Copy
import androidx.compose.material.icons.filled.Favorite
import androidx.compose.material.icons.filled.FavoriteBorder
import androidx.compose.material.icons.filled.Star
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color as ComposeColor
import androidx.compose.ui.graphics.drawscope.DrawScope
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.content.ContextCompat
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import com.google.accompanist.permissions.ExperimentalPermissionsApi
import com.google.accompanist.permissions.rememberPermissionState
import com.google.mlkit.vision.barcode.BarcodeScannerOptions
import com.google.mlkit.vision.barcode.HighStandbyMode
import com.google.mlkit.vision.barcode.common.Barcode
import com.google.mlkit.vision.barcode.common.BarcodeDetector
import com.google.mlkit.vision.barcode.common.BarcodeDetectorOptions
import com.google.mlkit.vision.barcode.common.BarcodeFormat
import com.google.mlkit.vision.barcode.common.BarcodeScanningMode
import com.journeyapps.barcodescanner.BarcodeCallbackManager
import com.journeyapps.barcodescanner.BarcodeResult
import com.journeyapps.barcodescanner.DecoratedBarcodeView
import com.journeyapps.barcodescanner.ScanContract
import com.journeyapps.barcodescanner.ScanOptions
import com.journeyapps.barcodescanner.BarcodeView
import com.journeyapps.barcodescanner.CaptureManager
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.TextUnit
import kotlinx.coroutines.delay

class QRScanAdventure : ComponentActivity() {
    private lateinit var barcodeView: BarcodeView
    private lateinit var capture: CaptureManager
    private lateinit var barcodeCallbackManager: BarcodeCallbackManager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            QRScanAdventureTheme {
                Surface(modifier = Modifier.fillMaxSize()) {
                    QRScanAdventureScreen()
                }
            }
        }
    }
}

@Composable
fun QRScanAdventureScreen() {
    val context = LocalContext.current
    val lifecycleOwner = LocalLifecycleOwner.current
    var points by remember { mutableStateOf(0) }
    var isScanning by remember { mutableStateOf(false) }
    var lastScannedText by remember { mutableStateOf("") }
    var favoriteCodes by remember { mutableStateOf(emptyList<String>()) }
    var isFavorite by remember { mutableStateOf(false) }
    var showBonusEffect by remember { mutableStateOf(false) }
    var showSecretMessage by remember { mutableStateOf(false) }
    var secretMessage by remember { mutableStateOf("") }

    val permissionState = rememberPermissionState(Manifest.permission.CAMERA)
    val scanLauncher = rememberLauncherForScan(context, barcodeCallbackManager)

    LaunchedEffect(permissionState.status) {
        if (permissionState.status.isGranted) {
            isScanning = true
        }
    }

    barcodeCallbackManager = BarcodeCallbackManager { result: BarcodeResult ->
        handleBarcodeResult(result, points, lastScannedText, favoriteCodes, isFavorite, showBonusEffect, showSecretMessage, secretMessage)
    }

    DisposableEffect(lifecycleOwner) {
        val observer = LifecycleEventObserver { _, event ->
            if (event == Lifecycle.Event.ON_PAUSE) {
                isScanning = false
                barcodeCallbackManager.removeCallback()
            }
        }
        lifecycleOwner.lifecycle.addObserver(observer)
        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(
                Brush.verticalGradient(
                    colors = listOf(
                        ComposeColor(0xFF000033),
                        ComposeColor(0xFF000066)
                    )
                )
            ),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        // Points display with space theme
        Text(
            text = "Points: $points",
            color = ComposeColor.White,
            fontSize = 24.sp,
            fontWeight = FontWeight.Bold,
            modifier = Modifier.padding(bottom = 16.dp)
        )

        // Space-themed scanner frame
        Box(
            modifier = Modifier
                .aspectRatio(1f)
                .clip(RoundedCornerShape(16.dp))
                .background(ComposeColor.Black.copy(alpha = 0.7f))
                .padding(16.dp)
        ) {
            if (isScanning) {
                BarcodeView(
                    modifier = Modifier
                        .fillMaxSize()
                        .clip(RoundedCornerShape(8.dp))
                        .background(ComposeColor.Transparent),
                    decoderOptions = createDecoderOptions(),
                    onResult = { result -> handleBarcodeResult(result, points, lastScannedText, favoriteCodes, isFavorite, showBonusEffect, showSecretMessage, secretMessage) }
                ).also { barcodeView = it }
            } else {
                Column(
                    modifier = Modifier.fillMaxSize(),
                    verticalArrangement = Arrangement.Center,
                    horizontalAlignment = Alignment.CenterHorizontally
                ) {
                    Text(
                        text = "Scan to begin your adventure!",
                        color = ComposeColor.White,
                        fontSize = 18.sp
                    )
                    Spacer(modifier = Modifier.height(16.dp))
                    CircularProgressIndicator(
                        color = ComposeColor(0xFF4CAF50),
                        modifier = Modifier.size(48.dp)
                    )
                }
            }
        }

        Spacer(modifier = Modifier.height(16.dp))

        // Action buttons
        Column(horizontalAlignment = Alignment.CenterHorizontally) {
            Button(
                onClick = { scanLauncher.launch(true) },
                modifier = Modifier
                    .fillMaxWidth()
                    .height(56.dp)
                    .clip(RoundedCornerShape(24.dp)),
                colors = ButtonDefaults.buttonColors(
                    containerColor = ComposeColor(0xFF4CAF50),
                    contentColor = ComposeColor.White
                ),
                shape = RoundedCornerShape(24.dp)
            ) {
                Text(
                    text = if (isScanning) "Stop Scan" else "Start Scan",
                    fontSize = 18.sp,
                    fontWeight = FontWeight.Bold
                )
            }

            Spacer(modifier = Modifier.height(8.dp))

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.Center
            ) {
                IconButton(
                    onClick = {
                        val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
                        val clip = ClipData.newPlainText("QR Code", lastScannedText)
                        clipboard.setPrimaryClip(clip)
                        Toast.makeText(context, "Copied to clipboard", Toast.LENGTH_SHORT).show()
                    },
                    enabled = lastScannedText.isNotEmpty()
                ) {
                    Icon(Icons.Default.Copy, contentDescription = "Copy", tint = ComposeColor.White)
                }

                IconButton(
                    onClick = {
                        if (lastScannedText in favoriteCodes) {
                            favoriteCodes = favoriteCodes - lastScannedText
                            isFavorite = false
                        } else {
                            favoriteCodes = favoriteCodes + lastScannedText
                            isFavorite = true
                        }
                    },
                    enabled = lastScannedText.isNotEmpty()
                ) {
                    Icon(
                        if (isFavorite) Icons.Default.Favorite else Icons.Default.FavoriteBorder,
                        contentDescription = if (isFavorite) "Remove from favorites" else "Add to favorites",
                        tint = if (isFavorite) ComposeColor(0xFFFF5252) else ComposeColor.White
                    )
                }
            }
        }

        // Bonus effect animation
        if (showBonusEffect) {
            AnimatedBonusEffect()
            LaunchedEffect(Unit) {
                delay(2000)
                showBonusEffect = false
            }
        }

        // Favorite codes list
        if (favoriteCodes.isNotEmpty()) {
            Spacer(modifier = Modifier.height(16.dp))
            Text(
                text = "Favorite Codes (${favoriteCodes.size})",
                color = ComposeColor.White,
                fontSize = 18.sp,
                fontWeight = FontWeight.Bold
            )

            Column(modifier = Modifier.fillMaxWidth()) {
                favoriteCodes.forEachIndexed { index, code ->
                    FavoriteCodeItem(
                        code = code,
                        onClick = { copyToClipboard(context, code) },
                        modifier = Modifier
                            .fillMaxWidth()
                            .padding(horizontal = 16.dp, vertical = 4.dp)
                    )
                }
            }
        }

        // Secret message display
        if (showSecretMessage && secretMessage.isNotEmpty()) {
            Box(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(16.dp)
                    .clip(RoundedCornerShape(8.dp))
                    .background(ComposeColor.Black.copy(alpha = 0.8f)),
                contentAlignment = Alignment.Center
            ) {
                Text(
                    text = secretMessage,
                    color = ComposeColor(0xFF00FF00),
                    fontSize = 18.sp,
                    fontWeight = FontWeight.Bold,
                    modifier = Modifier.padding(16.dp)
                )
            }
            LaunchedEffect(Unit) {
                delay(5000)
                showSecretMessage = false
            }
        }
    }
}

@Composable
fun handleBarcodeResult(
    result: BarcodeResult,
    points: Int,
    lastScannedText: String,
    favoriteCodes: List<String>,
    isFavorite: Boolean,
    showBonusEffect: Boolean,
    showSecretMessage: Boolean,
    secretMessage: String
) {
    val context = LocalContext.current
    var pointsState = remember { mutableStateOf(points) }
    var lastScannedTextState = remember { mutableStateOf(lastScannedText) }
    var favoriteCodesState = remember { mutableStateOf(favoriteCodes) }
    var isFavoriteState = remember { mutableStateOf(isFavorite) }
    var showBonusEffectState = remember { mutableStateOf(showBonusEffect) }
    var showSecretMessageState = remember { mutableStateOf(showSecretMessage) }
    var secretMessageState = remember { mutableStateOf(secretMessage) }

    result.bitstring?.let { bitstring ->
        val newPoints = points + (bitstring.length * 10)
        pointsState.value = newPoints
        Toast.makeText(context, "Bonus points: +${bitstring.length * 10}", Toast.LENGTH_SHORT).show()
        showBonusEffectState.value = true
    } ?: run {
        result.rawValue?.let { rawValue ->
            lastScannedTextState.value = rawValue
            Toast.makeText(context, "Scanned: $rawValue", Toast.LENGTH_SHORT).show()

            // Check if this is a secret code (contains "space" or "galaxy")
            if (rawValue.contains("space", ignoreCase = true) ||
                rawValue.contains("galaxy", ignoreCase = true) ||
                rawValue.contains("NASA", ignoreCase = true)) {
                showSecretMessageState.value = true
                secretMessageState.value = "🚀 Space bonus unlocked! You've found a cosmic code! 🌌"

                // Award extra points for secret codes
                val extraPoints = if (rawValue.contains("NASA")) 500 else 100
                pointsState.value = points + extraPoints
                Toast.makeText(context, "Extra $extraPoints points for secret code!", Toast.LENGTH_SHORT).show()
            }

            // Check if this is a bonus code (contains "bonus" or "reward")
            if (rawValue.contains("bonus", ignoreCase = true) ||
                rawValue.contains("reward", ignoreCase = true)) {
                showBonusEffectState.value = true
                pointsState.value = points + 200
                Toast.makeText(context, "Bonus reward! +200 points", Toast.LENGTH_SHORT).show()
            }
        }
    }
}

fun createDecoderOptions(): BarcodeDetectorOptions {
    return BarcodeDetectorOptions.Builder()
        .setBarcodeFormats(
            BarcodeFormat.QR_CODE,
            BarcodeFormat.AZTEC,
            BarcodeFormat.DATA_MATRIX,
            BarcodeFormat.UPC_A,
            BarcodeFormat.UPC_E,
            BarcodeFormat.EAN_8,
            BarcodeFormat.EAN_13,
            BarcodeFormat.CODABAR
        )
        .setCharacterSet listOf("UTF-8", "ISO-8859-1")
        .setPossibleSymbolValueFormats(listOf())
        .build()
}

@Composable
fun AnimatedBonusEffect() {
    Canvas(
        modifier = Modifier
            .fillMaxWidth()
            .height(100.dp)
    ) {
        val starCount = 20
        for (i in 0 until starCount) {
            val angle = (i * (360f / starCount)).toDouble().toRadians()
            val radius = size.width * 0.8f
            val x = center.x + radius * cos(angle)
            val y = center.y + radius * sin(angle)

            drawCircle(
                color = ComposeColor(0xFF00FF00),
                radius = 4f,
                center = Offset(x, y)
            )

            // Add trailing effects
            drawLine(
                color = ComposeColor(0xFF00FF00).copy(alpha = 0.3f),
                start = Offset(x, y),
                end = Offset(x + 10 * cos(angle), y + 10 * sin(angle)),
                strokeWidth = 1f
            )
        }
    }
}

@Composable
fun FavoriteCodeItem(code: String, onClick: () -> Unit, modifier: Modifier = Modifier) {
    Row(
        modifier = modifier
            .clip(RoundedCornerShape(8.dp))
            .background(ComposeColor(0xFF333366))
            .padding(12.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.SpaceBetween
    ) {
        Text(
            text = code.take(12) + if (code.length > 12) "..." else "",
            color = ComposeColor.White,
            fontSize = 14.sp
        )

        IconButton(
            onClick = onClick,
            modifier = Modifier.size(24.dp)
        ) {
            Icon(
                imageVector = Icons.Default.Copy,
                contentDescription = "Copy",
                tint = ComposeColor.White,
                modifier = Modifier.size(20.dp)
            )
        }
    }
}

@Composable
fun copyToClipboard(context: Context, text: String) {
    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
    val clip = ClipData.newPlainText("Copied QR Code", text)
    clipboard.setPrimaryClip(clip)
    Toast.makeText(context, "Copied to clipboard", Toast.LENGTH_SHORT).show()
}

@Preview(showBackground = true)
@Composable
fun QRScanAdventurePreview() {
    QRScanAdventureTheme {
        QRScanAdventureScreen()
    }
}

fun Double.toRadians(): Double {
    return this * Math.PI / 180.0
}

fun rememberLauncherForScan(context: Context, callbackManager: BarcodeCallbackManager) =
    remember(context) {
        object : BarcodeScanLauncher(context, callbackManager) {}
    }

class BarcodeScanLauncher(
    private val context: Context,
    private val callbackManager: BarcodeCallbackManager
) {
    private val scanLauncher = context.registryForActivityResult(
        ScanContract()
    ) { result ->
        result.contents?.let { barcodeResult ->
            callbackManager.handleResult(barcodeResult)
        }
    }