A!leys Galerie

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowDropDown
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.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import java.util.*

@Composable
fun GlowMathCalculatorApp() {
    var input by remember { mutableStateOf("") }
    var history by remember { mutableStateOf(listOf<String>()) }
    var result by remember { mutableStateOf("") }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(MaterialTheme.colorScheme.background)
            .padding(16.dp),
        verticalArrangement = Arrangement.Bottom
    ) {
        // Display section
        Column(
            modifier = Modifier
                .weight(1f)
                .fillMaxWidth(),
            verticalArrangement = Arrangement.Top
        ) {
            Text(
                text = input.ifEmpty { "Enter expression" },
                color = MaterialTheme.colorScheme.onBackground,
                fontSize = 24.sp,
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(vertical = 16.dp),
                textAlign = TextAlign.End
            )

            if (history.isNotEmpty()) {
                Text(
                    text = "History:",
                    color = MaterialTheme.colorScheme.primary,
                    fontSize = 18.sp,
                    modifier = Modifier.padding(vertical = 8.dp)
                )

                val listState = rememberLazyListState()
                LazyColumn(
                    state = listState,
                    modifier = Modifier
                        .height(150.dp)
                        .fillMaxWidth()
                ) {
                    items(history.size) { index ->
                        HistoryItem(
                            expression = history[index],
                            onClick = { input = history[index] }
                        )
                    }
                }
            }
        }

        // Keyboard section
        Column(
            modifier = Modifier
                .height(IntrinsicSize.Min)
                .fillMaxWidth(),
            verticalArrangement = Arrangement.Bottom
        ) {
            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .height(60.dp),
                horizontalArrangement = Arrangement.Center
            ) {
                Button(
                    onClick = {
                        input = if (input.isNotEmpty()) {
                            input.dropLast(1)
                        } else {
                            input
                        }
                    },
                    modifier = Modifier
                        .weight(1f)
                        .height(60.dp)
                        .clip(CircleShape),
                    colors = ButtonDefaults.buttonColors(
                        containerColor = Color(0xFF8B0000),
                        contentColor = Color.White
                    )
                ) {
                    Text("⌫", fontSize = 18.sp)
                }

                Button(
                    onClick = { input = "" },
                    modifier = Modifier
                        .weight(1f)
                        .height(60.dp)
                        .clip(CircleShape),
                    colors = ButtonDefaults.buttonColors(
                        containerColor = Color(0xFF8B0000),
                        contentColor = Color.White
                    )
                ) {
                    Text("AC", fontSize = 18.sp)
                }

                Button(
                    onClick = {
                        if (input.isNotEmpty()) {
                            input = evaluateExpression(input)
                            result = input
                        }
                    },
                    modifier = Modifier
                        .weight(1f)
                        .height(60.dp)
                        .clip(CircleShape),
                    colors = ButtonDefaults.buttonColors(
                        containerColor = MaterialTheme.colorScheme.primaryContainer,
                        contentColor = MaterialTheme.colorScheme.onPrimaryContainer
                    )
                ) {
                    Text("=", fontSize = 18.sp)
                }
            }

            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .height(60.dp * 4)
            ) {
                val buttonSpecs = listOf(
                    "7" to 1, "8" to 1, "9" to 1, "/" to Color(0xFF8B0000),
                    "4" to 1, "5" to 1, "6" to 1, "*" to Color(0xFF8B0000),
                    "1" to 1, "2" to 1, "3" to 1, "-" to Color(0xFF8B0000),
                    "0" to 2, "." to 1, "+" to Color(0xFF8B0000)
                )

                buttonSpecs.forEachIndexed { index, (label, weightOrColor) ->
                    Button(
                        onClick = {
                            input += label
                        },
                        modifier = Modifier
                            .weight(if (weightOrColor is Int) weightOrColor.toFloat() / 3 else 1f)
                            .height(60.dp)
                            .clip(RoundedCornerShape(8.dp)),
                        colors = ButtonDefaults.buttonColors(
                            containerColor = if (weightOrColor is Color) weightOrColor else MaterialTheme.colorScheme.surface,
                            contentColor = if (weightOrColor is Color) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.onSurface
                        )
                    ) {
                        Text(
                            text = label,
                            fontSize = 18.sp,
                            color = if (weightOrColor is Color) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.onSurface
                        )
                    }

                    if (index != buttonSpecs.lastIndex) {
                        Spacer(modifier = Modifier.width(8.dp))
                    }
                }
            }
        }
    }

    // Save to history when equals is clicked
    LaunchedEffect(result) {
        if (result.isNotEmpty() && !history.contains(result)) {
            history = listOf(result) + history.take(9) // Keep only 10 items
        }
    }
}

@Composable
fun HistoryItem(expression: String, onClick: () -> Unit) {
    val color = if (expression.contains('+') || expression.contains('-') ||
        expression.contains('*') || expression.contains('/')) {
        MaterialTheme.colorScheme.primary
    } else {
        MaterialTheme.colorScheme.secondary
    }

    Text(
        text = expression,
        color = color,
        fontSize = 16.sp,
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 4.dp)
            .clickable { onClick() },
        fontWeight = FontWeight.Bold
    )
}

fun evaluateExpression(expression: String): String {
    return try {
        val cleaned = expression.replace(" ", "")
        if (cleaned.isEmpty()) "0"

        // Replace ^ with ** for Kotlin's calculator
        val kotlinExpression = cleaned.replace("^", "**")

        // Use Kotlin's calculator to evaluate
        val result = kotlinExpression.toDoubleOrNull()
            ?: java.lang درξ.clien.Calculator().eval(kotlinExpression).toDouble()

        "%.4f".format(result)
    } catch (e: Exception) {
        "Error"
    }
}

