A!leys Galerie

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

#!/usr/bin/env python3
"""
SymmetricKeylocked — Encrypt/decrypt files using a drawn key pattern.
"""

import os
import sys
import hashlib
import argparse
import getpass
from typing import Optional, Tuple, List
from pathlib import Path
import hashlib
import numpy as np
from PIL import Image, ImageDraw, ImageTk
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import base64

# Constants
KEY_SIZE = 32  # 256-bit key
COLOR_PALETTE = ["#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#FF00FF", "#00FFFF"]
CANVAS_SIZE = (400, 400)
PATTERN_SIZE = (10, 10)

class SymmetricKeyGenerator:
    """
    Generates a symmetric key from a user-drawn pattern.
    """

    def __init__(self, canvas_size: Tuple[int, int] = CANVAS_SIZE):
        self.canvas_size = canvas_size
        self.pattern_size = PATTERN_SIZE
        self.key: Optional[bytes] = None

    def draw_canvas(self, window: tk.Tk) -> None:
        """
        Renders a drawing canvas for user pattern input.
        """
        self.canvas = tk.Canvas(window, width=self.canvas_size[0], height=self.canvas_size[1],
                               bg="white", highlightthickness=1, highlightbackground="black")
        self.canvas.pack(pady=10)

        self.draw_tool = "line"
        self.last_x, self.last_y = None, None

        self.canvas.bind("<B1-Motion>", self.draw_line)
        self.canvas.bind("<Button-1>", self.draw_start)
        self.canvas.bind("<ButtonRelease-1>", self.draw_end)

        # Render grid lines
        self._render_grid()

    def _render_grid(self) -> None:
        """
        Draws a visual grid on the canvas.
        """
        width, height = self.canvas_size
        x_step = width // self.pattern_size[0]
        y_step = height // self.pattern_size[1]
        for x in range(0, width, x_step):
            self.canvas.create_line((x, 0, x, height), fill="#e0e0e0")
        for y in range(0, height, y_step):
            self.canvas.create_line((0, y, width, y), fill="#e0e0e0")

    def draw_start(self, event: tk.Event) -> None:
        """
        Handles the start of a drawing action.
        """
        self.last_x, self.last_y = event.x, event.y

    def draw_line(self, event: tk.Event) -> None:
        """
        Draws a line on the canvas.
        """
        if self.last_x and self.last_y:
            self.canvas.create_line((self.last_x, self.last_y, event.x, event.y),
                                   width=3, fill=COLOR_PALETTE[0], capstyle=tk.ROUND, smooth=True)
        self.last_x, self.last_y = event.x, event.y

    def draw_end(self, _: tk.Event) -> None:
        """
        Ends the drawing action and generates the key.
        """
        self._extract_pattern()
        self.key = self._hash_pattern()
        self.canvas.delete("all")
        self.canvas.create_text(self.canvas_size[0] // 2, self.canvas_size[1] // 2,
                               text="Key generated!", font=("Helvetica", 16, "bold"),
                               fill="#000000")
        self.canvas.after(1000, self.canvas.destroy)

    def _extract_pattern(self) -> np.ndarray:
        """
        Extracts the drawn pattern as a 2D numpy array.
        """
        grid_size = self.pattern_size
        img = Image.new("RGBA", self.canvas_size, (255, 255, 255, 0))
        draw = ImageDraw.Draw(img)
        draw.line([(self.last_x, self.last_y)], fill=COLOR_PALETTE[0], width=3)
        img = img.resize(grid_size, Image.LANCZOS)
        img = img.convert("L")
        img = np.array(img) // 255
        return img

    def _hash_pattern(self) -> bytes:
        """
        Hashes the extracted pattern to a fixed-size key.
        """
        pattern = self._extract_pattern()
        pattern_str = base64.b64encode(pattern.tobytes()).decode("ascii")
        return hashlib.sha256(pattern_str.encode("ascii")).digest()

class FileEncryptorDecryptor:
    """
    Encrypts/decrypts files using AES-256 in CBC mode.
    """

    def __init__(self, key: bytes):
        self.key = key[:KEY_SIZE]
        self.iv = os.urandom(16)  # 16 bytes for AES

    def _encrypt_block(self, data: bytes) -> bytes:
        """
        Encrypts a block of data.
        """
        from Crypto.Cipher import AES
        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
        return cipher.encrypt(data)

    def _decrypt_block(self, data: bytes) -> bytes:
        """
        Decrypts a block of data.
        """
        from Crypto.Cipher import AES
        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
        return cipher.decrypt(data)

    def encrypt_file(self, input_path: str, output_path: str) -> bool:
        """
        Encrypts a file.
        """
        try:
            with open(input_path, "rb") as fin, open(output_path, "wb") as fout:
                data = fin.read()
                # Pad data to multiple of block size (16)
                pad = 16 - (len(data) % 16)
                padded_data = data + bytes([pad] * pad)
                encrypted = self._encrypt_block(padded_data)
                fout.write(self.iv + encrypted)
            return True
        except Exception as e:
            print(f"Encryption failed: {e}", file=sys.stderr)
            return False

    def decrypt_file(self, input_path: str, output_path: str) -> bool:
        """
        Decrypts a file.
        """
        try:
            with open(input_path, "rb") as fin, open(output_path, "wb") as fout:
                data = fin.read()
                iv = data[:16]
                encrypted = data[16:]
                decrypted = self._decrypt_block(encrypted)
                # Unpad data
                pad = decrypted[-1]
                if pad > 16:
                    raise ValueError("Invalid padding")
                unpadded_data = decrypted[:-pad]
                fout.write(unpadded_data)
            return True
        except Exception as e:
            print(f"Decryption failed: {e}", file=sys.stderr)
            return False

