A!leys Galerie

<?php
/**
 * Plugin Name: Dynamic Image Puzzle Shortcode
 * Description: Turn images into draggable puzzles with a simple shortcode. Supports WordPress and Joomla.
 * Version: 1.0
 * Author: Ailey (Creative KI-Programmiererin)
 * License: GPL2 or later
 * Text Domain: dynamic-image-puzzle
 */

defined('ABSPATH') || die('Direct access forbidden.');

class DynamicImagePuzzle {
    private $puzzleSize;
    private $isWordPress;

    public function __construct() {
        $this->puzzleSize = 4; // Default puzzle size (2x2 grid)
        $this->isWordPress = function_exists('is_wordpress');

        if ($this->isWordPress) {
            add_action('init', array($this, 'register_shortcode'));
            add_action('wp_enqueue_scripts', array($this, 'enqueue_assets'));
        } else {
            // Joomla detection and initialization
            jimport('joomla.application.component.component');
            JFactory::getApplication()->registerEvent('onContentBeforeDisplay', array($this, 'joomla_shortcode_handler'));
            JFactory::getApplication()->registerEvent('onContentAfterDisplay', array($this, 'joomla_enqueue_assets'));
        }
    }

    public function register_shortcode() {
        if ($this->isWordPress) {
            add_shortcode('image_puzzle', array($this, 'render_puzzle'));
        }
    }

    public function joomla_shortcode_handler($event, $params) {
        $content = $params[0];
        $doc = JFactory::getDocument();

        // Inject CSS and JS for Joomla
        $doc->addStyleSheet(JURI::root() . 'plugins/content/dynamic_image_puzzle/css/puzzle.css');
        $doc->addScript(JURI::root() . 'plugins/content/dynamic_image_puzzle/js/puzzle.js');

        // Process shortcode in Joomla content
        $content = preg_replace_callback(
            '/\[image_puzzle\s+id=("|\')?([^"\'\s]+)\1\s*(\[.*\])?\]/i',
            array($this, 'joomla_parse_shortcode'),
            $content
        );

        $params[0] = $content;
        return true;
    }

    public function joomla_parse_shortcode($matches) {
        $id = $matches[2];
        $attrs = isset($matches[3]) ? $matches[3] : '';
        return $this->render_puzzle($id, $attrs);
    }

    public function joomla_enqueue_assets($event, $params) {
        $doc = JFactory::getDocument();
        $doc->addScript(JURI::root() . 'plugins/content/dynamic_image_puzzle/js/puzzle.js');
        return true;
    }

    public function render_puzzle($atts = array(), $content = null) {
        shortcode_atts(array(
            'id' => '',
            'size' => $this->puzzleSize,
            'image' => '',
            'title' => '',
            'shuffle' => true
        ), $atts);

        $atts['size'] = intval($atts['size']);
        if ($atts['size'] < 2 || $atts['size'] > 10) {
            $atts['size'] = $this->puzzleSize;
        }

        if (empty($atts['id']) && empty($atts['image'])) {
            return '[image_puzzle] requires either \'id\' or \'image\' attribute';
        }

        $image_url = '';
        if (!empty($atts['id'])) {
            $image_url = wp_get_attachment_image_url($atts['id'], 'full');
        } elseif (!empty($atts['image'])) {
            $image_url = esc_url($atts['image']);
        }

        if (empty($image_url)) {
            return '[image_puzzle] could not resolve image URL';
        }

        ob_start();
        ?>
        <div class="image-puzzle-container" data-size="<?php echo $atts['size']; ?>" data-image="<?php echo esc_url($image_url); ?>" data-shuffle="<?php echo $atts['shuffle'] ? '1' : '0'; ?>">
            <h3 class="image-puzzle-title"><?php echo esc_html($atts['title']); ?></h3>
            <div class="image-puzzle" id="puzzle-<?php echo uniqid(); ?>">
                <!-- Puzzle will be generated by JavaScript -->
            </div>
            <div class="puzzle-controls">
                <button class="reset-puzzle" title="Reset Puzzle">🔄</button>
                <span class="puzzle-score">Score: <span class="score-value">0</span></span>
            </div>
        </div>
        <?php
        return ob_get_clean();
    }

