A!leys Galerie

<?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)
        }
    }

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Whispers of the Alley</title>
    <style>
        :root {
            --alley-bg: #1a2a3a;
            --alley-text: #f5e6d3;
            --alley-highlight: #ff9a56;
            --shadow-color: rgba(0, 0, 0, 0.7);
            --verse-color: #d4c4a8;
            --transition-speed: 0.8s;
        }

        body {
            margin: 0;
            padding: 0;
            font-family: 'Courier New', monospace;
            background-color: var(--alley-bg);
            color: var(--alley-text);
            overflow: hidden;
            height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            text-align: center;
            background-image: radial-gradient(circle at 20% 50%, rgba(255, 255, 255, 0.05) 1px, transparent 1px),
                              radial-gradient(circle at 80% 50%, rgba(255, 255, 255, 0.05) 1px, transparent 1px);
            background-size: 100px 100px;
        }

        #alley {
            position: relative;
            width: 90vw;
            max-width: 800px;
            height: 80vh;
            max-height: 600px;
            border: 2px dashed var(--alley-highlight);
            border-radius: 10px;
            overflow: hidden;
            box-shadow: 0 0 20px var(--shadow-color);
            background: linear-gradient(to bottom, #1a2a3a 0%, #2a3a4a 100%);
            padding: 2rem;
            box-sizing: border-box;
        }

        #verse-container {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            opacity: 0;
            transition: opacity var(--transition-speed) ease, transform var(--transition-speed) ease;
            color: var(--verse-color);
            font-size: 1.2rem;
            line-height: 1.6;
            text-shadow: 0 0 5px rgba(0, 0, 0, 0.3);
            z-index: 2;
            width: 80%;
        }

        #verse {
            display: none;
            margin-bottom: 1rem;
            padding: 0.5rem 1rem;
            border-radius: 5px;
            background-color: rgba(0, 0, 0, 0.2);
            backdrop-filter: blur(2px);
        }

        #verse.active {
            display: block;
            animation: fadeIn 1s ease;
        }

        .shadow-figure {
            position: absolute;
            width: 30px;
            height: 30px;
            border-radius: 50%;
            background-color: var(--shadow-color);
            box-shadow: 0 0 10px var(--shadow-color);
            z-index: 1;
            transition: all 0.5s ease;
        }

        #instruction {
            position: absolute;
            top: 10px;
            left: 10px;
            font-size: 0.8rem;
            opacity: 0.7;
            transition: opacity 0.5s ease;
        }

        #instruction.hidden {
            opacity: 0;
        }

        @keyframes fadeIn {
            from { opacity: 0; transform: translateY(20px); }
            to { opacity: 1; transform: translateY(0); }
        }

        @media (max-width: 600px) {
            #verse-container {
                font-size: 1rem;
                width: 90%;
            }
        }
    </style>