def main() -> None:
    """
    Main entry point.
    """
    parser = argparse.ArgumentParser(description="SymmetricKeylocked — Encrypt/decrypt files using a drawn key.")
    parser.add_argument("action", choices=["encrypt", "decrypt"], help="Action: encrypt or decrypt")
    parser.add_argument("input", help="Input file or directory")
    parser.add_argument("output", help="Output file or directory")
    parser.add_argument("--keyfile", help="Path to save/load key (optional)")
    args = parser.parse_args()

    input_path = Path(args.input)
    output_path = Path(args.output)
    if not input_path.exists():
        print(f"Error: Input path does not exist: {input_path}", file=sys.stderr)
        sys.exit(1)
    if output_path.exists() and output_path.is_file():
        print(f"Error: Output path already exists and is a file: {output_path}", file=sys.stderr)
        sys.exit(1)

    # Generate or load key
    key: Optional[bytes] = None
    if args.keyfile:
        keyfile = Path(args.keyfile)
        if keyfile.exists():
            with open(keyfile, "rb") as f:
                key = f.read()
        else:
            print(f"Warning: Key file not found, generating new one: {keyfile}", file=sys.stderr)

    if key is None:
        root = tk.Tk()
        root.withdraw()  # Hide the main window
        generator = SymmetricKeyGenerator()
        generator.draw_canvas(root)
        root.mainloop()
        key = generator.key
        if not key:
            print("Error: Key generation failed.", file=sys.stderr)
            sys.exit(1)
        if args.keyfile:
            with open(args.keyfile, "wb") as f:
                f.write(key)
    else:
        if len(key) != KEY_SIZE:
            print(f"Error: Key size must be {KEY_SIZE} bytes.", file=sys.stderr)
            sys.exit(1)

    # Process input/output paths
    input_path = Path(args.input)
    output_path = Path(args.output)
    if input_path.is_dir():
        for file in input_path.glob("*"):
            if file.is_file():
                output_file = output_path / file.name
                if args.action == "encrypt":
                    encryptor = FileEncryptorDecryptor(key)
                    encryptor.encrypt_file(str(file), str(output_file))
                else:
                    decryptor = FileEncryptorDecryptor(key)
                    decryptor.decrypt_file(str(file), str(output_file))
    else:
        if args.action == "encrypt":
            encryptor = FileEncryptorDecryptor(key)
            encryptor.encrypt_file(str(input_path), str(output_path))
        else:
            decryptor = FileEncryptorDecryptor(key)
            decryptor.decrypt_file(str(input_path), str(output_path))

if __name__ == "__main__":
    main()

```javascript
// Dynamic Weather Particle Studio for RPG Maker MZ
// Runs as a Node.js command-line tool for generating weather/particle effects

import readline from 'readline';
import { createInterface } from 'readline/promises';
import fs from 'fs/promises';
import path from 'path';

// RPG Maker MZ Weather/Particle effect template
const baseTemplate = (effectName, params) => {
    const {
        type, // 'rain', 'snow', 'spark', 'leaf', 'water', 'smoke', 'custom'
        color, // [r, g, b] or hex string
        speed, // base speed (0-10)
        gravity, // gravity strength (0-5)
        scale, // scale (0.5-2.0)
        count, // number of particles (10-200)
        life, // particle life (30-300 frames)
        opacity, // initial opacity (0-255)
        blend, // 'normal' | 'add' | 'multiply' | 'screen'
        speedVariation, // speed variation (0-0.5)
        angle, // base angle (0-360)
        angleVariation, // angle variation (0-60)
        scaleVariation, // scale variation (0-0.5)
        customParams = {} // additional custom parameters for custom types
    } = params;

    const colorStr = typeof color === 'string' ? color : `Color(${color.join(', ')})`;

    return `// ${effectName} - RPG Maker MZ Weather/Particle Effect\n` +
        `\n` +
        `const create${effectName}Effect = function(scene) {\n` +
        `    const weatherType = new RPG.MweatherType();\n` +
        `    const particles = new RPG.MparticleGenerator();\n` +
        `    \n` +
        `    // Configure weather type\n` +
        `    weatherType.type = RPG.MweatherType.${type.toUpperCase()};\n` +
        `    weatherType.r = ${color[0] || 0};\n` +
        `    weatherType.g = ${color[1] || 0};\n` +
        `    weatherType.b = ${color[2] || 0};\n` +
        `    weatherType.a = ${opacity};\n` +
        `    weatherType.speed = ${speed};\n` +
        `    weatherType.gravity = ${gravity};\n` +
        `    weatherType.multiplier = ${scale};\n` +
        `    \n` +
        `    // Configure particle generator\n` +
        `    particles.type = RPG.MparticleGenerator.${type.toUpperCase()};\n` +
        `    particles.r = ${color[0] || 0};\n` +
        `    particles.g = ${color[1] || 0};\n` +
        `    particles.b = ${color[2] || 0};\n` +
        `    particles.a = ${opacity};\n` +
        `    particles.speed = ${speed};\n` +
        `    particles.speedRand = ${speedVariation};\n` +
        `    particles.gravity = ${gravity};\n` +
        `    particles.multiplier = ${scale};\n` +
        `    particles.multiplierRand = ${scaleVariation};\n` +
        `    particles.repeat = ${count};\n` +
        `    particles.life = ${life};\n` +
        `    particles.angle = ${angle};\n` +
        `    particles.angleRand = ${angleVariation};\n` +
        `    particles.blend = RPG.MblendType.${blend.toUpperCase()};\n` +
        `    \n` +
        `    // Custom parameters (if any)\n` +
        `${Object.entries(customParams).map(([key, value]) => `\n    particles.${key} = ${value};`).join('')}\n` +
        `    \n` +
        `    // Add to scene\n` +
        `    scene.addChild(weatherType);\n` +
        `    scene.addChild(particles);\n` +
        `};\n` +
        `export default create${effectName}Effect;`;
};