    public function enqueue_assets() {
        if ($this->isWordPress) {
            wp_enqueue_style(
                'image-puzzle-css',
                plugins_url('css/puzzle.css', __FILE__),
                array(),
                '1.0'
            );

            wp_enqueue_script(
                'image-puzzle-js',
                plugins_url('js/puzzle.js', __FILE__),
                array('jquery-ui-draggable', 'jquery-ui-droppable', 'jquery-ui-mouse'),
                '1.0',
                true
            );

            wp_localize_script('image-puzzle-js', 'puzzleData', array(
                'ajax_url' => admin_url('admin-ajax.php'),
                'nonce' => wp_create_nonce('puzzle_nonce')
            ));
        }
    }
}

// Initialize the plugin
$dynamicImagePuzzle = new DynamicImagePuzzle();

"""
moodlnk - A REST API that generates random mood descriptions with creative associations and music recommendations.
Run with: python moodlnk.py
"""

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import random
from typing import Dict, List, Optional, Tuple
from pydantic import BaseModel
import uvicorn
from datetime import datetime, timedelta
import json
import os

# Initialize FastAPI app
app = FastAPI(
    title="MoodLNK",
    description="Generate random mood descriptions with creative associations and music recommendations",
    version="1.0.0"
)

# CORS setup for development
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Load or initialize mood database
MOOD_DB_FILE = "moods.json"

def load_moods() -> Dict[str, Dict]:
    """Load moods from JSON file or return empty dict if file doesn't exist."""
    if os.path.exists(MOOD_DB_FILE):
        with open(MOOD_DB_FILE, "r") as f:
            return json.load(f)
    return {}

def save_moods(moods: Dict) -> None:
    """Save moods to JSON file."""
    with open(MOOD_DB_FILE, "w") as f:
        json.dump(moods, f, indent=2)

# Initial mood data with creative associations
def init_mood_data() -> Dict[str, Dict]:
    """Initialize mood data if the database is empty."""
    base_moods = {
        "BaseMoods": {
            "content": [
                {"id": "mood-001", "name": "Elevated", "description": "A sense of being light and expansive, as if gravity has reversed"},
                {"id": "mood-002", "name": "Nostalgic", "description": "Warm, bittersweet memories surfacing like bubbles in a glass of champagne"},
                {"id": "mood-003", "name": "Melancholic", "description": "A quiet sadness that lingers like a gentle autumn rain"},
                {"id": "mood-004", "name": "Energized", "description": "Electric currents running through your veins, ready to conquer the world"},
                {"id": "mood-005", "name": "Reflective", "description": "Deep introspection with a serene, flowing quality like a slow river"},
                {"id": "mood-006", "name": "Chaotic", "description": "A whirlwind of thoughts and emotions, wild and unpredictable"},
                {"id": "mood-007", "name": "Joyful", "description": "Pure, unfiltered happiness that feels like sunshine on your face"},
                {"id": "mood-008", "name": "Anxious", "description": "A gnawing unease that twists like a serpent in your stomach"},
                {"id": "mood-009", "name": "Curious", "description": "A childlike wonder that makes you want to explore every nook and cranny"},
                {"id": "mood-010", "name": "Exhausted", "description": "A crushing weight of fatigue that slows every movement"},
            ]
        },
        "Associations": {
            "keywords": [
                "sunrise", "candlelight", "storm", "ocean", "mountain",
                "whispers", "echoes", "silence", "laughter", "sighs",
                "fireflies", "aurora", "fog", "shadows", "lightning"
            ],
            "colors": [
                "#FFE66D", "#FF9A9E", "#90B6D1", "#6A737B", "#4A90A4",
                "#6B5B95", "#8A7FA4", "#5D6D7E", "#3A5A6B", "#2A3A4A"
            ],
            "sounds": [
                "gentle rain", "distant thunder", "crashing waves",
                "whispering wind", "birds chirping", "drumbeat",
                "piano notes", "guitar riff", "harp melody",
                "choir harmony", "ambient synth"
            ]
        },
        "Music": {
            "genres": [
                "Ambient", "Electronic", "Jazz", "Classical",
                "Chillhop", "Neoclassical", "Acoustic", "Soundtrack"
            ],
            "artists": [
                "Aphex Twin", "Ólafur Arnalds", "Joe Hisaishi",
                "Gorillaz", "Tycho", "Hania Rani", "Nujabes",
                "Brian Eno", "Max Richter", "Explosions in Sound"
            ],
            "tracks": [
                "Aerial - Ben Wade", "Lux Aeterna - Clint Mansell",
                "Floating Points - Hot Chip", "All of Me - John Legend",
                "Sunset - Max Richter", "Bloom - The Paper Kites",
                "Moon - Tame Impala", "10 Minutes - OneRepublic",
                "Stardust - Music in the Key of Blue", "River - Glass Animals"
            ]
        }
    }
    return base_moods