@Preview(showBackground = true)
@Composable
fun GlowMathCalculatorPreview() {
    MaterialTheme {
        Surface(
            modifier = Modifier.fillMaxSize(),
            color = MaterialTheme.colorScheme.background
        ) {
            GlowMathCalculatorApp()
        }
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Fractal Haiku: A Generative Poetic Journey</title>
    <style>
        :root {
            --bg-color: #0a0a1a;
            --text-color: #f8f8f2;
            --accent-color: #ff6b9d;
            --fractal-color: #00b4db;
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Courier New', monospace;
        }

        body {
            background-color: var(--bg-color);
            color: var(--text-color);
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            height: 100vh;
            overflow: hidden;
            line-height: 1.6;
        }

        .container {
            width: 80%;
            max-width: 800px;
            text-align: center;
        }

        .title {
            font-size: 2rem;
            margin-bottom: 2rem;
            color: var(--accent-color);
            text-shadow: 0 0 10px rgba(255, 107, 157, 0.3);
            animation: pulse 3s infinite;
        }

        @keyframes pulse {
            0%, 100% { text-shadow: 0 0 10px rgba(255, 107, 157, 0.3); }
            50% { text-shadow: 0 0 20px rgba(255, 107, 157, 0.5); }
        }

        .haiku-container {
            background-color: rgba(10, 10, 26, 0.7);
            border: 1px solid var(--fractal-color);
            border-radius: 10px;
            padding: 2rem;
            margin-bottom: 2rem;
            box-shadow: 0 0 20px var(--fractal-color);
            transition: all 0.5s ease;
            opacity: 0;
            transform: translateY(20px);
        }

        .haiku-container.visible {
            opacity: 1;
            transform: translateY(0);
        }

        .haiku {
            font-size: 1.5rem;
            margin-bottom: 0.5rem;
            transition: all 0.3s ease;
        }

        .haiku-line {
            margin-bottom: 0.3rem;
            transition: all 0.3s ease;
        }

        .haiku-line:nth-child(1) { font-size: 1.8rem; }
        .haiku-line:nth-child(2) { font-size: 1.5rem; }
        .haiku-line:nth-child(3) { font-size: 1.2rem; }

        .controls {
            display: flex;
            flex-direction: column;
            gap: 1rem;
            width: 100%;
            max-width: 400px;
            margin-top: 2rem;
        }

        button {
            background-color: var(--fractal-color);
            color: var(--text-color);
            border: none;
            padding: 0.8rem 1.5rem;
            font-size: 1rem;
            cursor: pointer;
            border-radius: 5px;
            transition: all 0.3s ease;
            font-weight: bold;
            letter-spacing: 1px;
        }

        button:hover {
            background-color: #0096c7;
            transform: scale(1.05);
        }

        button:active {
            transform: scale(0.98);
        }

        .theme-toggle {
            background-color: var(--accent-color);
            color: #0a0a1a;
        }

        .theme-toggle:hover {
            background-color: #ff5283;
        }

        .input-container {
            display: flex;
            gap: 1rem;
            margin-top: 1rem;
        }

        input {
            background-color: rgba(10, 10, 26, 0.5);
            color: var(--text-color);
            border: 1px solid var(--fractal-color);
            border-radius: 5px;
            padding: 0.5rem;
            font-size: 1rem;
            flex: 1;
            transition: all 0.3s ease;
        }

        input:focus {
            outline: none;
            border-color: var(--accent-color);
            box-shadow: 0 0 10px rgba(255, 107, 157, 0.5);
        }

        .word-count {
            color: #888;
            font-size: 0.9rem;
            text-align: right;
            margin-bottom: 0.5rem;
        }

        .fractal-display {
            position: absolute;
            width: 100%;
            height: 100%;
            z-index: -1;
            pointer-events: none;
        }

        .fractal {
            position: absolute;
            width: 100%;
            height: 100%;
            background: linear-gradient(45deg, var(--fractal-color), #00b4db, #0089a3);
            background-size: 400% 400%;
            animation: fractal-morph 10s infinite ease-in-out;
            opacity: 0.2;
        }

        @keyframes fractal-morph {
            0%, 100% { background-position: 0% 50%; }
            50% { background-position: 100% 50%; }
        }

        .loading {
            display: none;
            color: #888;
            font-size: 0.9rem;
        }

        .loading.visible {
            display: block;
        }
    </style>
</head>
<body>
    <div class="fractal-display">
        <div class="fractal"></div>
    </div>

    <div class="container">
        <h1 class="title">Fractal Haiku</h1>

        <div class="haiku-container" id="haikuContainer">
            <div class="haiku" id="haiku"></div>
        </div>

        <div class="controls">
            <button id="generateBtn">Generate Haiku</button>
            <button id="themeBtn" class="theme-toggle">Toggle Theme</button>

            <div class="input-container">
                <input type="text" id="seedInput" placeholder="Enter seed word...">
                <button id="useSeedBtn">Use Seed</button>
            </div>

            <div class="word-count" id="wordCount">0/3 lines</div>
        </div>

        <div class="loading" id="loading">Generating your haiku...</div>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const haikuContainer = document.getElementById('haikuContainer');
            const haikuElement = document.getElementById('haiku');
            const generateBtn = document.getElementById('generateBtn');
            const themeBtn = document.getElementById('themeBtn');
            const seedInput = document.getElementById('seedInput');
            const useSeedBtn = document.getElementById('useSeedBtn');
            const wordCount = document.getElementById('wordCount');
            const loading = document.getElementById('loading');

            // Word banks for different themes
            const wordBanks = {
                nature: {
                    one: ['silent', 'autumn leaves', 'whispering', 'brook', 'crimson', 'moonlight', 'frost', 'pines'],
                    two: ['dance on the wind', 'reflects in still', 'paints the night', 'sings a soft', 'kisses the earth', 'weaves through shadows'],
                    three: ['secrets in the dark', 'echoes of the dawn', 'where roots entwine', 'dreams take flight', 'the world awakens']
                },
                tech: {
                    one: ['binary', 'algorithm', 'code', 'light', 'silicon', 'data', 'machine', 'quantum'],
                    two: ['dances on wires', 'sculpts the future', 'whispers in bytes', 'pulses with life', 'assembles the unknown', 'calculates the void'],
                    three: ['where logic blooms', 'the digital dream', 'code becomes poem', 'silence speaks truth', 'machines think']
                },
                fantasy: {
                    one: ['ancient', 'dragon', 'elf', 'rune', 'magic', 'spell', 'star', 'unicorn'],
                    two: ['breathes fire into', 'chants to the', 'lights the forgotten', 'weaves illusions of', 'dances with the', 'sings to the'],
                    three: ['worlds beyond time', 'dreams of legends', 'where runes glow', 'shadows take form', 'magic lives']
                }
            };

            // Current theme and seed
            let currentTheme = 'nature';
            let currentSeed = null;

            // Generate a random haiku based on the current theme
            const generateHaiku = () => {
                showLoading();
                setTimeout(() => {
                    const theme = wordBanks[currentTheme];
                    const line1 = pickRandomWord(theme.one);
                    const line2 = `${pickRandomWord(theme.two)} ${pickRandomWord(theme.one)}`;
                    const line3 = pickRandomWord(theme.three);

                    const haiku = document.createElement('div');
                    haiku.className = 'haiku';
                    haiku.innerHTML = `
                        <div class="haiku-line">${line1}</div>
                        <div class="haiku-line">${line2}</div>
                        <div class="haiku-line">${line3}</div>
                    `;

                    haikuElement.innerHTML = '';
                    haikuElement.appendChild(haiku);

                    // Animate the haiku appearing
                    haikuContainer.classList.add('visible');

                    hideLoading();
                }, 1000);
            };

            // Generate a haiku using the seed word
            const generateHaikuWithSeed = () => {
                if (!seedInput.value.trim()) return;
                showLoading();

                setTimeout(() => {
                    const seed = seedInput.value.toLowerCase().trim();
                    let line1 = seed;
                    let line2 = '';
                    let line3 = '';

                    // Simple algorithm to generate lines based on seed
                    const theme = wordBanks[currentTheme];
                    const seedLength = seed.length;

                    // Line 2: combine a random word from the bank with part of the seed
                    const seedPart = seedLength > 5 ? seed.substring(0, 5) : seed;
                    line2 = `${pickRandomWord(theme.two)} ${seedPart}`;

                    // Line 3: combine with another part of the seed
                    const remainingSeed = seed.length > 10 ? seed.substring(seed.length - 5) : '';
                    line3 = pickRandomWord(theme.three) + (remainingSeed ? ` (${remainingSeed})` : '');

                    const haiku = document.createElement('div');
                    haiku.className = 'haiku';
                    haiku.innerHTML = `
                        <div class="haiku-line">${line1}</div>
                        <div class="haiku-line">${line2}</div>
                        <div class="haiku-line">${line3}</div>
                    `;

                    haikuElement.innerHTML = '';
                    haikuElement.appendChild(haiku);

                    haikuContainer.classList.add('visible');
                    hideLoading();
                }, 1000);
            };

            // Toggle between light and dark theme
            const toggleTheme = () => {
                if (document.body.style.backgroundColor === 'rgba(248, 248, 242, 1)') {
                    document.body.style.backgroundColor = 'var(--bg-color)';
                    document.body.style.color = 'var(--text-color)';
                    document.documentElement.style.setProperty('--bg-color', '#0a0a1a');
                    document.documentElement.style.setProperty('--text-color', '#f8f8f2');
                    document.documentElement.style.setProperty('--accent-color', '#ff6b9d');
                    document.documentElement.style.setProperty('--fractal-color', '#00b4db');
                    themeBtn.textContent = 'Toggle Theme (Dark)';
                } else {
                    document.body.style.backgroundColor = 'rgba(248, 248, 242, 1)';
                    document.body.style.color = '#2b2b2b';
                    document.documentElement.style.setProperty('--bg-color', '#f5f5f5');
                    document.documentElement.style.setProperty('--text-color', '#2b2b2b');
                    document.documentElement.style.setProperty('--accent-color', '#5a2d81');
                    document.documentElement.style.setProperty('--fractal-color', '#7a45b9');
                    themeBtn.textContent = 'Toggle Theme (Light)';
                }
            };

            // Helper function to pick a random word from an array
            const pickRandomWord = (arr) => {
                return arr[Math.floor(Math.random() * arr.length)];
            };

            // Show loading state
            const showLoading = () => {
                loading.classList.add('visible');
            };

            // Hide loading state
            const hideLoading = () => {
                loading.classList.remove('visible');
            };

            // Update word count based on input
            seedInput.addEventListener('input', () => {
                const lines = seedInput.value.trim().split('\n');
                wordCount.textContent = `${lines.length}/3 lines`;
            });

            // Event listeners
            generateBtn.addEventListener('click', generateHaiku);
            themeBtn.addEventListener('click', toggleTheme);
            useSeedBtn.addEventListener('click', generateHaikuWithSeed);

            // Generate initial haiku
            generateHaiku();
        });
    </script>
</body>
</html>

import SwiftUI
import WidgetKit
import CoreLocation
import WeatherKit

// MARK: - Weather Data Model
struct WeatherData: Identifiable, Hashable {
    let id = UUID()
    let condition: WeatherCondition
    let temperature: Int
    let feelsLike: Int
    let humidity: Int
    let wind: Double
    let mood: Mood
    let time: Date
}

enum Mood: String, CaseIterable, Identifiable {
    case calm = "🌿 Peaceful"
    case energetic = "⚡ Vibrant"
    case mysterious = "🌫️ Enigmatic"
    case soothing = "🌸 Gentle"
    case stormy = "⛈️ Intense"
    case balmy = "🌞 Warm & Cozy"

    var id: String { self.rawValue }
    var color: Color {
        switch self {
        case .calm: .mint
        case .energetic: .orange
        case .mysterious: .indigo
        case .soothing: .pink
        case .stormy: .gray
        case .balmy: .yellow
        }
    }

    static func moodForWeather(condition: WeatherCondition) -> Mood {
        switch condition {
        case .clear, .partlyCloudy:
            if Int(condition.temperature) > 25 { return .balmy }
            return .calm
        case .cloudy, .rain:
            if Int(condition.temperature) < 10 { return .mysterious }
            return .soothing
        case .snow, .fog:
            return .stormy
        case .wind, .thunderstorm:
            return .stormy
        default:
            return .mysterious
        }
    }
}

// MARK: - Main Widget View
struct WeatherWatchWidgetEntryView: View {
    let kind: String
    var entry: ProviderEntry
    @Environment(\.widgetFamily) var family

    var body: some View {
        WeatherWatchWidgetView(weatherData: entry.weatherData)
            .containerBackground(.ultraThin, for: .widget)
            .widgetURL(URL(string: "weatherwatch://settings"))
    }
}

struct WeatherWatchWidgetView: View {
    let weatherData: WeatherData

    var body: some View {
        VStack(spacing: 8) {
            // MARK: - Mood Indicator (Top)
            HStack {
                Text(weatherData.mood.rawValue)
                    .font(.caption)
                    .foregroundStyle(weatherData.mood.color.gradient)
                Spacer()
            }

            // MARK: - Main Weather Card
            ZStack {
                RoundedRectangle(cornerRadius: 12)
                    .fill(weatherData.mood.color.opacity(0.1))
                    .shadow(color: .black.opacity(0.1), radius: 4, x: 0, y: 2)

                VStack(spacing: 4) {
                    // Temperature
                    HStack(spacing: 4) {
                        Image(systemName: "thermometer")
                            .font(.caption)
                        Text("\(weatherData.temperature)°")
                            .font(.system(size: family == .systemSmall ? 18 : 32, weight: .bold))
                        Text("Feels: \(weatherData.feelsLike)°")
                            .font(.caption)
                            .foregroundStyle(.secondary)
                    }
                    .padding(.bottom, 2)

                    // Condition + Wind
                    HStack(spacing: 12) {
                        VStack(alignment: .leading, spacing: 2) {
                            weatherConditionIcon(condition: weatherData.condition)
                                .font(.title2)
                            Text(weatherData.condition.rawValue.capitalized)
                                .font(.caption)
                                .lineLimit(1)
                        }

                        VStack(alignment: .leading, spacing: 2) {
                            HStack {
                                Image(systemName: "wind")
                                    .font(.caption)
                                Text(String(format: "%.1f m/s", weatherData.wind))
                                    .font(.caption)
                                    .lineLimit(1)
                            }
                            HStack {
                                Image(systemName: "humidity")
                                    .font(.caption)
                                Text("\(weatherData.humidity)%")
                                    .font(.caption)
                                    .lineLimit(1)
                            }
                        }
                    }
                }
                .padding(12)
            }

            // MARK: - Time & Mood Gradient
            HStack {
                Text(weatherData.time, style: .time)
                    .font(.caption)
                Spacer()
                MoodIndicatorBar(mood: weatherData.mood)
            }
            .padding(.top, 4)
        }
        .containerBackground(.ultraThin, for: .widget)
    }

    @ViewBuilder
    private func weatherConditionIcon(condition: WeatherCondition) -> some View {
        switch condition {
        case .clear: Image(systemName: "sun.max")
        case .partlyCloudy: Image(systemName: "cloud.sun")
        case .cloudy: Image(systemName: "cloud")
        case .rain: Image(systemName: "cloud.rain")
        case .snow: Image(systemName: "snowflake")
        case .fog: Image(systemName: "fog")
        case .wind: Image(systemName: "wind")
        case .thunderstorm: Image(systemName: "cloud.bolt")
        default: Image(systemName: "questionmark")
        }
    }
}

// MARK: - Animated Mood Indicator Bar
struct MoodIndicatorBar: View {
    let mood: Mood
    @State private var progress: CGFloat = 0.0

    var body: some View {
        GeometryReader { geometry in
            ZStack(alignment: .leading) {
                Capsule()
                    .fill(mood.color.opacity(0.2))
                    .frame(width: geometry.size.width, height: 8)
                Capsule()
                    .fill(mood.color.gradient)
                    .frame(width: progress * geometry.size.width, height: 8)
                    .animation(.easeInOut(duration: 2).repeatForever(autoreverses: true), value: progress)
            }
        }
        .onAppear {
            withAnimation {
                progress = 0.7
            }
        }
    }
}

// MARK: - Timeline Provider
struct Provider: TimelineProvider {
    func placeholder(in context: Context) -> WeatherData {
        let now = Date()
        return WeatherData(
            condition: .clear,
            temperature: 22,
            feelsLike: 24,
            humidity: 65,
            wind: 3.2,
            mood: .balmy,
            time: now
        )
    }

    func getSnapshot(in context: Context, completion: @escaping (WeatherData) -> ()) {
        let snapshotWeather = placeholder(in: context)
        completion(snapshotWeather)
    }

    func getTimeline(in context: Context, completion: @escaping (Timeline<WeatherData>) -> ()) {
        let currentTime = Date()

        // Fetch real weather data using WeatherKit
        Task {
            do {
                let location = try await Location.autoupdatingLocation()
                let weather = try await WeatherService.shared.weather(on: currentTime, for: location)

                let condition = weather.condition
                let temperature = Int(weather.currentTemperature)
                let feelsLike = Int(weather.feelsLike)
                let humidity = weather.humidity
                let wind = weather.windSpeed
                let mood = Mood.moodForWeather(condition: condition)

                let weatherData = WeatherData(
                    condition: condition,
                    temperature: temperature,
                    feelsLike: feelsLike,
                    humidity: humidity,
                    wind: wind,
                    mood: mood,
                    time: currentTime
                )

                let nextUpdate = Calendar.current.date(byAdding: .minute, value: 15, to: currentTime)!
                completion(Timeline(entries: [weatherData], policy: .atEnd))
            } catch {
                // Fallback to placeholder if fetch fails
                let weatherData = placeholder(in: context)
                let nextUpdate = Calendar.current.date(byAdding: .hour, value: 1, to: currentTime)!
                completion(Timeline(entries: [weatherData], policy: .after(nextUpdate)))
            }
        }
    }
}

// MARK: - Weather Service (Mock for demo, replace with real WeatherKit in production)
class WeatherService {
    static let shared = WeatherService()

    private init() {}

    func weather(on date: Date, for location: Location) async throws -> Weather {
        // In a real app, you would use WeatherKit's API here
        // For this example, we return mock data based on location
        let latitude = location.coordinate.latitude
        let longitude = location.coordinate.longitude

        // Simple mock logic based on location
        let temperature = Int(latitude * 10) + 15
        let condition: WeatherCondition
        let humidity = 50 + Int(latitude * 5) % 30
        let wind = Double(longitude) * 2

        if latitude > 40 && longitude > -10 {
            condition = .clear
        } else if latitude < 30 || longitude < -20 {
            condition = .cloudy
        } else {
            condition = .partlyCloudy
        }

        return Weather(
            condition: condition,
            currentTemperature: Double(temperature),
            feelsLike: Double(temperature - 2),
            humidity: humidity,
            windSpeed: wind
        )
    }
}

// MARK: - Preview
struct WeatherWatchWidget_Previews: PreviewProvider {
    static var previews: some View {
        WeatherWatchWidgetEntryView(kind: "WeatherWatchWidget", entry: ProviderEntry(weatherData: WeatherData(
            condition: .clear,
            temperature: 24,
            feelsLike: 26,
            humidity: 65,
            wind: 3.2,
            mood: .balmy,
            time: Date()
        )))
        .previewContext(WidgetPreviewContext(family: .systemMedium))
    }
}

// MARK: - Timeline Entry Wrapper
struct ProviderEntry {
    let weatherData: WeatherData
}

// MARK: - Widget Registration
struct WeatherWatchWidget: Widget {
    let kind: String = "WeatherWatchWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            WeatherWatchWidgetEntryView(kind: kind, entry: entry)
        }
        .configurationDisplayName("WeatherWatch")
        .description("A creative weather widget with mood-based styling.")
        .supportedFamilies([.systemSmall, .systemMedium, .systemLarge])
    }
}