// Interactive CLI with live preview
class ParticleStudio {
    constructor() {
        this.rl = createInterface({
            input: process.stdin,
            output: process.stdout
        });
        this.effectName = '';
        this.params = {
            type: 'rain',
            color: [100, 100, 255], // blue
            speed: 2,
            gravity: 0.5,
            scale: 1,
            count: 50,
            life: 100,
            opacity: 200,
            blend: 'add',
            speedVariation: 0.1,
            angle: 90,
            angleVariation: 20,
            scaleVariation: 0.1,
            customParams: {}
        };
    }

    async run() {
        console.log('\n🌦️  Dynamic Weather Particle Studio for RPG Maker MZ  🌦️');
        console.log('-------------------------------------------------------');
        console.log('Generate custom weather/particle effects with interactive controls.');
        console.log('Press Ctrl+C to exit.\n');

        await this.initEffectName();
        await this.mainMenu();
    }

    async initEffectName() {
        this.effectName = (await this.rl.question('Enter effect name (e.g., "MagicalRain"): ')).trim() || 'CustomEffect';
    }

    async mainMenu() {
        while (true) {
            console.log('\n===== MAIN MENU =====');
            console.log('1. Basic Parameters');
            console.log('2. Advanced Controls');
            console.log('3. Custom Parameters');
            console.log('4. Preview Current Effect');
            console.log('5. Export to RPG Maker MZ Plugin');
            console.log('6. Save Current Configuration');
            console.log('7. Load Configuration');
            console.log('8. Reset to Defaults');
            console.log('9. Exit');

            const choice = await this.rl.question('\nSelect an option: ');

            switch (choice) {
                case '1':
                    await this.basicParamsMenu();
                    break;
                case '2':
                    await this.advancedMenu();
                    break;
                case '3':
                    await this.customParamsMenu();
                    break;
                case '4':
                    this.previewEffect();
                    break;
                case '5':
                    await this.exportEffect();
                    break;
                case '6':
                    await this.saveConfig();
                    break;
                case '7':
                    await this.loadConfig();
                    break;
                case '8':
                    this.resetParams();
                    console.log('✅ Parameters reset to default!');
                    break;
                case '9':
                    console.log('👋 Goodbye!');
                    process.exit(0);
                default:
                    console.log('❌ Invalid choice. Please try again.');
            }
        }
    }