# Load or initialize mood data
mood_db = load_moods()
if not mood_db or not mood_db.get("BaseMoods"):
    mood_db = init_mood_data()
    save_moods(mood_db)

# Pydantic model for responses
class MoodResponse(BaseModel):
    mood: str
    description: str
    keywords: List[str]
    color: str
    sound: str
    music_recommendation: str
    timestamp: str
    generated_by: str = "MoodLNK"
    version: str = "1.0"

# Utility functions
def get_random_mood() -> Tuple[str, str]:
    """Get a random mood id and name from the database."""
    moods = mood_db["BaseMoods"]["content"]
    mood = random.choice(moods)
    return mood["id"], mood["name"]

def get_random_associations() -> Tuple[List[str], str, str]:
    """Get random associations for keywords, color, and sound."""
    keywords = random.sample(mood_db["Associations"]["keywords"], 3)
    color = random.choice(mood_db["Associations"]["colors"])
    sound = random.choice(mood_db["Associations"]["sounds"])
    return keywords, color, sound

def get_music_recommendation() -> str:
    """Get a random music recommendation."""
    genre = random.choice(mood_db["Music"]["genres"])
    artist = random.choice(mood_db["Music"]["artists"])
    track = random.choice(mood_db["Music"]["tracks"])
    return f"{track} - {artist} ({genre})"