</head>
<body>
    <div id="alley">
        <div id="instruction">Move your mouse across the alley to summon shadows and unveil verses...</div>
        <div id="verse-container"></div>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const alley = document.getElementById('alley');
            const verseContainer = document.getElementById('verse-container');
            const instruction = document.getElementById('instruction');

            // Verses to be displayed
            const verses = [
                "A shadow dances where the lamplight fades,",
                "Whispering secrets in the alley's shade.",
                "Footsteps echo, soft yet clear,",
                "Like a melody lost, now crystal-clear.",
                "The alley hums with stories untold,",
                "Of laughter and sorrow, brave and bold.",
                "A door creaks open, just a crack,",
                "Revealing moments that the light won't take.",
                "The night weaves tales with silver thread,",
                "In the heart of this forgotten bed.",
                "But when the dawn begins to peek,",
                "The shadows fade—yet leave no sneak,",
                "For every verse, every hue,",
                "Lives in the echoes, ancient and true."
            ];

            // Create shadow figures (5 per side)
            const shadowFigures = [];
            for (let i = 0; i < 5; i++) {
                const leftShadow = createShadow('left', i);
                const rightShadow = createShadow('right', i);
                alley.appendChild(leftShadow);
                alley.appendChild(rightShadow);
                shadowFigures.push(leftShadow, rightShadow);
            }

            // Mouse movement tracking
            let mouseX = 0;
            let mouseY = 0;

            alley.addEventListener('mousemove', (e) => {
                mouseX = e.clientX;
                mouseY = e.clientY;

                // Update shadow positions
                shadowFigures.forEach(shadow => {
                    updateShadowPosition(shadow);
                });

                // Show/hide instruction
                if (mouseX > alley.offsetLeft + 10 && mouseX < alley.offsetLeft + alley.offsetWidth - 10 &&
                    mouseY > alley.offsetTop + 10 && mouseY < alley.offsetTop + alley.offsetHeight - 10) {
                    instruction.classList.add('hidden');
                } else {
                    instruction.classList.remove('hidden');
                }
            });

            // Function to create a shadow figure
            function createShadow(side, index) {
                const shadow = document.createElement('div');
                shadow.className = 'shadow-figure';
                shadow.dataset.side = side;
                shadow.dataset.index = index;

                // Position shadows on the sides
                if (side === 'left') {
                    shadow.style.left = '10px';
                    shadow.style.top = `${20 + index * 50}%`;
                } else {
                    shadow.style.right = '10px';
                    shadow.style.top = `${20 + index * 50}%`;
                }

                return shadow;
            }

            // Function to update shadow position based on mouse
            function updateShadowPosition(shadow) {
                const rect = alley.getBoundingClientRect();
                const alleyLeft = rect.left;
                const alleyTop = rect.top;
                const alleyWidth = rect.width;
                const alleyHeight = rect.height;

                const mouseInAlleyX = mouseX - alleyLeft;
                const mouseInAlleyY = mouseY - alleyTop;
                const mousePercentX = mouseInAlleyX / alleyWidth;
                const mousePercentY = mouseInAlleyY / alleyHeight;

                const shadow = shadow;

                // Calculate direction based on mouse position
                if (shadow.dataset.side === 'left') {
                    // Shadows on the left move toward the mouse if it's more to the right
                    const targetX = alleyLeft + 100 + (mouseInAlleyX * 0.3);
                    const targetY = alleyTop + 100 + (mouseInAlleyY * 0.3);
                    shadow.style.left = `${targetX - alleyLeft}px`;
                    shadow.style.top = `${targetY - alleyTop}px`;

                    // If mouse is on the right side, make shadow larger and more prominent
                    if (mouseInAlleyX > alleyWidth * 0.6) {
                        shadow.style.width = '40px';
                        shadow.style.height = '40px';
                        shadow.style.boxShadow = '0 0 15px var(--shadow-color)';
                    } else {
                        shadow.style.width = '30px';
                        shadow.style.height = '30px';
                        shadow.style.boxShadow = '0 0 10px var(--shadow-color)';
                    }
                } else {
                    // Shadows on the right move toward the mouse if it's more to the left
                    const targetX = alleyLeft + alleyWidth - 110 - (mouseInAlleyX * 0.3);
                    const targetY = alleyTop + 100 + (mouseInAlleyY * 0.3);
                    shadow.style.right = `${alleyWidth - (targetX - alleyLeft)}px`;
                    shadow.style.top = `${targetY - alleyTop}px`;

                    // If mouse is on the left side, make shadow larger and more prominent
                    if (mouseInAlleyX < alleyWidth * 0.4) {
                        shadow.style.width = '40px';
                        shadow.style.height = '40px';
                        shadow.style.boxShadow = '0 0 15px var(--shadow-color)';
                    } else {
                        shadow.style.width = '30px';
                        shadow.style.height = '30px';
                        shadow.style.boxShadow = '0 0 10px var(--shadow-color)';
                    }
                }

                // Trigger verse when shadow is near the center
                if (side === 'left' && mouseInAlleyX > alleyWidth * 0.4) {
                    if (shadow.dataset.index === '0' && !shadow.classList.contains('active')) {
                        showVerse(0);
                        shadow.classList.add('active');
                    }
                } else if (side === 'right' && mouseInAlleyX < alleyWidth * 0.6) {
                    if (shadow.dataset.index === '0' && !shadow.classList.contains('active')) {
                        showVerse(1);
                        shadow.classList.add('active');
                    }
                }

                // Additional verses for other shadows
                if (side === 'left') {
                    if (mouseInAlleyX > alleyWidth * 0.3 && shadow.dataset.index === '1' && !shadow.classList.contains('active')) {
                        showVerse(2);
                        shadow.classList.add('active');
                    }
                    if (mouseInAlleyX > alleyWidth * 0.2 && shadow.dataset.index === '2' && !shadow.classList.contains('active')) {
                        showVerse(3);
                        shadow.classList.add('active');
                    }
                    if (mouseInAlleyY < alleyHeight * 0.4 && shadow.dataset.index === '3' && !shadow.classList.contains('active')) {
                        showVerse(4);
                        shadow.classList.add('active');
                    }
                    if (mouseInAlleyY > alleyHeight * 0.6 && shadow.dataset.index === '4' && !shadow.classList.contains('active')) {
                        showVerse(5);
                        shadow.classList.add('active');
                    }
                } else {
                    if (mouseInAlleyX < alleyWidth * 0.7 && shadow.dataset.index === '1' && !shadow.classList.contains('active')) {
                        showVerse(6);
                        shadow.classList.add('active');
                    }
                    if (mouseInAlleyX < alleyWidth * 0.8 && shadow.dataset.index === '2' && !shadow.classList.contains('active')) {
                        showVerse(7);
                        shadow.classList.add('active');
                    }
                    if (mouseInAlleyY < alleyHeight * 0.4 && shadow.dataset.index === '3' && !shadow.classList.contains('active')) {
                        showVerse(8);
                        shadow.classList.add('active');
                    }
                    if (mouseInAlleyY > alleyHeight * 0.6 && shadow.dataset.index === '4' && !shadow.classList.contains('active')) {
                        showVerse(9);
                        shadow.classList.add('active');
                    }
                }
            }

            // Function to show a verse
            function showVerse(index) {
                if (index >= 0 && index < verses.length) {
                    verseContainer.innerHTML = '';
                    const verse = document.createElement('div');
                    verse.id = 'verse';
                    verse.textContent = verses[index];
                    verseContainer.appendChild(verse);

                    // Fade out all verses after 5 seconds
                    setTimeout(() => {
                        verse.style.opacity = '0';
                        setTimeout(() => {
                            verse.remove();
                        }, 1000);
                    }, 5000);
                }
            }
        });
    </script>