    async basicParamsMenu() {
        console.log('\n===== BASIC PARAMETERS =====');
        console.log(`Type: ${this.params.type} (rain/snow/spark/leaf/water/smoke/custom)`);
        console.log(`Color: ${this.params.color} (r,g,b or hex)`);
        console.log(`Speed: ${this.params.speed} (0-10)`);
        console.log(`Gravity: ${this.params.gravity} (0-5)`);
        console.log(`Scale: ${this.params.scale} (0.5-2.0)`);
        console.log(`Particle Count: ${this.params.count} (10-200)`);
        console.log(`Life: ${this.params.life} (30-300)`);
        console.log(`Opacity: ${this.params.opacity} (0-255)`);
        console.log(`Blend Mode: ${this.params.blend}`);

        const choice = await this.rl.question('\nSelect parameter to edit (1-9) or 0 to return: ');

        switch (choice) {
            case '1':
                this.params.type = await this.rl.question('Enter type (rain/snow/spark/leaf/water/smoke/custom): ') || 'rain';
                if (!['rain', 'snow', 'spark', 'leaf', 'water', 'smoke', 'custom'].includes(this.params.type)) {
                    console.log('❌ Invalid type. Using default: rain');
                    this.params.type = 'rain';
                }
                break;
            case '2':
                const colorInput = await this.rl.question('Enter color (r,g,b or hex, e.g., 100,100,255 or #6495ED): ');
                const colorParts = colorInput.split(',');
                if (colorParts.length === 3) {
                    this.params.color = colorParts.map(p => parseInt(p.trim()) || 0);
                } else if (colorInput.startsWith('#')) {
                    this.params.color = this.hexToRgb(colorInput);
                } else {
                    console.log('❌ Invalid color format. Using default: [100, 100, 255]');
                    this.params.color = [100, 100, 255];
                }
                break;
            case '3':
                this.params.speed = parseFloat(await this.rl.question('Enter speed (0-10): ') || '2');
                this.params.speed = Math.max(0, Math.min(10, this.params.speed));
                break;
            case '4':
                this.params.gravity = parseFloat(await this.rl.question('Enter gravity (0-5): ') || '0.5');
                this.params.gravity = Math.max(0, Math.min(5, this.params.gravity));
                break;
            case '5':
                this.params.scale = parseFloat(await this.rl.question('Enter scale (0.5-2.0): ') || '1');
                this.params.scale = Math.max(0.5, Math.min(2.0, this.params.scale));
                break;
            case '6':
                this.params.count = parseInt(await this.rl.question('Enter particle count (10-200): ') || '50');
                this.params.count = Math.max(10, Math.min(200, this.params.count));
                break;
            case '7':
                this.params.life = parseInt(await this.rl.question('Enter particle life (30-300): ') || '100');
                this.params.life = Math.max(30, Math.min(300, this.params.life));
                break;
            case '8':
                this.params.opacity = parseInt(await this.rl.question('Enter opacity (0-255): ') || '200');
                this.params.opacity = Math.max(0, Math.min(255, this.params.opacity));
                break;
            case '9':
                this.params.blend = await this.rl.question('Enter blend mode (normal/add/multiply/screen): ') || 'add';
                if (!['normal', 'add', 'multiply', 'screen'].includes(this.params.blend)) {
                    console.log('❌ Invalid blend mode. Using default: add');
                    this.params.blend = 'add';
                }
                break;
            case '0':
                return;
            default:
                console.log('❌ Invalid choice.');
        }
        console.log('✅ Parameter updated!');
    }

    async advancedMenu() {
        console.log('\n===== ADVANCED CONTROLS =====');
        console.log(`Speed Variation: ${this.params.speedVariation} (0-0.5)`);
        console.log(`Angle: ${this.params.angle} (0-360)`);
        console.log(`Angle Variation: ${this.params.angleVariation} (0-60)`);
        console.log(`Scale Variation: ${this.params.scaleVariation} (0-0.5)`);

        const choice = await this.rl.question('\nSelect parameter to edit (1-4) or 0 to return: ');

        switch (choice) {
            case '1':
                this.params.speedVariation = parseFloat(await this.rl.question('Enter speed variation (0-0.5): ') || '0.1');
                this.params.speedVariation = Math.max(0, Math.min(0.5, this.params.speedVariation));
                break;
            case '2':
                this.params.angle = parseInt(await this.rl.question('Enter angle (0-360): ') || '90');
                this.params.angle = this.params.angle % 360;
                break;
            case '3':
                this.params.angleVariation = parseInt(await this.rl.question('Enter angle variation (0-60): ') || '20');
                this.params.angleVariation = Math.max(0, Math.min(60, this.params.angleVariation));
                break;
            case '4':
                this.params.scaleVariation = parseFloat(await this.rl.question('Enter scale variation (0-0.5): ') || '0.1');
                this.params.scaleVariation = Math.max(0, Math.min(0.5, this.params.scaleVariation));
                break;
            case '0':
                return;
            default:
                console.log('❌ Invalid choice.');
        }
        console.log('✅ Parameter updated!');
    }

    async customParamsMenu() {
        console.log('\n===== CUSTOM PARAMETERS =====');
        console.log('For custom effect types or special behaviors. Use "key=value" pairs.');
        console.log('Example: "accel=0.1,rotation=45,rotationRandom=10"');

        const input = await this.rl.question('Enter custom parameters (or leave blank to clear): ');

        if (input.trim() === '') {
            this.params.customParams = {};
            console.log('✅ Custom parameters cleared!');
        } else {
            const pairs = input.split(',');
            const newParams = {};

            for (const pair of pairs) {
                const [key, value] = pair.split('=');
                if (key && value) {
                    // Try to parse number if possible
                    const numValue = parseFloat(value);
                    newParams[key.trim()] = isNaN(numValue) ? value.trim() : numValue;
                }
            }

            this.params.customParams = { ...newParams };
            console.log('✅ Custom parameters updated!');
        }
    }