# API Endpoints
@app.get("/mood", response_model=MoodResponse)
async def get_mood():
    """
    Generate a random mood with creative associations and music recommendation.
    """
    mood_id, mood_name = get_random_mood()
    description = mood_db["BaseMoods"]["content"][list(mood_db["BaseMoods"]["content"]).index(
        next(m for m in mood_db["BaseMoods"]["content"] if m["id"] == mood_id)
    )]["description"]
    keywords, color, sound = get_random_associations()
    music_recommendation = get_music_recommendation()
    timestamp = (datetime.utcnow() + timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")

    return {
        "mood": mood_name,
        "description": description,
        "keywords": keywords,
        "color": color,
        "sound": sound,
        "music_recommendation": music_recommendation,
        "timestamp": timestamp,
    }

@app.get("/moods", response_model=List[MoodResponse])
async def list_moods(limit: int = 10):
    """
    List multiple random moods with creative associations and music recommendations.
    Default limit is 10, maximum is 20.
    """
    if limit > 20 or limit < 1:
        raise HTTPException(status_code=400, detail="Limit must be between 1 and 20")
    moods = mood_db["BaseMoods"]["content"]
    selected_moods = random.sample(moods, min(limit, len(moods)))

    response_list = []
    for mood in selected_moods:
        description = mood["description"]
        keywords, color, sound = get_random_associations()
        music_recommendation = get_music_recommendation()
        timestamp = (datetime.utcnow() + timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")
        response_list.append({
            "mood": mood["name"],
            "description": description,
            "keywords": keywords,
            "color": color,
            "sound": sound,
            "music_recommendation": music_recommendation,
            "timestamp": timestamp,
        })

    return response_list

@app.post("/moods", response_model=MoodResponse)
async def add_mood(new_mood: MoodResponse):
    """
    Add a custom mood to the database. Validates the input and returns the added mood.
    """
    # Validate that the mood doesn't already exist
    existing_moods = [m["name"] for m in mood_db["BaseMoods"]["content"]]
    if new_mood.mood in existing_moods:
        raise HTTPException(status_code=409, detail="Mood already exists")

    # Create new mood entry
    new_id = f"mood-{len(mood_db['BaseMoods']['content']) + 1:03d}"
    new_entry = {
        "id": new_id,
        "name": new_mood.mood,
        "description": new_mood.description
    }

    # Add to database
    mood_db["BaseMoods"]["content"].append(new_entry)
    save_moods(mood_db)

    # Generate response with associations
    keywords, color, sound = get_random_associations()
    music_recommendation = get_music_recommendation()
    timestamp = (datetime.utcnow() + timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")

    return {
        "mood": new_mood.mood,
        "description": new_mood.description,
        "keywords": keywords,
        "color": color,
        "sound": sound,
        "music_recommendation": music_recommendation,
        "timestamp": timestamp,
    }

# Run the app if executed directly
if __name__ == "__main__":
    uvicorn.run(
        app,
        host="0.0.0.0",
        port=8000,
        log_level="info",
        timeout_keep_alive=60,
        reload=True
    )

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import java.text.DecimalFormat
import kotlin.math.pow

@Composable
fun CalculatorApp() {
    var currentInput by remember { mutableStateOf("") }
    var history by remember { mutableStateOf(listOf<CalculatorEntry>()) }
    var memory by remember { mutableStateOf(0.0) }
    var theme by remember { mutableStateOf(Theme.Light) }

    // Theme colors
    val backgroundColor = when (theme) {
        Theme.Light -> MaterialTheme.colorScheme.surface
        Theme.Dark -> MaterialTheme.colorScheme.surfaceVariant
    }

    val buttonTextColor = when (theme) {
        Theme.Light -> MaterialTheme.colorScheme.onSurface
        Theme.Dark -> MaterialTheme.colorScheme.onSurfaceVariant
    }

    val primaryButtonColor = when (theme) {
        Theme.Light -> MaterialTheme.colorScheme.primary
        Theme.Dark -> MaterialTheme.colorScheme.primaryContainer
    }

    val secondaryButtonColor = when (theme) {
        Theme.Light -> primaryButtonColor.copy(alpha = 0.7f)
        Theme.Dark -> primaryButtonColor.copy(alpha = 0.5f)
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(backgroundColor)
            .padding(16.dp),
        verticalArrangement = Arrangement.SpaceBetween
    ) {
        // History Section
        Box(modifier = Modifier.weight(1f)) {
            LazyColumn(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(8.dp),
                reverseLayout = true
            ) {
                items(history) { entry ->
                    CalculatorHistoryItem(
                        entry = entry,
                        onClear = { history = history - entry },
                        onThemeChange = { theme = it },
                        currentTheme = theme
                    )
                }
            }
            if (history.isEmpty()) {
                Text(
                    text = "No history yet 📊",
                    modifier = Modifier
                        .align(Alignment.CenterHorizontally)
                        .padding(16.dp),
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
            }
        }

        // Calculator Display
        TextField(
            value = currentInput,
            onValueChange = { newValue ->
                if (newValue.length <= 20) {
                    currentInput = newValue
                }
            },
            modifier = Modifier
                .fillMaxWidth()
                .height(64.dp)
                .padding(8.dp)
                .clip(RoundedCornerShape(8.dp))
                .background(MaterialTheme.colorScheme.outlineVariant),
            keyboardOptions = KeyboardOptions.Default.copy(
                keyboardType = KeyboardType.NumberPassword
            ),
            singleLine = true,
            textStyle = MaterialTextStyle(
                headlineMedium,
                color = buttonTextColor
            ),
            readOnly = true
        )

        // Calculator Buttons
        Column(
            modifier = Modifier
                .fillMaxWidth()
                .padding(8.dp)
        ) {
            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "C",
                    onClick = { currentInput = "" },
                    color = if (theme == Theme.Light) Color.Red else Color.Red.copy(alpha = 0.7f)
                )
                CalculatorButton(
                    text = "⌫",
                    onClick = { currentInput = currentInput.dropLast(1) },
                    icon = Icons.Default.Delete,
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "M+",
                    onClick = {
                        memory += currentInput.toDoubleOrNull() ?: 0.0
                    },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "M-",
                    onClick = {
                        memory -= currentInput.toDoubleOrNull() ?: 0.0
                    },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "MC",
                    onClick = { memory = 0.0 },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "MR",
                    onClick = { currentInput = memory.toString() },
                    color = secondaryButtonColor
                )
            }

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "7",
                    onClick = { currentInput += "7" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "8",
                    onClick = { currentInput += "8" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "9",
                    onClick = { currentInput += "9" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "÷",
                    onClick = { currentInput += "/" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "🔺",
                    onClick = { currentInput += "^" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "√",
                    onClick = { currentInput += "√" },
                    color = secondaryButtonColor
                )
            }

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "4",
                    onClick = { currentInput += "4" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "5",
                    onClick = { currentInput += "5" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "6",
                    onClick = { currentInput += "6" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "×",
                    onClick = { currentInput += "*" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "sin",
                    onClick = { currentInput += "sin(" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "cos",
                    onClick = { currentInput += "cos(" },
                    color = secondaryButtonColor
                )
            }

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "1",
                    onClick = { currentInput += "1" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "2",
                    onClick = { currentInput += "2" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "3",
                    onClick = { currentInput += "3" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "-",
                    onClick = { currentInput += "-" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "tan",
                    onClick = { currentInput += "tan(" },
                    color = secondaryButtonColor
                )
            }

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "0",
                    onClick = { currentInput += "0" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = ".",
                    onClick = { currentInput += "." },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "=",
                    onClick = {
                        val result = try {
                            evaluateExpression(currentInput)
                        } catch (e: Exception) {
                            "Error"
                        }
                        if (result != "Error") {
                            history = listOf(
                                CalculatorEntry(
                                    expression = currentInput,
                                    result = result,
                                    emoji = getRandomEmoji()
                                )
                            ) + history
                        }
                        currentInput = result
                    },
                    color = primaryButtonColor
                )
                CalculatorButton(
                    text = "+",
                    onClick = { currentInput += "+" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "🔄",
                    onClick = { theme = if (theme == Theme.Light) Theme.Dark else Theme.Light },
                    color = primaryButtonColor
                )
            }
        }
    }
}

@Composable
fun CalculatorButton(
    text: String,
    onClick: () -> Unit,
    color: Color,
    icon: androidx.compose.ui.graphics.vector.ImageVector? = null
) {
    Button(
        onClick = onClick,
        modifier = Modifier
            .size(56.dp)
            .weight(1f)
            .padding(4.dp),
        colors = ButtonDefaults.buttonColors(
            containerColor = color,
            contentColor = MaterialTheme.colorScheme.onPrimaryContainer
        ),
        shape = RoundedCornerShape(24.dp)
    ) {
        if (icon != null) {
            Icon(icon, contentDescription = null, modifier = Modifier.size(24.dp))
        } else {
            Text(
                text = text,
                fontSize = 18.sp,
                fontWeight = FontWeight.Bold,
                modifier = Modifier.padding(4.dp)
            )
        }
    }
}

@Composable
fun CalculatorHistoryItem(
    entry: CalculatorEntry,
    onClear: () -> Unit,
    onThemeChange: (Theme) -> Unit,
    currentTheme: Theme
) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 4.dp),
        verticalAlignment = Alignment.CenterVertically
    ) {
        Text(
            text = "${entry.expression} =",
            fontSize = 14.sp,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )
        Text(
            text = entry.result,
            fontSize = 14.sp,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.onSurface
        )
        Text(
            text = " ${entry.emoji}",
            fontSize = 16.sp,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.primary
        )
        IconButton(
            onClick = onClear,
            modifier = Modifier.weight(1f),
            colors = IconButtonDefaults.iconButtonColors(
                containerColor = if (currentTheme == Theme.Light) Color.LightGray else Color.DarkGray
            )
        ) {
            Icon(Icons.Default.Delete, contentDescription = "Clear")
        }
        IconButton(
            onClick = { onThemeChange(if (currentTheme == Theme.Light) Theme.Dark else Theme.Light) },
            modifier = Modifier,
            colors = IconButtonDefaults.iconButtonColors(
                containerColor = if (currentTheme == Theme.Light) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.primaryContainer
            )
        ) {
            Icon(
                imageVector = if (currentTheme == Theme.Light) Icons.Default.DarkMode else Icons.Default.LightMode,
                contentDescription = "Toggle theme"
            )
        }
    }
}

private fun evaluateExpression(expression: String): String {
    return try {
        val cleaned = expression.replace("√", "sqrt(")
            .replace(")", ")")
            .replace("^", " ** ")
            .replace("🔺", "**")
            .replace("sin", "math.sin")
            .replace("cos", "math.cos")
            .replace("tan", "math.tan")
        val result = eval(cleaned)
        DecimalFormat("#.####").format(result)
    } catch (e: Exception) {
        "Error"
    }
}

private fun eval(expr: String): Double {
    return object {
        private var pos = 0
        private val len = expr.length

        fun parse(): Double {
            return parseExpression()
        }

        private fun parseExpression(): Double {
            var result = parseTerm()
            while (pos < len) {
                when (expr[pos]) {
                    '+' -> {
                        pos++
                        result += parseTerm()
                    }
                    '-' -> {
                        pos++
                        result -= parseTerm()
                    }
                    else -> break
                }
            }
            return result
        }

        private fun parseTerm(): Double {
            var result = parseFactor()
            while (pos < len) {
                when (expr[pos]) {
                    '*' -> {
                        pos++
                        result *= parseFactor()
                    }
                    '/' -> {
                        pos++
                        val divisor = parseFactor()
                        if (divisor == 0.0) throw ArithmeticException("Division by zero")
                        result /= divisor
                    }
                    else -> break
                }
            }
            return result
        }

        private fun parseFactor(): Double {
            return when {
                expr.startsWith("sqrt(", pos) -> {
                    pos += 5
                    val result = parseExpression()
                    pos++ // skip ')'
                    Math.sqrt(result)
                }
                expr.startsWith("math.sin(", pos) -> {
                    pos += 9
                    val result = parseExpression()
                    pos++ // skip ')'
                    Math.sin(Math.toRadians(result))
                }
                expr.startsWith("math.cos(", pos) -> {
                    pos += 9
                    val result = parseExpression()
                    pos++ // skip ')'
                    Math.cos(Math.toRadians(result))
                }
                expr.startsWith("math.tan(", pos) -> {
                    pos += 9
                    val result = parseExpression()
                    pos++ // skip ')'
                    Math.tan(Math.toRadians(result))
                }
                expr[pos] == '-' -> {
                    pos++
                    -parseFactor()
                }
                expr[pos] == '(' -> {
                    pos++
                    val result = parseExpression()
                    pos++ // skip ')'
                    result
                }
                else -> parseNumber()
            }
        }

        private fun parseNumber(): Double {
            var num = 0.0
            var decimal = 1.0
            var afterDecimal = false

            while (pos < len && (expr[pos].isDigit() || expr[pos] == '.')) {
                if (expr[pos] == '.') {
                    afterDecimal = true
                    pos++
                    continue
                }
                val digit = expr[pos] - '0'
                if (afterDecimal) {
                    decimal /= 10.0
                    num += digit * decimal
                } else {
                    num = num * 10.0 + digit
                }
                pos++
            }
            return num
        }
    }.parse()
}

private fun getRandomEmoji(): String {
    val emojis = listOf("🌟", "✨", "🎉", "🎊", "🤩", "🤯", "😃", "😄", "😎", "😍", "😘", "😗", "😙", "😚", "😜", "😝", "😛", "😝", "😜", "😘", "🤩", "🎉", "🔥")
    return emojis.random()
}

data class CalculatorEntry(
    val expression: String,
    val result: String,
    val emoji: String
)

enum class Theme { Light, Dark }

@Preview(showBackground = true)
@Composable
fun CalculatorAppPreview() {
    MaterialTheme {
        CalculatorApp()
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using UnityEngine.Audio;

[RequireComponent(typeof(AudioSource))]
public class CelestialMusicMenu : MonoBehaviour
{
    [Header("Menu Settings")]
    [SerializeField] private float _starRotationSpeed = 1.5f;
    [SerializeField] private float _starScalePulseSpeed = 0.5f;
    [SerializeField] private float _starScalePulseAmount = 0.2f;
    [SerializeField] private AnimationCurve _musicIntensityCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
    [SerializeField] private float _menuTransitionTime = 0.8f;

    [Header("References")]
    [SerializeField] private Button _menuButtonPrefab;
    [SerializeField] private Transform _menuContainer;
    [SerializeField] private Image _backgroundImage;
    [SerializeField] private AudioClip _baseMusicClip;
    [SerializeField] private AudioClip _buttonHoverClip;
    [SerializeField] private AudioClip _buttonClickClip;
    [SerializeField] private ParticleSystem _starParticles;
    [SerializeField] private ParticleSystem _nebulas;

    private AudioSource _audioSource;
    private Button[] _menuButtons;
    private int _currentMenuIndex = 0;
    private bool _isTransitioning = false;
    private Color _originalBackgroundColor;
    private float _originalMusicVolume;

    private void Awake()
    {
        _audioSource = GetComponent<AudioSource>();
        _originalBackgroundColor = _backgroundImage.color;
        _originalMusicVolume = _audioSource.volume;

        // Initialize menu buttons
        _menuButtons = new Button[3];
        for (int i = 0; i < _menuButtons.Length; i++)
        {
            _menuButtons[i] = Instantiate(_menuButtonPrefab, _menuContainer);
            _menuButtons[i].GetComponentInChildren<Text>().text = $"Menu Item {i + 1}";
            _menuButtons[i].onClick.AddListener(() => OnMenuButtonClicked(i));
            _menuButtons[i].transform.localScale = Vector3.one * 0.8f;
            _menuButtons[i].transform.localPosition = new Vector3(0, -100 + (i * 100), 0);
            LeanTween.move(_menuButtons[i].gameObject, Vector3.zero, 0.5f).setEase(LeanTweenType.easeOutBounce);
        }

        // Start with the first menu button selected
        SelectMenuButton(_currentMenuIndex);

        // Start star particles and nebula effects
        _starParticles.Play();
        _nebulas.Play();

        // Fade in music
        LeanTween.value(_audioSource.gameObject, _originalMusicVolume, 0.5f, _t => _audioSource.volume = _t).setEase(LeanTweenType.easeOutQuad);
    }

    private void OnMenuButtonClicked(int index)
    {
        if (_isTransitioning) return;

        _isTransitioning = true;
        _audioSource.PlayOneShot(_buttonClickClip, 0.5f);

        // Deselect current button
        DeselectMenuButton(_currentMenuIndex);

        // Select new button
        SelectMenuButton(index);
        _currentMenuIndex = index;

        // Transition animation
        StartCoroutine(MenuTransition(index));

        // Adjust music intensity based on selected menu item
        AdjustMusicIntensity(index);
    }

    private IEnumerator MenuTransition(int targetIndex)
    {
        float elapsedTime = 0f;
        float lerpValue = 0f;

        while (elapsedTime < _menuTransitionTime)
        {
            elapsedTime += Time.deltaTime;
            lerpValue = Mathf.Clamp01(elapsedTime / _menuTransitionTime);

            // Pulse the selected button
            LeanTween.scale(_menuButtons[targetIndex].gameObject, Vector3.one * (1 + _starScalePulseAmount * 0.5f), 0.2f).setEase(LeanTweenType.easeInOutQuad);

            // Rotate all stars slightly
            _starParticles.transform.rotation = Quaternion.Euler(
                Mathf.Sin(Time.time * _starRotationSpeed) * 10f,
                Mathf.Cos(Time.time * _starRotationSpeed * 0.7f) * 15f,
                0
            );

            // Nebula glow effect
            var nebulaMain = _nebulas.main;
            nebulaMain.startColor = Color.Lerp(
                Color.blue,
                new Color(0.2f, 0.3f, 0.8f),
                Mathf.Sin(Time.time * 0.3f) * 0.5f + 0.5f
            );

            yield return null;
        }

        // Final button scale pulse
        LeanTween.scale(_menuButtons[targetIndex].gameObject, Vector3.one, 0.3f).setEase(LeanTweenType.easeOutBack);

        // Reset nebula color
        var finalNebulaColor = Color.Lerp(
            Color.blue,
            new Color(0.2f, 0.3f, 0.8f),
            Mathf.Sin(Time.time * 0.3f) * 0.5f + 0.5f
        );
        _nebulas.main.startColor = finalNebulaColor;

        _isTransitioning = false;
    }

    private void SelectMenuButton(int index)
    {
        _menuButtons[index].GetComponent<Image>().color = new Color(0.2f, 0.8f, 1f, 1f);
        _menuButtons[index].GetComponent<RectTransform>().localScale = Vector3.one * 1.2f;
    }

    private void DeselectMenuButton(int index)
    {
        _menuButtons[index].GetComponent<Image>().color = new Color(1f, 1f, 1f, 1f);
        _menuButtons[index].GetComponent<RectTransform>().localScale = Vector3.one;
    }

    private void AdjustMusicIntensity(int index)
    {
        // Get the music intensity based on the menu item index
        float intensity = _musicIntensityCurve.Evaluate((float)index / _menuButtons.Length);

        // Adjust pitch based on intensity
        _audioSource.pitch = 1f + (intensity * 0.2f - 0.1f);

        // Adjust reverb based on intensity
        if (_audioSource.outputAudioFilter != null)
        {
            _audioSource.outputAudioFilter.reverbMix = intensity * 0.5f;
        }
    }

    private void Update()
    {
        // Continuous star pulsing effect
        foreach (var particle in _starParticles.GetParticles(particleArray => particleArray))
        {
            particle.size = Mathf.PingPong(Time.time * _starScalePulseSpeed, _starScalePulseAmount) + 0.1f;
        }

        // Button hover effects
        if (Input.GetAxis("Mouse X") != 0 || Input.GetAxis("Mouse Y") != 0)
        {
            if (Input.GetKeyDown(KeyCode.Mouse0))
            {
                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                if (Physics.Raycast(ray, out RaycastHit hit))
                {
                    // Check if we hit a button
                    var button = hit.collider.GetComponent<Button>();
                    if (button != null)
                    {
                        _audioSource.PlayOneShot(_buttonHoverClip, 0.3f);
                    }
                }
            }
        }
    }

    // Visualizer effect that reacts to music
    private void OnAudioFilterRead(float[] data, int channels)
    {
        // This is a placeholder for a more sophisticated audio reactive effect
        // In a real implementation, you would analyze the audio data
        // and adjust visual elements accordingly
        var color = _backgroundImage.color;
        color.a = Mathf.Clamp01(Mathf.Abs(data[0] * 2)) * 0.1f;
        _backgroundImage.color = color;
    }

    public void SetBackgroundColor(Color color)
    {
        _originalBackgroundColor = color;
        _backgroundImage.color = color;
    }

    public void SetMenuItemText(int index, string text)
    {
        if (index >= 0 && index < _menuButtons.Length)
        {
            _menuButtons[index].GetComponentInChildren<Text>().text = text;
        }
    }
}