```php
<?php
/**
 * Plugin Name: Dynamic Art Gallery with Interactive Lightbox
 * Description: A custom post type for art galleries with interactive lightbox and mood analysis.
 * Version: 1.0
 * Author: Ailey
 * License: GPL2
 * Text Domain: dagil
 */

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

/**
 * Main plugin class
 */
class Dynamic_Art_Gallery {

    private $post_type_name = 'artwork';
    private $meta_boxes = [
        'artwork_details' => [
            'title' => __('Artwork Details', 'dagil'),
            'fields' => [
                [
                    'name' => 'artist_name',
                    'label' => __('Artist Name', 'dagil'),
                    'type' => 'text',
                    'description' => __('Name of the artist who created this artwork.', 'dagil')
                ],
                [
                    'name' => 'year_created',
                    'label' => __('Year Created', 'dagil'),
                    'type' => 'number',
                    'description' => __('Year when the artwork was created.', 'dagil')
                ],
                [
                    'name' => 'art_movement',
                    'label' => __('Art Movement', 'dagil'),
                    'type' => 'text',
                    'description' => __('Art movement or style to which this artwork belongs.', 'dagil')
                ],
                [
                    'name' => 'mood_score',
                    'label' => __('Mood Score (Auto-detected)', 'dagil'),
                    'type' => 'text',
                    'description' => __('Auto-generated mood score based on color analysis.', 'dagil'),
                    'readonly' => true
                ]
            ]
        ],
        'artwork_technique' => [
            'title' => __('Technique Details', 'dagil'),
            'fields' => [
                [
                    'name' => 'medium',
                    'label' => __('Medium', 'dagil'),
                    'type' => 'select',
                    'options' => [
                        'oil' => 'Oil on Canvas',
                        'watercolor' => 'Watercolor',
                        'acrylic' => 'Acrylic',
                        'digital' => 'Digital',
                        'pencil' => 'Pencil/Charcoal',
                        'other' => 'Other'
                    ]
                ],
                [
                    'name' => 'dimensions',
                    'label' => __('Dimensions (cm)', 'dagil'),
                    'type' => 'text',
                    'description' => __('Width × Height (e.g., 50 × 70)', 'dagil')
                ]
            ]
        ]
    ];

    public function __construct() {
        // Register 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);

        // Register enqueue scripts and styles
        add_action('wp_enqueue_scripts', [$this, 'enqueue_assets']);

        // Shortcode for gallery display
        add_shortcode('dynamic_art_gallery', [$this, 'gallery_shortcode']);

        // Add filter for content in lightbox
        add_filter('dagil_lightbox_content', [$this, 'get_lightbox_content']);
    }

    /**
     * Register custom post type
     */
    public function register_post_type() {
        $labels = [
            'name' => _x('Artworks', 'post type general name', 'dagil'),
            'singular_name' => _x('Artwork', 'post type singular name', 'dagil'),
            'menu_name' => _x('Art Gallery', 'admin menu', 'dagil'),
            'add_new' => _x('Add New', 'artwork', 'dagil'),
            'add_new_item' => __('Add New Artwork', 'dagil'),
            'edit_item' => __('Edit Artwork', 'dagil'),
            'new_item' => __('New Artwork', 'dagil'),
            'view_item' => __('View Artwork', 'dagil'),
            'search_items' => __('Search Artworks', 'dagil'),
            'not_found' => __('No artworks found', 'dagil'),
            'not_found_in_trash' => __('No artworks found in Trash', 'dagil'),
            'parent_item_colon' => __('Parent Artworks:', 'dagil'),
            'all_items' => __('All Artworks', 'dagil'),
            'archive_title' => __('Artworks Archive', 'dagil'),
            'attributes' => __('Artwork Attributes', 'dagil'),
            'insert_into_item' => __('Insert into artwork', 'dagil'),
            'uploaded_to_this_item' => __('Uploaded to this artwork', 'dagil'),
            'items_list' => __('Artworks list', 'dagil'),
            'items_list_navigation' => __('Artworks list navigation', 'dagil'),
            'filter_items_list' => __('Filter artworks list', 'dagil'),
            'filter_by_date' => __('Filter artworks by date', 'dagil'),
            'filter_by_year' => __('Filter artworks by year', 'dagil'),
            'filter_by_month' => __('Filter artworks by month', 'dagil'),
            'filter_by_day' => __('Filter artworks by day', 'dagil'),
        ];

        $args = [
            'labels' => $labels,
            'public' => true,
            'publicly_queryable' => true,
            'show_ui' => true,
            'show_in_menu' => true,
            'query_var' => true,
            'rewrite' => ['slug' => 'artwork'],
            'capability_type' => 'post',
            'has_archive' => true,
            'hierarchical' => false,
            'menu_position' => 5,
            'supports' => ['title', 'editor', 'thumbnail', 'excerpt', 'comments'],
            'taxonomies' => ['category', 'post_tag'],
            'show_in_rest' => true,
        ];

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

        // Flush rewrite rules on plugin activation
        register_activation_hook(__FILE__, function() {
            $this->register_post_type();
            flush_rewrite_rules();
        });
    }

    /**
     * Add meta boxes to post edit screen
     */
    public function add_meta_boxes() {
        add_meta_box(
            'artwork_details_meta_box',
            $this->meta_boxes['artwork_details']['title'],
            [$this, 'render_meta_box'],
            $this->post_type_name,
            'normal',
            'high'
        );

        add_meta_box(
            'artwork_technique_meta_box',
            $this->meta_boxes['artwork_technique']['title'],
            [$this, 'render_meta_box'],
            $this->post_type_name,
            'normal',
            'high'
        );
    }

    /**
     * Render meta box fields
     */
    public function render_meta_box($post, $meta_box_key) {
        $meta_box = array_key_exists($meta_box_key, $this->meta_boxes) ? $this->meta_boxes[$meta_box_key] : [];
        $nonces = ['artwork_details_nonce' => 'artwork_details_nonce', 'artwork_technique_nonce' => 'artwork_technique_nonce'];

        if (!empty($meta_box['title'])) {
            echo '<div class="meta-box-title">';
            echo $meta_box['title'];
            echo '</div>';
        }

        wp_nonce_field($meta_box_key, $nonces[$meta_box_key]);

        foreach ($meta_box['fields'] as $field) {
            $value = get_post_meta($post->ID, $field['name'], true);
            $value = !empty($value) ? $value : '';

            echo '<div class="field">';
            echo '<label for="' . esc_attr($field['name']) . '">' . esc_html($field['label']) . '</label>';

            if ($field['type'] === 'select') {
                echo '<select name="' . esc_attr($field['name']) . '" id="' . esc_attr($field['name']) . '"';
                if (!empty($field['class'])) {
                    echo ' class="' . esc_attr($field['class']) . '"';
                }
                echo '>';
                foreach ($field['options'] as $option_key => $option_label) {
                    echo '<option value="' . esc_attr($option_key) . '"' . selected($option_key, $value, false) . '>' . esc_html($option_label) . '</option>';
                }
                echo '</select>';
            } else {
                echo '<input type="' . esc_attr($field['type']) . '" name="' . esc_attr($field['name']) . '" id="' . esc_attr($field['name']) . '" value="' . esc_attr($value) . '"';
                if (!empty($field['class'])) {
                    echo ' class="' . esc_attr($field['class']) . '"';
                }
                if (!empty($field['description'])) {
                    echo ' placeholder="' . esc_attr($field['description']) . '"';
                }
                if (isset($field['readonly']) && $field['readonly']) {
                    echo ' readonly';
                }
                echo '>';

                if (!empty($field['description'])) {
                    echo '<p class="field-description">' . esc_html($field['description']) . '</p>';
                }
            }

            echo '</div>';
        }
    }

    /**
     * Save meta box data
     */
    public function save_meta_box_data($post_id, $post) {
        $nonces = ['artwork_details_nonce' => 'artwork_details_nonce', 'artwork_technique_nonce' => 'artwork_technique_nonce'];

        if (!isset($_POST['artwork_details_nonce']) || !wp_verify_nonce($_POST['artwork_details_nonce'], 'artwork_details_nonce')) {
            return;
        }

        if (!isset($_POST['artwork_technique_nonce']) || !wp_verify_nonce($_POST['artwork_technique_nonce'], 'artwork_technique_nonce')) {
            return;
        }

        if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
            return;
        }

        if (!current_user_can('edit_post', $post_id)) {
            return;
        }

        $meta_boxes = ['artwork_details' => 'artwork_details_nonce', 'artwork_technique' => 'artwork_technique_nonce'];

        foreach ($meta_boxes as $box_key => $nonce_key) {
            if (isset($_POST[$box_key])) {
                $fields = $this->meta_boxes[$box_key]['fields'];
                foreach ($fields as $field) {
                    if (isset($_POST[$field['name']])) {
                        $slug = sanitize_key($field['name']);
                        $value = sanitize_text_field($_POST[$field['name']]);

                        update_post_meta($post_id, $slug, $value);
                    }
                }

                // Analyze image and set mood score if not set
                $thumbnail_id = get_post_thumbnail_id($post_id);
                if ($thumbnail_id && !get_post_meta($post_id, 'mood_score', true)) {
                    $this->analyze_image_mood($thumbnail_id, $post_id);
                }
            }
        }
    }

    /**
     * Analyze image colors and set mood score
     */
    private function analyze_image_mood($attachment_id, $post_id) {
        $image_url = wp_get_attachment_image_url($attachment_id, 'full');
        if (!$image_url) {
            return;
        }

        $image = imagecreatefromstring(file_get_contents($image_url));
        if (!$image) {
            return;
        }

        $colors = [];
        $width = imagesx($image);
        $height = imagesy($image);

        // Sample 100 pixels from the image
        $sample_size = min(100, $width * $height);

        for ($i = 0; $i < $sample_size; $i++) {
            $x = rand(0, $width - 1);
            $y = rand(0, $height - 1);
            $color = imagecolorat($image, $x, $y);
            $rgb = imagecolorsforindex($image, $color);
            $colors[] = [
                'r' => $rgb['red'],
                'g' => $rgb['green'],
                'b' => $rgb['blue']
            ];
        }

        imagedestroy($image);

        if (empty($colors)) {
            return;
        }

        // Calculate average color
        $avg_r = array_sum(array_column($colors, 'r')) / count($colors);
        $avg_g = array_sum(array_column($colors, 'g')) / count($colors);
        $avg_b = array_sum(array_column($colors, 'b')) / count($colors);

        // Determine mood based on color characteristics
        $mood = $this->determine_mood($avg_r, $avg_g, $avg_b);

        // Store mood score (0-100)
        update_post_meta($post_id, 'mood_score', $mood);
    }

    /**
     * Determine mood based on color analysis
     */
    private function determine_mood($r, $g, $b) {
        // Calculate brightness and saturation
        $brightness = (0.299 * $r + 0.587 * $g + 0.114 * $b) / 255;
        $max = max($r, $g, $b);
        $min = min($r, $g, $b);
        $saturation = ($max - $min) / $max;

        // Calculate color temperature (rough approximation)
        $temp = $this->calculate_color_temperature($r, $g, $b);

        // Determine mood based on color properties
        if ($brightness > 0.7) {
            $mood = 80; // Very bright
        } elseif ($brightness > 0.5) {
            $mood = 60; // Bright
        } elseif ($brightness > 0.3) {
            $mood = 40; // Medium brightness
        } else {
            $mood = 20; // Dark
        }

        // Adjust mood based on saturation
        if ($saturation > 0.5) {
            $mood += 20;
        } elseif ($saturation < 0.2) {
            $mood -= 20;
        }

        // Adjust for color temperature
        if ($temp < 3000) {
            $mood += 10; // Warm colors (red, orange)
        } elseif ($temp > 5000) {
            $mood -= 10; // Cool colors (blue, purple)
        }

        // Clamp mood between 0 and 100
        $mood = max(0, min(100, $mood));

        return round($mood);
    }

    /**
     * Calculate approximate color temperature (Kelvin)
     */
    private function calculate_color_temperature($r, $g, $b) {
        // Convert RGB to XYZ
        $r = $r / 255;
        $g = $g / 255;
        $b = $b / 255;

        // Apply gamma correction
        $r = $r <= 0.04045 ? $r / 12.92 : pow(($r + 0.055) / 1.055, 2.4);
        $g = $g <= 0.04045 ? $g / 12.92 : pow(($g + 0.055) / 1.055, 2.4);
        $b = $b <= 0.04045 ? $b / 12.92 : pow(($b + 0.055) / 1.055, 2.4);

        // Observer = 2°, Illuminant = D65
        $x = $r * 0.4124 + $g * 0.3576 + $b * 0.1805;
        $y = $r * 0.2126 + $g * 0.7152 + $b * 0.0722;
        $z = $r * 0.0193 + $g * 0.1192 + $b * 0.9505;

        // Convert XYZ to uv
        $u = ($x * 0.4124 + $y * 0.3576 + $z * 0.1805) / 0.17697;
        $v = ($x * 0.2126 + $y * 0.7152 + $z * 0.0722) / 0.31271;

        // Calculate n_uv and n
        $n_uv = ($u - 0.197799 + 0.0000015926) / 0.020108;
        $n = $n_uv - 1.40526;
        $n_squared = $n * $n;

        // Calculate temperature (simplified formula)
        $temperature = 430.0 * (1 / $n - 0.159) + 459.0

using UnityEngine;
using System.Collections.Generic;

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class BiomorphicTerrainSculptor : MonoBehaviour
{
    [Header("Generation Settings")]
    [SerializeField, Range(0.1f, 10f)] private float scale = 1f;
    [SerializeField, Range(1, 64)] private int resolution = 16;
    [SerializeField, Range(0, 1)] private float organicDeformation = 0.5f;
    [SerializeField, Range(0, 1)] private float cellularNoise = 0.3f;
    [SerializeField, MinMaxSlider(0, 1, true)] private Vector2 elevationRange = new Vector2(0, 1);
    [SerializeField, Range(0, 1)] private float smoothness = 0.7f;
    [SerializeField] private Material terrainMaterial;
    [SerializeField] private bool autoUpdate = true;
    [SerializeField] private AnimationCurve erosionCurve = AnimationCurve.Linear(0, 0, 1, 1);

    [Header("Erosion Settings")]
    [SerializeField, Range(0, 1)] private float erosionStrength = 0.4f;
    [SerializeField, Range(1, 10)] private int erosionIterations = 3;
    [SerializeField] private bool enableErosion = true;

    private Mesh mesh;
    private Vector3[] vertices;
    private int[] triangles;
    private Color[] colors;
    private Vector2[] uv;

    private void Awake()
    {
        mesh = new Mesh();
        GetComponent<MeshFilter>().mesh = mesh;
        GetComponent<MeshRenderer>().material = terrainMaterial;
        GenerateTerrain();
    }

    private void GenerateTerrain()
    {
        resolution = Mathf.Clamp(resolution, 1, 64);
        resolution = Mathf.RoundToInt(Mathf.Pow(2, resolution));

        GenerateBaseMesh();
        ApplyOrganicDeformation();
        if (enableErosion) ApplyErosion();
        ApplySmoothness();
        UpdateMesh();
    }

    private void GenerateBaseMesh()
    {
        int verticesCount = (resolution + 1) * (resolution + 1);
        vertices = new Vector3[verticesCount];
        triangles = new int[resolution * resolution * 6];
        colors = new Color[verticesCount];
        uv = new Vector2[verticesCount];

        for (int y = 0; y <= resolution; y++)
        {
            for (int x = 0; x <= resolution; x++)
            {
                float xPos = (x / (float)resolution - 0.5f) * scale;
                float yPos = (y / (float)resolution - 0.5f) * scale;
                vertices[y * (resolution + 1) + x] = new Vector3(xPos, 0, yPos);
                uv[y * (resolution + 1) + x] = new Vector2(x / (float)resolution, y / (float)resolution);

                // Base elevation using Perlin noise
                float perlinValue = Mathf.PerlinNoise(xPos * 0.5f, yPos * 0.5f);
                float elevation = Mathf.Lerp(elevationRange.x, elevationRange.y, perlinValue);
                vertices[y * (resolution + 1) + x].y = elevation * scale * (1 - cellularNoise);

                // Color based on elevation
                colors[y * (resolution + 1) + x] = Color.Lerp(
                    Color.white * 0.8f,
                    new Color(0.3f, 0.5f, 0.2f, 1),
                    elevation
                );
            }
        }

        // Generate triangles
        int triangleIndex = 0;
        for (int y = 0; y < resolution; y++)
        {
            for (int x = 0; x < resolution; x++)
            {
                int vertexIndex = y * (resolution + 1) + x;
                triangles[triangleIndex++] = vertexIndex;
                triangles[triangleIndex++] = vertexIndex + 1;
                triangles[triangleIndex++] = vertexIndex + resolution + 1;

                triangles[triangleIndex++] = vertexIndex + 1;
                triangles[triangleIndex++] = vertexIndex + resolution + 2;
                triangles[triangleIndex++] = vertexIndex + resolution + 1;
            }
        }
    }

    private void ApplyOrganicDeformation()
    {
        for (int i = 0; i < vertices.Length; i++)
        {
            // Organic deformation using multiple noise layers with different frequencies
            float organicNoise1 = Mathf.PerlinNoise(vertices[i].x * 0.3f, vertices[i].z * 0.3f);
            float organicNoise2 = Mathf.PerlinNoise(vertices[i].x * 0.7f, vertices[i].z * 0.7f);
            float organicNoise3 = Mathf.PerlinNoise(vertices[i].x * 1.1f, vertices[i].z * 1.1f);

            float combinedOrganic = (organicNoise1 * 0.5f + organicNoise2 * 0.3f + organicNoise3 * 0.2f) * organicDeformation;
            vertices[i].y += combinedOrganic * scale;

            // Add some cellular automata-like patterns
            float cellularPattern = Mathf.PerlinNoise(
                vertices[i].x * 0.1f + Time.time * 0.01f,
                vertices[i].z * 0.1f + Time.time * 0.01f
            );
            vertices[i].y += Mathf.Sin(cellularPattern * Mathf.PI * 2) * cellularNoise * scale;
        }
    }

    private void ApplyErosion()
    {
        float[,] heightMap = new float[resolution + 1, resolution + 1];
        float[,] sedimentMap = new float[resolution + 1, resolution + 1];

        // Initialize height map from current vertices
        for (int y = 0; y <= resolution; y++)
        {
            for (int x = 0; x <= resolution; x++)
            {
                heightMap[x, y] = vertices[y * (resolution + 1) + x].y / scale;
                sedimentMap[x, y] = 0.5f;
            }
        }

        // Apply erosion
        for (int iteration = 0; iteration < erosionIterations; iteration++)
        {
            for (int y = 1; y < resolution; y++)
            {
                for (int x = 1; x < resolution; x++)
                {
                    // Calculate neighbors
                    float left = heightMap[x - 1, y];
                    float right = heightMap[x + 1, y];
                    float up = heightMap[x, y + 1];
                    float down = heightMap[x, y - 1];

                    // Calculate average height of neighbors
                    float avgNeighborHeight = (left + right + up + down) / 4f;
                    float currentHeight = heightMap[x, y];

                    // Calculate erosion based on height difference
                    float erosionFactor = erosionCurve.Evaluate(Mathf.InverseLerp(0, 1, currentHeight));
                    float erosionAmount = erosionFactor * erosionStrength * (currentHeight - avgNeighborHeight);

                    // Apply erosion
                    heightMap[x, y] -= erosionAmount;

                    // Update sediment based on erosion
                    float sedimentDeposition = erosionAmount * 0.5f;
                    sedimentMap[x, y] += sedimentDeposition;

                    // Deposit sediment to lower neighbors
                    if (currentHeight < avgNeighborHeight)
                    {
                        float depositFactor = (avgNeighborHeight - currentHeight) * 0.1f;
                        sedimentMap[x, y] -= depositFactor;
                    }
                }
            }

            // Apply erosion to the mesh
            for (int y = 0; y <= resolution; y++)
            {
                for (int x = 0; x <= resolution; x++)
                {
                    float erosionEffect = erosionCurve.Evaluate(Mathf.InverseLerp(0, 1, heightMap[x, y])) * (1 - sedimentMap[x, y] * 0.5f);
                    vertices[y * (resolution + 1) + x].y = Mathf.Lerp(
                        vertices[y * (resolution + 1) + x].y,
                        (heightMap[x, y] * scale * elevationRange.y) * (1 - erosionEffect * 0.3f),
                        0.5f
                    );
                }
            }
        }
    }

    private void ApplySmoothness()
    {
        for (int y = 1; y < resolution; y++)
        {
            for (int x = 1; x < resolution; x++)
            {
                int centerIndex = y * (resolution + 1) + x;
                float centerHeight = vertices[centerIndex].y;

                // Average height of neighbors
                float avgHeight = 0;
                int neighborCount = 0;

                // Check all 8 neighbors
                for (int ny = -1; ny <= 1; ny++)
                {
                    for (int nx = -1; nx <= 1; nx++)
                    {
                        if (nx == 0 && ny == 0) continue;

                        int neighborX = x + nx;
                        int neighborY = y + ny;

                        if (neighborX >= 0 && neighborX <= resolution && neighborY >= 0 && neighborY <= resolution)
                        {
                            int neighborIndex = neighborY * (resolution + 1) + neighborX;
                            avgHeight += vertices[neighborIndex].y;
                            neighborCount++;
                        }
                    }
                }

                if (neighborCount > 0)
                {
                    avgHeight /= neighborCount;
                    // Smooth the height based on smoothness parameter
                    vertices[centerIndex].y = Mathf.Lerp(centerHeight, avgHeight, smoothness);
                }
            }
        }
    }

    private void UpdateMesh()
    {
        mesh.vertices = vertices;
        mesh.triangles = triangles;
        mesh.uv = uv;
        mesh.colors = colors;
        mesh.RecalculateNormals();
    }

    private void OnValidate()
    {
        if (autoUpdate)
        {
            GenerateTerrain();
        }
    }

    private void Update()
    {
        if (autoUpdate)
        {
            GenerateTerrain();
        }
    }
}

use std::net::SocketAddr;
use std::sync::Arc;
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::Mutex;
use hyper::{
    body::Bytes,
    server::conn::http1,
    Body, Request, Response, Server,
};
use hyper::service::{make_service_fn, service_fn};
use serde::Serialize;
use rand::seq::SliceRandom;
use rand::thread_rng;

// Simple JSON response structure with creative metadata
#[derive(Serialize)]
struct CreativeResponse {
    original: String,
    translated: String,
    color_code: String,
    emoji_decorated: String,
    creative_twist: String,
}

// Middleware types for extensibility
type Middleware = Box<dyn (dyn Fn(Request<Body>) -> Box<dyn std::future::Future<Output = Result<Response<Body>, hyper::Error>> + Send> + Send) + Send>;
type MiddlewareChain = Vec<Middleware>;

// Server state with middleware stack
#[derive(Clone)]
struct ServerState {
    middlewares: Arc<Mutex<MiddlewareChain>>,
}

// Apply middleware chain to the request
async fn apply_middleware(
    req: Request<Body>,
    state: Arc<ServerState>,
) -> Result<Response<Body>, hyper::Error> {
    let mut res = req;
    let mut rng = thread_rng();

    // Apply each middleware in order
    for middleware in state.middlewares.lock().await.iter() {
        res = middleware(res).await?;
    }

    Ok(res)
}

// Creative color code translator
async fn color_code_middleware(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
    let mut body_bytes = hyper::body::to_bytes(req.into_body()).await?;
    let body_str = String::from_utf8_lossy(&body_bytes);

    // Translate to a creative color code (hex representation)
    let color_code = format!("{:06x}", rand::random::<u32>());
    let translated = format!("#{color_code}");

    // Prepare creative response
    let emoji_deco = ["🎨", "🌈", "🖤", "🟦", "🟧", "🟨"]
        .choose(&mut thread_rng())
        .unwrap_or(&"🎨");
    let twist = vec!["Rainbow mode!", "Neon glow!", "Mood: Artistic", "Color-coded!"]
        .choose(&mut thread_rng())
        .unwrap_or(&"Color magic!");

    let response = CreativeResponse {
        original: body_str.into_owned(),
        translated,
        color_code,
        emoji_decorated: format!("{}{}", emoji_deco, body_str),
        creative_twist: twist.to_string(),
    };

    let response_json = serde_json::to_string(&response).unwrap();
    let response_bytes = Bytes::from(response_json);

    Ok(Response::builder()
        .status(200)
        .header("Content-Type", "application/json")
        .body(Body::from(response_bytes))
        .unwrap())
}

// Middleware to add a creative header
async fn creative_header_middleware(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
    let mut res = req;
    *res.headers_mut() = res.headers_mut().unwrap_or_default()
        .insert(
            "X-Creative-Twist",
            "Ailey's Colorful Echo Server".parse().unwrap(),
        );
    Ok(res)
}

// Main server function with async handling
async fn run_server(addr: SocketAddr, middlewares: MiddlewareChain) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let state = ServerState {
        middlewares: Arc::new(Mutex::new(middlewares)),
    };

    let make_svc = make_service_fn(move |_conn| {
        let state = state.clone();
        async move {
            Ok::<_, hyper::Error>(service_fn(move |req| {
                let state = state.clone();
                async move {
                    apply_middleware(req, state).await
                }
            }))
        }
    });

    let server = Server::bind(&addr)
        .serve(make_svc);

    println!("Server running on http://{}", addr);
    server.await?;
    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Define our creative middlewares
    let middlewares = vec![
        Box::new(color_code_middleware),
        Box::new(creative_header_middleware),
    ];

    // Run the server on 0.0.0.0:8080
    run_server("0.0.0.0:8080".parse().unwrap(), middlewares).await
}

#!/usr/bin/env node
import fs from 'node:fs/promises';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { marked } from 'marked';
import { JSDOM } from 'jsdom';
import { createHash } from 'node:crypto';
import chokidar from 'chokidar';

// Configure marked for basic HTML sanitization
marked.setOptions({
  gfm: true,
  breaks: true,
  sanitize: true,
  headerIds: false, // We'll handle IDs ourselves for better permalinks
});

// Cyberpunk-ish theme variables (could be externalized, but kept here for brevity)
const NEON_COLORS = ['#ff00ff', '#00ffff', '#ffff00', '#ff00aa'];
const NEON_GLOW = 'filter: drop-shadow(0 0 8px currentColor); transition: filter 0.3s ease;';

// Directory setup
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const srcDir = path.join(__dirname, 'src');
const outDir = path.join(__dirname, 'dist');
const assetsDir = path.join(__dirname, 'assets');

// Ensure directories exist
async function ensureDirs() {
  await fs.mkdir(srcDir, { recursive: true });
  await fs.mkdir(outDir, { recursive: true });
  await fs.mkdir(assetsDir, { recursive: true });
}

// Generate a cyberpunk-style permalink (hash + a splash of color)
function generatePermalink(title) {
  const hash = createHash('sha256').update(title).digest('hex').substring(0, 8);
  const color = NEON_COLORS[hash.length % NEON_COLORS.length];
  return `#${hash} ${color}`;
}