    previewEffect() {
        console.log('\n🎨  PREVIEWING EFFECT  🎨');
        console.log('Effect Name:', this.effectName);
        console.log('Type:', this.params.type);
        console.log('Color:', this.params.color);
        console.log('Speed:', this.params.speed);
        console.log('Gravity:', this.params.gravity);
        console.log('Scale:', this.params.scale);
        console.log('Count:', this.params.count);
        console.log('Life:', this.params.life);
        console.log('Opacity:', this.params.opacity);
        console.log('Blend Mode:', this.params.blend);
        console.log('Speed Variation:', this.params.speedVariation);
        console.log('Angle:', this.params.angle);
        console.log('Angle Variation:', this.params.angleVariation);
        console.log('Scale Variation:', this.params.scaleVariation);
        console.log('Custom Parameters:', Object.entries(this.params.customParams).length > 0 ?
            JSON.stringify(this.params.customParams, null, 2) : 'None');

        // Simple ASCII preview
        const chars = ['•', '◐', '◑', '◒', '◓'];
        const previewLine = chars[Math.floor(Math.random() * chars.length)].repeat(this.params.count);
        console.log('\nPreview (simplified):');
        console.log('  ' + previewLine.split('').map(c => c.padEnd(2)).join(' '));
        console.log('  ' + previewLine.split('').map(c => c.padEnd(2)).join(' '));
        console.log('  ' + previewLine.split('').map(c => c.padEnd(2)).join(' '));
    }

    async exportEffect() {
        const effectCode = baseTemplate(this.effectName, this.params);
        const filePath = path.join(process.cwd(), `${this.effectName}.js`);

        try {
            await fs.writeFile(filePath, effectCode);
            console.log('✅ Effect exported successfully to:', filePath);
            console.log('You can now import this file into your RPG Maker MZ project.');
            console.log('Note: Make sure to follow RPG Maker MZ plugin naming conventions.');
        } catch (err) {
            console.error('❌ Error exporting effect:', err.message);
        }
    }

    async saveConfig() {
        const config = {
            effectName: this.effectName,
            params: this.params
        };
        const filePath = path.join(process.cwd(), 'particle_studio_config.json');

        try {
            await fs.writeFile(filePath, JSON.stringify(config, null, 2));
            console.log('✅ Configuration saved to:', filePath);
        } catch (err) {
            console.error('❌ Error saving configuration:', err.message);
        }
    }