</body>
</html>

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.UI;

[System.Serializable]
public class MemPellet : MonoBehaviour
{
    public string name;
    public Sprite icon;
    public int joyValue;
    public string flavor; // Emotional flavor (happy, sad, angry, etc.)
}

[System.Serializable]
public class FancyInventory
{
    public List<MemPellet> memPellets = new List<MemPellet>();
    public int totalJoy;
}

public class FancyInventorySystem : MonoBehaviour
{
    [Header("References")]
    public Text joyText;
    public Image memPelletDisplay;
    public Transform memPelletParent;
    public GameObject memPelletPrefab;

    [Header("Settings")]
    public float joyDecayRate = 0.1f;
    public float joyDecayInterval = 1.0f;
    public int maxMemPellets = 20;

    private FancyInventory inventory = new FancyInventory();
    private int currentPelletIndex = 0;
    private Coroutine joyDecayCoroutine;

    private void Awake()
    {
        if (joyDecayCoroutine != null)
        {
            StopCoroutine(joyDecayCoroutine);
        }
        joyDecayCoroutine = StartCoroutine(JoyDecay());
        LoadInventory();
        UpdateUI();
    }

    private void OnDestroy()
    {
        if (joyDecayCoroutine != null)
        {
            StopCoroutine(joyDecayCoroutine);
        }
        SaveInventory();
    }

    public void AddMemPellet(MemPellet pellet)
    {
        if (inventory.memPellets.Count >= maxMemPellets)
        {
            RemoveOldestPellet();
        }

        inventory.memPellets.Insert(0, pellet);
        inventory.totalJoy += pellet.joyValue;

        UpdateUI();
        SaveInventory();
    }

    private void RemoveOldestPellet()
    {
        if (inventory.memPellets.Count > 0)
        {
            var oldestPellet = inventory.memPellets[inventory.memPellets.Count - 1];
            inventory.totalJoy -= oldestPellet.joyValue;
            inventory.memPellets.RemoveAt(inventory.memPellets.Count - 1);
        }
    }

    private void UpdateUI()
    {
        joyText.text = $"Joy: {inventory.totalJoy}";

        if (inventory.memPellets.Count > 0)
        {
            currentPelletIndex = currentPelletIndex % inventory.memPellets.Count;
            var currentPellet = inventory.memPellets[currentPelletIndex];

            memPelletDisplay.sprite = currentPellet.icon;
            memPelletDisplay.color = GetFlavorColor(currentPellet.flavor);

            // Update mem pellet visuals
            foreach (Transform child in memPelletParent)
            {
                Destroy(child.gameObject);
            }

            for (int i = 0; i < inventory.memPellets.Count; i++)
            {
                var pellet = inventory.memPellets[i];
                var go = Instantiate(memPelletPrefab, memPelletParent);
                var img = go.GetComponent<Image>();
                img.sprite = pellet.icon;
                img.color = GetFlavorColor(pellet.flavor);

                // Position based on index (simple horizontal layout)
                RectTransform rect = go.GetComponent<RectTransform>();
                rect.anchoredPosition = new Vector2(i * 80f, 0);
            }
        }
    }

    private Color GetFlavorColor(string flavor)
    {
        switch (flavor.ToLower())
        {
            case "happy": return new Color(0.8f, 0.9f, 1f, 1f);
            case "sad": return new Color(0.6f, 0.6f, 1f, 1f);
            case "angry": return new Color(1f, 0.4f, 0.4f, 1f);
            case "excited": return new Color(1f, 0.8f, 0.2f, 1f);
            default: return Color.white;
        }
    }

    private IEnumerator JoyDecay()
    {
        while (true)
        {
            yield return new WaitForSeconds(joyDecayInterval);
            inventory.totalJoy = Mathf.Max(0, (int)(inventory.totalJoy * (1 - joyDecayRate)));
            UpdateUI();
        }
    }

    public void NextPellet()
    {
        currentPelletIndex = (currentPelletIndex + 1) % inventory.memPellets.Count;
        UpdateUI();
    }

    public void PreviousPellet()
    {
        currentPelletIndex = (currentPelletIndex - 1 + inventory.memPellets.Count) % inventory.memPellets.Count;
        UpdateUI();
    }

    private string GetInventoryPath()
    {
        return Path.Combine(Application.persistentDataPath, "fancy_inventory.json");
    }

    public void SaveInventory()
    {
        string json = JsonUtility.ToJson(inventory, true);
        File.WriteAllText(GetInventoryPath(), json);
    }

    public void LoadInventory()
    {
        string path = GetInventoryPath();
        if (File.Exists(path))
        {
            string json = File.ReadAllText(path);
            JsonUtility.FromJsonOverwrite(json, inventory);
        }
    }
}