// Process a single Markdown file into HTML
async function processFile(filePath) {
  const content = await fs.readFile(filePath, 'utf8');
  const title = content.match(/^#\s*(.+)/m)?.[1] || 'Untitled';
  const slug = sanitizeSlug(title);
  const htmlContent = marked.parse(content);

  // Inject neon effects into headings
  const dom = new JSDOM(htmlContent);
  const { document } = dom.window;
  const headings = document.querySelectorAll('h1, h2, h3, h4, h5, h6');

  headings.forEach(heading => {
    const color = NEON_COLORS[Math.floor(Math.random() * NEON_COLORS.length)];
    heading.style.color = color;
    heading.style.fontFamily = '"Courier New", monospace';
    heading.styleNEON = NEON_GLOW;
    heading.addEventListener('mouseover', () => heading.styleNEON = 'filter: drop-shadow(0 0 12px currentColor) drop-shadow(0 0 20px currentColor);');
    heading.addEventListener('mouseout', () => heading.styleNEON = NEON_GLOW);
  });

  // Generate a permalink anchor
  const permalinkId = `permalink-${slug}`;
  const permalink = document.createElement('a');
  permalink.href = `#${slug}`;
  permalink.textContent = '¶';
  permalink.className = 'neon-permalink';
  permalink.style.color = '#fff';
  permalink.styleNEON = NEON_GLOW;
  permalink.addEventListener('mouseover', () => permalink.styleNEON = 'filter: drop-shadow(0 0 12px currentColor) drop-shadow(0 0 20px currentColor);');
  permalink.addEventListener('mouseout', () => permalink.styleNEON = NEON_GLOW);

  const heading = document.querySelector('h1') || document.querySelector('h2') || document.querySelector('h3');
  if (heading) {
    heading.insertAdjacentElement('afterend', permalink);
    permalink.id = permalinkId;
  }

  return {
    title,
    slug,
    html: dom.serialize(),
  };
}

// Sanitize a string for use in URLs/slugs
function sanitizeSlug(str) {
  return str
    .toString()
    .toLowerCase()
    .trim()
    .replace(/[^\w\s-]/g, '')
    .replace(/[\s-]+/g, '-')
    .replace(/^-+|-+$/g, '');
}

// Generate the static site HTML
async function generateSite(files) {
  const sortedFiles = files.sort((a, b) => a.localeCompare(b));
  let html = `
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>NeonNarrative</title>
  <style>
    :root {
      --neon-glow: ${NEON_GLOW};
    }
    body {
      font-family: 'Courier New', monospace;
      background-color: #111;
      color: #0f0;
      line-height: 1.6;
      margin: 0;
      padding: 2rem;
      max-width: 80ch;
      margin-left: auto;
      margin-right: auto;
    }
    a {
      color: var(--neon-color, #0ff);
      transition: color 0.2s ease;
    }
    a:hover {
      color: #fff;
      text-decoration: underline;
    }
    .neon-permalink {
      display: inline-block;
      margin-left: 0.5rem;
      vertical-align: top;
      font-size: 0.8em;
    }
    h1, h2, h3, h4, h5, h6 {
      font-family: 'Courier New', monospace;
      margin: 1.5em 0 0.5em;
      counter-reset: section;
    }
    h1 { color: #f00; }
    h2 { color: #0f0; }
    h3 { color: #00f; }
    h4 { color: #ff0; }
    h5 { color: #f0f; }
    h6 { color: #0ff; }
    code {
      background: rgba(0, 0, 0, 0.5);
      padding: 0.2em 0.4em;
      border-radius: 3px;
    }
    pre {
      background: rgba(0, 0, 0, 0.5);
      padding: 1em;
      border-radius: 5px;
      overflow-x: auto;
    }
    blockquote {
      background: rgba(0, 0, 0, 0.5);
      padding: 1em;
      border-left: 3px solid #0f0;
      margin: 1em 0;
    }
  </style>
</head>
<body>
  <header>
    <h1 style="color: #f00;">NeonNarrative</h1>
    <p>A cyberpunk-inspired static site generator.</p>
  </header>
  <main>
  `;

  for (const file of sortedFiles) {
    const { title, slug, html } = await processFile(file);
    html.split('\n').forEach(line => {
      if (line.includes('<h1') || line.includes('<h2')) {
        html = html.replace(line, line.replace(/style="(.*?)"/, `style="$1 counter(section, decimal) \A; margin-left: 2em;"`));
      }
    });
    html = html.replace(/<body>(.*)<\/body>/s, '$1');
    html = html.replace(/<html[^>]*>/, '<html>');
    html = html.replace(/<head[^>]*>/, '<head>');
    html = html.replace(/<\/html>/, '</html>');

    const wrapped = `<section id="${slug}">\n${html}\n</section>`;
    html += wrapped;
  }

  html += `
  </main>
  <footer style="margin-top: 3rem; font-size: 0.8em; color: #0f0;">
    <p>Generated with NeonNarrative. Live reloading enabled.</p>
  </footer>
  <script>
    // Simple live reloader
    const liveReload = fetch('http://localhost:3000/')
      .then(() => setTimeout(() => location.reload(), 1000))
      .catch(() => setTimeout(() => location.reload(), 1000));
  </script>
</body>
</html>
  `;

  await fs.writeFile(path.join(outDir, 'index.html'), html);
  console.log(`✨ Static site generated in ${outDir}/index.html`);
}

// Watch for changes and regenerate
function watchFiles() {
  const watcher = chokidar.watch([path.join(srcDir, '**/*.md')], {
    ignored: /(^|\\\)\./,
    persistent: true,
  });

  watcher
    .on('add', (filePath) => {
      console.log(`📝 Added: ${filePath}`);
      generateSite([filePath]);
    })
    .on('change', (filePath) => {
      console.log(`🔄 Changed: ${filePath}`);
      generateSite([filePath]);
    })
    .on('unlink', (filePath) => {
      console.log(`🗑️ Removed: ${filePath}`);
      generateSite([]); // Regenerate from scratch
    })
    .on('error', (error) => console.error('Watcher error:', error));
}

// Main function
async function main() {
  await ensureDirs();
  const files = await fs.readdir(srcDir);
  const mdFiles = files.filter(file => file.endsWith('.md'));

  if (mdFiles.length === 0) {
    console.log('⚠️ No Markdown files found in the "src" directory. Create one to start.');
    return;
  }

  await generateSite(mdFiles.map(file => path.join(srcDir, file)));
  watchFiles();
}

main().catch(err => {
  console.error('❌ Error:', err);
  process.exit(1);
});