    async loadConfig() {
        const filePath = path.join(process.cwd(), 'particle_studio_config.json');

        try {
            const data = await fs.readFile(filePath, 'utf8');
            const config = JSON.parse(data);

            if (config.effectName) {
                this.effectName = config.effectName;
                console.log('✅ Effect name loaded:', this.effect

<?php
/**
 * Plugin Name: Creative Projects with Interactive Meta Boxes
 * Description: A WordPress plugin that creates a 'Creative Projects' custom post type with interactive meta boxes for visual pins and comments.
 * Version: 1.0
 * Author: Ailey
 * License: GPL2
 */

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

class Creative_Projects_Interactive_Meta_Boxes {
    public function __construct() {
        // Register custom post type
        add_action('init', [$this, 'register_custom_post_type']);

        // Add meta boxes
        add_action('add_meta_boxes', [$this, 'add_meta_boxes']);

        // Save meta box data
        add_action('save_post', [$this, 'save_meta_box_data']);

        // Enqueue scripts and styles
        add_action('admin_enqueue_scripts', [$this, 'enqueue_scripts']);

        // Add AJAX handlers for interactive features
        add_action('wp_ajax_save_pin', [$this, 'save_pin']);
        add_action('wp_ajax_add_comment', [$this, 'add_comment']);

        // Shortcode for displaying pins
        add_shortcode('creative_projects_pins', [$this, 'display_pins_shortcode']);
    }

    public function register_custom_post_type() {
        $args = array(
            'label'               => 'Creative Projects',
            'public'              => true,
            'publicly_queryable'  => true,
            'show_ui'             => true,
            'show_in_menu'        => true,
            'query_var'           => true,
            'rewrite'             => array('slug' => 'creative-projects'),
            'capability_type'     => 'post',
            'has_archive'         => true,
            'hierarchical'        => false,
            'menu_position'       => null,
            'supports'            => array('title', 'editor', 'thumbnail', 'excerpt', 'custom-fields'),
            'show_in_rest'        => true,
        );
        register_post_type('creative_projects', $args);
    }

    public function add_meta_boxes() {
        add_meta_box(
            'interactive_pins_meta_box',
            'Interactive Pins',
            [$this, 'render_interactive_pins_meta_box'],
            'creative_projects',
            'normal',
            'high'
        );
    }

    public function render_interactive_pins_meta_box($post) {
        wp_nonce_field('interactive_pins_nonce', 'interactive_pins_nonce');

        // Get existing pins
        $pins = get_post_meta($post->ID, 'creative_projects_pins', true);
        if (empty($pins)) {
            $pins = array();
        }

        echo '<div class="interactive-pins-container">';
        echo '<div class="pins-grid" id="pins-grid-' . $post->ID . '">';

        foreach ($pins as $pin) {
            echo '<div class="pin" draggable="true" data-pin-id="' . esc_attr($pin['id']) . '">';
            echo '<img src="' . esc_url($pin['image']) . '" alt="' . esc_attr($pin['title']) . '">';
            echo '<div class="pin-comments">';
            $comments = $pin['comments'] ?? array();
            foreach ($comments as $comment) {
                echo '<div class="comment">' . esc_html($comment) . '</div>';
            }
            echo '</div>';
            echo '</div>';
        }

        echo '</div>';
        echo '<div class="pin-form">';
        echo '<input type="hidden" id="pin-image-url-' . $post->ID . '" value="">';
        echo '<input type="text" id="pin-title-' . $post->ID . '" placeholder="Pin Title" style="display: none;">';
        echo '<button id="add-pin-button-' . $post->ID . '" class="button">Add Pin</button>';
        echo '</div>';
        echo '</div>';

        $this->enqueue_interactive_scripts($post->ID);
    }

    public function save_meta_box_data($post_id) {
        if (!isset($_POST['interactive_pins_nonce']) || !wp_verify_nonce($_POST['interactive_pins_nonce'], 'interactive_pins_nonce')) {
            return;
        }

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

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

        // Simulate saving pins (in a real scenario, this would be handled via AJAX)
        $pins = array();
        if (isset($_POST['pins'])) {
            $pins = json_decode($_POST['pins'], true);
        }
        update_post_meta($post_id, 'creative_projects_pins', $pins);
    }

    public function enqueue_scripts($hook) {
        if ($hook !== 'post-new.php' && $hook !== 'post.php') {
            return;
        }

        // CSS for the meta box
        wp_enqueue_style('creative-projects-interactive-styles', plugins_url('css/creative-projects-interactive.css', __FILE__));

        // JavaScript for the meta box
        wp_enqueue_script('jquery-ui-core');
        wp_enqueue_script('jquery-ui-draggable');
        wp_enqueue_script('creative-projects-interactive', plugins_url('js/creative-projects-interactive.js', __FILE__), array('jquery', 'jquery-ui-draggable'), '1.0', true);

        wp_localize_script('creative-projects-interactive', 'creativeProjectsData', array(
            'ajaxurl' => admin_url('admin-ajax.php'),
            'nonce' => wp_create_nonce('interactive_pins_nonce'),
        ));
    }

    public function enqueue_interactive_scripts($post_id) {
        wp_enqueue_script('jquery-ui-core');
        wp_enqueue_script('jquery-ui-draggable');
        wp_enqueue_script('creative-projects-interactive', plugins_url('js/creative-projects-interactive.js', __FILE__), array('jquery', 'jquery-ui-draggable'), '1.0', true);

        wp_localize_script('creative-projects-interactive', 'creativeProjectsData', array(
            'ajaxurl' => admin_url('admin-ajax.php'),
            'nonce' => wp_create_nonce('interactive_pins_nonce'),
            'post_id' => $post_id,
        ));
    }

    public function save_pin() {
        if (!isset($_POST['nonce']) || !wp_verify_nonce($_POST['nonce'], 'interactive_pins_nonce')) {
            wp_send_json_error('Invalid nonce.');
        }

        if (!current_user_can('edit_post', $_POST['post_id'])) {
            wp_send_json_error('Unauthorized action.');
        }

        $post_id = intval($_POST['post_id']);
        $pin_id = uniqid();
        $image_url = esc_url_raw($_POST['image_url']);
        $title = sanitize_text_field($_POST['title']);

        $pins = get_post_meta($post_id, 'creative_projects_pins', true);
        if (empty($pins)) {
            $pins = array();
        }

        $new_pin = array(
            'id' => $pin_id,
            'image' => $image_url,
            'title' => $title,
            'comments' => array(),
        );

        $pins[] = $new_pin;
        update_post_meta($post_id, 'creative_projects_pins', $pins);

        wp_send_json_success(array('pin' => $new_pin, 'pins' => $pins));
    }

    public function add_comment() {
        if (!isset($_POST['nonce']) || !wp_verify_nonce($_POST['nonce'], 'interactive_pins_nonce')) {
            wp_send_json_error('Invalid nonce.');
        }

        if (!current_user_can('edit_post', $_POST['post_id'])) {
            wp_send_json_error('Unauthorized action.');
        }

        $post_id = intval($_POST['post_id']);
        $pin_id = sanitize_text_field($_POST['pin_id']);
        $comment = sanitize_text_field($_POST['comment']);

        $pins = get_post_meta($post_id, 'creative_projects_pins', true);
        if (empty($pins)) {
            $pins = array();
        }

        foreach ($pins as &$pin) {
            if ($pin['id'] === $pin_id) {
                $pin['comments'][] = $comment;
                break;
            }
        }

        update_post_meta($post_id, 'creative_projects_pins', $pins);

        wp_send_json_success(array('pin' => end($pins), 'pins' => $pins));
    }

    public function display_pins_shortcode($atts) {
        ob_start();
        echo '<div class="creative-projects-pins-container">';
        echo do_shortcode('[creative_projects_pins]');
        echo '</div>';
        return ob_get_clean();
    }
}

// Initialize the plugin
new Creative_Projects_Interactive_Meta_Boxes();

// Create necessary directories if they don't exist
function create_plugin_directories() {
    $base_dir = plugin_dir_path(__FILE__);
    $css_dir = $base_dir . 'css/';
    $js_dir = $base_dir . 'js/';

    if (!file_exists($css_dir)) {
        wp_mkdir_p($css_dir);
    }

    if (!file_exists($js_dir)) {
        wp_mkdir_p($js_dir);
    }
}
register_activation_hook(__FILE__, 'create_plugin_directories');

// Create default CSS and JS files if they don't exist
function create_default_files() {
    $base_dir = plugin_dir_path(__FILE__);

    $css_file = $base_dir . 'css/creative-projects-interactive.css';
    $js_file = $base_dir . 'js/creative-projects-interactive.js';

    if (!file_exists($css_file)) {
        file_put_contents($css_file, $this->get_default_css());
    }

    if (!file_exists($js_file)) {
        file_put_contents($js_file, $this->get_default_js());
    }
}

// Helper functions to create default files
function get_default_css() {
    return '
.interactive-pins-container {
    margin: 20px 0;
}

.pins-grid {
    min-height: 300px;
    border: 2px dashed #ddd;
    padding: 10px;
    margin-bottom: 10px;
}

.pin {
    width: 100px;
    height: 100px;
    background: #f9f9f9;
    border: 1px solid #ddd;
    margin: 5px;
    padding: 5px;
    display: inline-block;
    position: relative;
    cursor: move;
}

.pin img {
    width: 100%;
    height: 80px;
    object-fit: cover;
    border-radius: 4px;
}

.pin-comments {
    margin-top: 5px;
    max-height: 100px;
    overflow-y: auto;
    border-top: 1px solid #eee;
    padding: 5px;
}

.comment {
    margin-bottom: 3px;
    font-size: 12px;
    color: #555;
}

.pin-form {
    margin-top: 10px;
}

.pin-form input[type="text"] {
    padding: 5px;
    margin-right: 5px;
}

.pin-form button {
    padding: 5px 10px;
    background: #2271b1;
    color: white;
    border: none;
    cursor: pointer;
}
';
}

function get_default_js() {
    return '
jQuery(document).ready(function($) {
    var postId = creativeProjectsData.post_id;
    var nonce = creativeProjectsData.nonce;

    // Make pins draggable
    $(".pin").draggable({
        revert: true,
        cursor: "move"
    });

    // Add pin functionality
    $("#add-pin-button-" + postId).on("click", function() {
        var imageUrl = $("#pin-image-url-" + postId).val();
        var title = $("#pin-title-" + postId).val();

        if (!imageUrl) {
            alert("Please upload an image first.");
            return;
        }

        $.ajax({
            url: creativeProjectsData.ajaxurl,
            type: "POST",
            data: {
                action: "save_pin",
                post_id: postId,
                image_url: imageUrl,
                title: title,
                nonce: nonce
            },
            success: function(response) {
                if (response.success) {
                    $("#pins-grid-" + postId).append(
                        "<div class=\"pin\" draggable=\"true\" data-pin-id=\"" + response.data.pin.id + "\">" +
                        "<img src=\"" + response.data.pin.image + "\" alt=\"" + response.data.pin.title + "\">" +
                        "<div class=\"pin-comments\"></div>" +
                        "</div>"
                    );
                    $("#pin-image-url-" + postId).val("");
                    $("#pin-title-" + postId).val("");
                } else {
                    alert(response.data);
                }
            }
        });
    });

    // Add comment functionality
    function addCommentToPin(pinId, comment) {
        $.ajax({
            url: creativeProjectsData.ajaxurl,
            type: "POST",
            data: {
                action: "add_comment",
                post_id: postId,
                pin_id: pinId,
                comment: comment,
                nonce: nonce
            },
            success: function(response) {
                if (response.success) {
                    $("div.pin[data-pin-id='" + pinId + "'] .pin-comments").append(
                        "<div class=\"comment\">" + response.data.pin.comments[response.data.pin.comments.length - 1] + "</div>"
                    );
                } else {
                    alert(response.data);
                }
            }
        });
    }

    // Example: Add a button to add comments (for demonstration)
    $(".pin").on("dblclick", function() {
        var pinId = $(this).data("pin-id");
        var comment = prompt("Add a comment:");
        if (comment) {
            addCommentToPin(pinId, comment);
        }
    });
});
';
}

// Register activation and deactivation hooks
register_activation_hook(__FILE__, function() {
    if (!file_exists(plugin_dir_path(__FILE__) . 'css/')) {
        wp_mkdir_p(plugin_dir_path(__FILE__) . 'css/');
    }
    if (!file_exists(plugin_dir_path(__FILE__) . 'js/')) {
        wp_mkdir_p(plugin_dir_path(__FILE__) . 'js/');
    }
    if (!file_exists(plugin_dir_path(__FILE__) . 'css/creative-projects-interactive.css')) {
        file_put_contents(
            plugin_dir_path(__FILE__) . 'css/creative-projects-interactive.css',
            get_default_css()
        );
    }
    if (!file_exists(plugin_dir_path(__FILE__) . 'js/creative-projects-interactive.js')) {
        file_put_contents(
            plugin_dir_path(__FILE__) . 'js/creative-projects-interactive.js',
            get_default_js()
        );
    }
});

// FocusFlow - Pomodoro with Adaptive Breeze
// A modern Pomodoro timer with adaptive soundscapes and unique focus techniques

import android.media.MediaPlayer
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Pause
import androidx.compose.material.icons.filled.PlayArrow
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Slider
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.zIndex
import kotlinx.coroutines.delay
import java.util.concurrent.TimeUnit

@Composable
fun FocusFlowApp() {
    MaterialTheme {
        Surface(
            modifier = Modifier.fillMaxSize(),
            color = MaterialTheme.colorScheme.background
        ) {
            FocusFlowTimer()
        }
    }
}

@Composable
fun FocusFlowTimer() {
    var timeLeft by remember { mutableStateOf(25 * 60 * 1000L) } // 25 minutes in milliseconds
    var isRunning by remember { mutableStateOf(false) }
    var currentMode by remember { mutableStateOf("Focus") }
    var mediaPlayer: MediaPlayer? by remember { mutableStateOf(null) }
    var sliderValue by remember { mutableStateOf(25f) }
    var activeProgress by remember { mutableStateOf(0f) }
    val totalDuration = 25 * 60 * 1000L

    LaunchedEffect(isRunning) {
        if (isRunning) {
            var remainingTime = timeLeft
            while (remainingTime > 0) {
                delay(100)
                remainingTime -= 100
                timeLeft = remainingTime
                activeProgress = (1 - (remainingTime.toFloat() / totalDuration.toFloat())).coerceIn(0f, 1f)

                if (remainingTime <= 0) {
                    isRunning = false
                    currentMode = if (currentMode == "Focus") "Break" else "Focus"
                    timeLeft = if (currentMode == "Break") 5 * 60 * 1000L else 25 * 60 * 1000L
                    playAmbientSound(currentMode)
                    break
                }
            }
        }
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        // Timer Display
        Box(
            modifier = Modifier.fillMaxWidth(),
            contentAlignment = Alignment.Center
        ) {
            Text(
                text = "${(timeLeft / 1000 / 60).toInt().toString().padStart(2, '0')}:${(timeLeft / 1000 % 60).toInt().toString().padStart(2, '0')}",
                fontSize = 64.sp,
                fontWeight = FontWeight.Bold,
                color = MaterialTheme.colorScheme.primary,
                textAlign = TextAlign.Center
            )

            // Adaptive progress circle
            Canvas(
                modifier = Modifier
                    .size(200.dp)
                    .zIndex(-1f)
            ) {
                drawCircle(
                    color = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.2f),
                    radius = size.minDimension / 2,
                    center = center
                )
                drawArc(
                    color = MaterialTheme.colorScheme.secondary,
                    startAngle = -90f,
                    sweep = 360 * activeProgress,
                    useCenter = false,
                    size = size,
                    style = Stroke(width = 8.dp.toPx())
                )
            }
        }

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

        // Mode indicator
        Row(
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.Center
        ) {
            Icon(
                painter = painterResource(id = R.drawable.ic_focus),
                contentDescription = null,
                tint = if (currentMode == "Focus") MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurface.copy(alpha = 0.3f)
            )
            Text(
                text = currentMode,
                modifier = Modifier.padding(start = 8.dp),
                fontWeight = FontWeight.Medium,
                color = if (currentMode == "Focus") MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurface.copy(alpha = 0.3f)
            )
        }

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

        // Control buttons
        Row(
            horizontalArrangement = Arrangement.Center,
            verticalAlignment = Alignment.CenterVertically
        ) {
            IconButton(
                onClick = {
                    if (!isRunning) {
                        isRunning = true
                        playAmbientSound(currentMode)
                    }
                }
            ) {
                Icon(
                    imageVector = if (isRunning) Icons.Default.Pause else Icons.Default.PlayArrow,
                    contentDescription = if (isRunning) "Pause" else "Start"
                )
            }

            IconButton(
                onClick = {
                    if (isRunning) {
                        isRunning = false
                        mediaPlayer?.pause()
                    } else {
                        isRunning = true
                        playAmbientSound(currentMode)
                    }
                }
            ) {
                Icon(
                    imageVector = Icons.Default.Refresh,
                    contentDescription = "Reset"
                )
            }
        }

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

        // Customization slider
        Column(
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            Text(
                text = "Work: ${sliderValue.toInt()} min",
                color = MaterialTheme.colorScheme.onSurface
            )
            Slider(
                value = sliderValue,
                onValueChange = { newValue ->
                    sliderValue = newValue.coerceIn(15f, 60f)
                    timeLeft = (sliderValue.toInt() * 60 * 1000L).coerceAtLeast(15 * 60 * 1000L)
                },
                valueRange = 15f..60f
            )
        }
    }
}

private fun playAmbientSound(mode: String) {
    val mediaPlayer = MediaPlayer.create(
        android.app.Application/applicationContext,
        when (mode) {
            "Focus" -> R.raw.focus_soundscape
            else -> R.raw.break_soundscape
        }
    )
    mediaPlayer.isLooping = true
    mediaPlayer.start()
}

@Composable
fun TimerPreview() {
    FocusFlowApp()
}