A!leys Galerie

#!/usr/bin/env python3
"""
PIXEL-MORPH — Intelligenter Batch-Image-Resizer mit Qualitätpräsentationen.

Features:
- 5 intelligente Qualitätpräsentationen (Standard, Portrait, Display, Print, Web)
- Automatische Kontrast-, Schärfe- und Farbverlaufs-Optimierung
- Parallelverarbeitung für schnelle Batch-Verarbeitung
- Progress-Balken für visuelle Rückmeldung
- Support für PNG, JPEG, HEIF, WebP
"""

import os
import sys
import math
import argparse
import concurrent.futures
from typing import List, Tuple, Dict, Optional
from PIL import Image, ImageEnhance, ImageFilter, ImageOps
from tqdm import tqdm
import platform

# Qualitätpräsentationen mit automatischen Parametern
QUALITY_PRESETS = {
    "Standard": {"width": 1920, "height": 1080, "contrast": 1.1, "sharpness": 1.2, "adjust_brightness": 0.1},
    "Portrait": {"width": 1080, "height": 1920, "contrast": 1.05, "sharpness": 1.15, "adjust_brightness": 0.05},
    "Display": {"width": 2560, "height": 1600, "contrast": 1.2, "sharpness": 1.3, "adjust_brightness": 0.05},
    "Print": {"width": 3000, "height": 3000, "contrast": 1.0, "sharpness": 1.1, "adjust_brightness": 0.0},
    "Web": {"width": 1280, "height": 720, "contrast": 1.15, "sharpness": 1.25, "adjust_brightness": 0.05}
}

# Unterstützte Dateitypen
SUPPORTED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".heif", ".webp"}

def adjust_image_quality(image: Image.Image, preset: Dict) -> Image.Image:
    """
    Optimiert ein Bild basierend auf der Qualitätpräsentation.

    Args:
        image: PIL Image Object
        preset: Qualitätpräsentation mit Parametern

    Returns:
        Optimiertes PIL Image Object
    """
    # Automatische Helligkeitsanpassung basierend auf Kontrastpräsentation
    if preset["contrast"] > 1.1:
        adj_brightness = ImageEnhance.Brightness(image).enhance(1 + preset["adjust_brightness"])
    else:
        adj_brightness = image

    # Automatische Schärfeanpassung
    if preset["sharpness"] > 1.2:
        adj_sharpness = ImageEnhance.Sharpness(adj_brightness).enhance(preset["sharpness"])
    else:
        adj_sharpness = adj_brightness

    # Automatischer Kontrast (nur wenn signifikant)
    if preset["contrast"] > 1.05:
        adj_contrast = ImageEnhance.Contrast(adj_sharpness).enhance(preset["contrast"])
    else:
        adj_contrast = adj_sharpness

    return adj_contrast

def resize_image(image_path: str, output_path: str, preset: Dict) -> None:
    """
    Resizt ein Bild und optimiert die Qualität.

    Args:
        image_path: Pfad zur Eingabedatei
        output_path: Pfad zur Ausgabedatei
        preset: Qualitätpräsentation
    """
    try:
        with Image.open(image_path) as img:
            # Automatische Rotationskorrektur
            if img.info.get("orientation"):
                img = ImageOps.exif_transpose(img)

            # Qualität optimieren
            adjusted_img = adjust_image_quality(img, preset)

            # Automatische Skalierung
            img_width, img_height = adjusted_img.size
            target_width, target_height = preset["width"], preset["height"]

            # Berechne Skalierungsfaktor
            width_ratio = target_width / img_width
            height_ratio = target_height / img_height
            scale_factor = min(width_ratio, height_ratio)

            # Resizen mit Anti-Aliasing
            new_size = (int(img_width * scale_factor), int(img_height * scale_factor))
            resized_img = adjusted_img.resize(new_size, Image.LANCZOS)

            # Automatische Qualitätsanpassung basierend auf Dateityp
            if image_path.lower().endswith(".png"):
                resized_img.save(output_path, optimize=True, quality=95)
            elif image_path.lower().endswith(".heif"):
                resized_img.save(output_path, "HEIF", quality=90)
            else:
                resized_img.save(output_path, "JPEG", quality=95)

    except Exception as e:
        print(f"Fehler beim Verarbeiten von {image_path}: {str(e)}")

def process_directory(input_dir: str, output_dir: str, preset_name: str) -> int:
    """
    Verarbeitet ein Verzeichnis mit Bildern.

    Args:
        input_dir: Eingabeverzeichnis
        output_dir: Ausgabeverzeichnis
        preset_name: Name der Qualitätpräsentation

    Returns:
        Anzahl der verarbeiteten Bilder
    """
    if preset_name not in QUALITY_PRESETS:
        print(f"Fehler: Qualitätpräsentation '{preset_name}' nicht gefunden.")
        return 0

    preset = QUALITY_PRESETS[preset_name]
    input_dir = os.path.abspath(input_dir)
    output_dir = os.path.abspath(output_dir)

    if not os.path.exists(input_dir):
        print(f"Fehler: Verzeichnis '{input_dir}' nicht gefunden.")
        return 0

    os.makedirs(output_dir, exist_ok=True)

    # Sammle alle Bilddateien
    image_paths = []
    for root, _, files in os.walk(input_dir):
        for file in files:
            ext = os.path.splitext(file)[1].lower()
            if ext in SUPPORTED_EXTENSIONS:
                image_paths.append(os.path.join(root, file))

    if not image_paths:
        print("Keine unterstützten Bilddateien gefunden.")
        return 0

    # Parallelverarbeitung mit Progress-Balken
    processed_count = 0
    with tqdm(total=len(image_paths), desc=f"Resizen mit {preset_name}") as pbar:
        with concurrent.futures.ThreadPoolExecutor() as executor:
            futures = []
            for image_path in image_paths:
                rel_path = os.path.relpath(image_path, input_dir)
                output_path = os.path.join(output_dir, rel_path)
                os.makedirs(os.path.dirname(output_path), exist_ok=True)
                futures.append(executor.submit(resize_image, image_path, output_path, preset))

            for future in concurrent.futures.as_completed(futures):
                try:
                    future.result()
                    processed_count += 1
                    pbar.update(1)
                except Exception as e:
                    print(f"Fehler beim Verarbeiten: {str(e)}")

    print(f"\nErfolgreich verarbeitet: {processed_count} Bilder")
    return processed_count

def main():
    """
    Haupteinstiegspunkt des Programms.
    """
    parser = argparse.ArgumentParser(description="PIXEL-MORPH — Intelligenter Batch-Image-Resizer")
    parser.add_argument("input_dir", help="Eingabeverzeichnis mit Bildern")
    parser.add_argument("output_dir", help="Ausgabeverzeichnis für resizte Bilder")
    parser.add_argument("--preset", choices=QUALITY_PRESETS.keys(), default="Standard",
                        help="Qualitätpräsentation auswählen (Standard, Portrait, Display, Print, Web)")
    parser.add_argument("--list-presets", action="store_true", help="Zeigt verfügbare Qualitätpräsentationen an")

    args = parser.parse_args()

    if args.list_presets:
        print("Verfügbare Qualitätpräsentationen:")
        for name, preset in QUALITY_PRESETS.items():
            print(f"  {name}: {preset['width']}x{preset['height']} (Contrast: {preset['contrast']}, Sharpness: {preset['sharpness']})")
        return

    process_directory(args.input_dir, args.output_dir, args.preset)

if __name__ == "__main__":
    main()

use reqwest;
use std::error::Error;
use std::fs;
use std::io::{self, Write};
use std::path::PathBuf;
use std::sync::Arc;
use tokio::sync::Semaphore;

// Easter Egg Zitat-Sammlungen
const EASTER_EGG_QUOTES: [&str; 3] = [
    "Every artist was first an amateur.",
    "The only way to do great work is to love what you do.",
    "Done is better than perfect.",
];

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let args: Vec<String> = std::env::args().collect();
    if args.len() != 2 {
        eprintln!("Usage: {} <path_to_markdown_file>", args[0]);
        std::process::exit(1);
    }

    let file_path = PathBuf::from(&args[1]);
    let content = fs::read_to_string(&file_path)
        .map_err(|e| io::Error::new(io::ErrorKind::NotFound, e))?;

    // Easter Egg: Wenn die Markdown-Datei eine bestimmte Zeile enthält
    if content.contains("🦄 RAINBOW MODE 🦄") {
        println!("\n🌈 RAINBOW MODE AKTIVIERT! 🌈");
        println!("{}", EASTER_EGG_QUOTES[rand::random::<usize>() % 3]);
        println!("Verlass mich nicht so schnell! 🐰💕");
    }

    let urls: Vec<String> = extract_markdown_links(&content);
    if urls.is_empty() {
        println!("Keine Links in der Markdown-Datei gefunden.");
        return Ok(());
    }

    println!("Finde {} Links in {}...", urls.len(), file_path.display());

    let semaphore = Arc::new(Semaphore::new(10)); // Limit concurrent requests to 10
    let mut checked_urls = Vec::new();

    for url in urls {
        let permit = semaphore.clone().acquire_owned().await?;
        let url_clone = url.clone();
        tokio::spawn(async move {
            let _permit = permit;
            let result = check_url(&url_clone).await;
            (url_clone, result)
        });
    }

    // Collect all results
    while checked_urls.len() < urls.len() {
        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
    }

    // Sort results by URL for consistent output
    let mut results: Vec<(String, Result<String, String>)> = checked_urls;
    results.sort_by(|a, b| a.0.cmp(&b.0));

    // Print results
    for (url, result) in results {
        match result {
            Ok(status) => println!("✅ {} - {}", url, status),
            Err(e) => println!("⚠️ {} - {}", url, e),
        }
    }

    Ok(())
}

fn extract_markdown_links(content: &str) -> Vec<String> {
    let mut links = Vec::new();
    for line in content.lines() {
        if line.starts_with("["){
            if let Some(start) = line.find('(') {
                if let Some(end) = line[start + 1..].find(')') {
                    if let Ok(url) = url::Url::parse(&line[start + 1..start + 1 + end]) {
                        links.push(url.as_str().to_string());
                    }
                }
            }
        }
    }
    links
}

async fn check_url(url: &str) -> Result<String, String> {
    let client = reqwest::Client::new();
    let response = match client.head(url).send().await {
        Ok(res) => res,
        Err(e) => return Err(format!("Connection failed: {}", e)),
    };

    let status = response.status();
    if !status.is_success() {
        return Err(format!("HTTP {} - {}", status, status.canonical_reason().unwrap_or("Unknown")));
    }

    Ok(format!("HTTP {} - {}", status, status.canonical_reason().unwrap_or("Success")))
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Ailey's Circular Pomodoro</title>
    <style>
        :root {
            --primary: #6c5ce7;
            --secondary: #a29bfe;
            --accent: #fd79a8;
            --dark: #2d3436;
            --light: #f5f6fa;
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Inter', sans-serif;
        }

        body {
            background: var(--light);
            color: var(--dark);
            min-height: 100vh;
            display: flex;
            flex-direction: column;
            align-items: center;
            justify-content: center;
            padding: 2rem;
        }

        .container {
            width: 100%;
            max-width: 800px;
            text-align: center;
            background: white;
            border-radius: 20px;
            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
            padding: 3rem;
            transition: all 0.3s ease;
        }

        .timer {
            position: relative;
            width: 300px;
            height: 300px;
            margin: 2rem auto;
        }

        .progress-circle {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            border-radius: 50%;
            background: conic-gradient(var(--primary) 0deg, var(--secondary) 360deg);
            border: 20px solid white;
            opacity: 0.7;
            transform: rotate(-90deg);
        }

        .progress-fill {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            border-radius: 50%;
            background: conic-gradient(var(--accent) 0deg, var(--primary) 0deg, var(--secondary) 360deg);
            border: 20px solid white;
            opacity: 0.9;
            transform: rotate(-90deg);
            transform-origin: 50% 50%;
            transition: all 0.5s ease;
        }

        .time {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            font-size: 4rem;
            font-weight: 700;
            color: var(--dark);
            z-index: 2;
        }

        .controls {
            display: flex;
            justify-content: center;
            gap: 1rem;
            margin-top: 2rem;
        }

        button {
            padding: 0.8rem 1.5rem;
            background: var(--primary);
            color: white;
            border: none;
            border-radius: 50px;
            font-size: 1rem;
            font-weight: 600;
            cursor: pointer;
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }

        button:hover {
            background: #5a4bd3;
            transform: translateY(-2px);
        }

        button:disabled {
            background: #a29bfe;
            cursor: not-allowed;
            transform: none;
        }

        .settings {
            margin-top: 2rem;
            padding-top: 1rem;
            border-top: 1px solid #eee;
        }

        .setting-item {
            margin: 0.8rem 0;
            display: flex;
            justify-content: center;
            align-items: center;
            gap: 1rem;
        }

        input {
            width: 60px;
            text-align: center;
            padding: 0.3rem;
            border: 1px solid #ddd;
            border-radius: 8px;
        }

        .loading {
            width: 100%;
            height: 300px;
            position: relative;
            overflow: hidden;
            border-radius: 50%;
            background: conic-gradient(
                var(--primary) 0deg,
                var(--secondary) 120deg,
                var(--accent) 240deg,
                var(--primary) 360deg
            );
            display: flex;
            justify-content: center;
            align-items: center;
            animation: loading 2s infinite linear;
        }

        .loader-dot {
            width: 20px;
            height: 20px;
            background: white;
            border-radius: 50%;
            position: absolute;
            box-shadow: 0 0 0 2px white;
        }

        .dot-1 { transform: rotate(0deg); }
        .dot-2 { transform: rotate(120deg); }
        .dot-3 { transform: rotate(240deg); }
        .dot-4 { transform: rotate(360deg); }

        .title {
            margin-bottom: 1rem;
            font-size: 2.5rem;
            font-weight: 700;
            color: var(--primary);
            text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.1);
        }

        .state {
            margin-top: 1rem;
            font-size: 1.2rem;
            font-weight: 600;
            color: #555;
        }

        @keyframes loading {
            0% { transform: rotate(0deg); }
            100% { transform: rotate(360deg); }
        }

        @font-face {
            font-family: 'Inter';
            src: url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
            font-weight: normal;
            font-style: normal;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1 class="title">Ailey's Circular Pomodoro</h1>

        <div id="loading" class="loading">
            <div class="loader-dot dot-1"></div>
            <div class="loader-dot dot-2"></div>
            <div class="loader-dot dot-3"></div>
            <div class="loader-dot dot-4"></div>
            <div style="position: absolute; color: white; font-weight: bold; font-size: 1.5rem;">Ailey's Pomodoro</div>
        </div>

        <div id="timer" style="display: none;">
            <div class="timer">
                <div class="progress-circle"></div>
                <div class="progress-fill" id="progressFill"></div>
                <div class="time" id="time">25:00</div>
            </div>

            <div class="controls">
                <button id="startBtn">Start</button>
                <button id="pauseBtn" disabled>Pause</button>
                <button id="resetBtn">Reset</button>
            </div>

            <div class="settings">
                <h3>Settings</h3>
                <div class="setting-item">
                    <span>Work:</span>
                    <input type="number" id="workInput" min="1" max="60" value="25">
                    <span>min</span>
                </div>
                <div class="setting-item">
                    <span>Break:</span>
                    <input type="number" id="breakInput" min="1" max="60" value="5">
                    <span>min</span>
                </div>
                <div class="setting-item">
                    <label>
                        <input type="checkbox" id="soundToggle">
                        Sound notifications
                    </label>
                </div>
                <div class="setting-item">
                    <label>
                        <input type="checkbox" id="autoToggle" checked>
                        Auto-switch to break
                    </label>
                </div>
            </div>

            <div class="state" id="state">Ready to start</div>
        </div>
    </div>

    <audio id="timerSound" src="https://assets.mixkit.co/sfx/preview/mixkit-alarm-digital-clock-beep-989.mp3"></audio>
    <audio id="doneSound" src="https://assets.mixkit.co/sfx/preview/mixkit-positive-notification-952.mp3"></audio>

    <script>
        document.addEventListener('DOMContentLoaded', function() {
            // Loading animation
            const loading = document.getElementById('loading');
            const timer = document.getElementById('timer');

            // Timer elements
            const timeElement = document.getElementById('time');
            const progressFill = document.getElementById('progressFill');
            const startBtn = document.getElementById('startBtn');
            const pauseBtn = document.getElementById('pauseBtn');
            const resetBtn = document.getElementById('resetBtn');
            const stateElement = document.getElementById('state');

            // Settings elements
            const workInput = document.getElementById('workInput');
            const breakInput = document.getElementById('breakInput');
            const soundToggle = document.getElementById('soundToggle');
            const autoToggle = document.getElementById('autoToggle');

            // Timer variables
            let timerInterval;
            let totalSeconds = 25 * 60; // Default 25 minutes
            let isRunning = false;
            let isWorkPeriod = true;
            let timeLeft = totalSeconds;

            // Initialize with settings
            function init() {
                workInput.addEventListener('change', updateWorkTime);
                breakInput.addEventListener('change', updateBreakTime);
                soundToggle.addEventListener('change', toggleSound);

                startBtn.addEventListener('click', startTimer);
                pauseBtn.addEventListener('click', pauseTimer);
                resetBtn.addEventListener('click', resetTimer);

                // Start loading animation
                setTimeout(() => {
                    loading.style.display = 'none';
                    timer.style.display = 'block';
                    startTimer(); // Start with a test run
                }, 2000);
            }

            function updateWorkTime() {
                const workMinutes = parseInt(workInput.value) || 25;
                totalSeconds = workMinutes * 60 + (parseInt(breakInput.value) || 5) * 60;
                resetTimer();
            }

            function updateBreakTime() {
                const breakMinutes = parseInt(breakInput.value) || 5;
                totalSeconds = (parseInt(workInput.value) || 25) * 60 + breakMinutes * 60;
                resetTimer();
            }

            function toggleSound() {
                const soundEnabled = soundToggle.checked;
                document.getElementById('timerSound').muted = !soundEnabled;
                document.getElementById('doneSound').muted = !soundEnabled;
            }

            function formatTime(seconds) {
                const mins = Math.floor(seconds / 60);
                const secs = seconds % 60;
                return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
            }

            function startTimer() {
                if (isRunning) return;

                isRunning = true;
                timeLeft = totalSeconds;
                stateElement.textContent = `Timer started - ${isWorkPeriod ? 'Work period' : 'Break period'}`;
                updateDisplay();

                timerInterval = setInterval(() => {
                    timeLeft--;
                    updateDisplay();

                    if (timeLeft <= 0) {
                        clearInterval(timerInterval);
                        isRunning = false;

                        if (autoToggle.checked && isWorkPeriod) {
                            // Auto-switch to break period
                            isWorkPeriod = false;
                            timeLeft = (parseInt(breakInput.value) || 5) * 60;
                            stateElement.textContent = `Break started - ${timeLeft / 60} minutes`;
                        } else {
                            stateElement.textContent = `Time's up! ${isWorkPeriod ? 'Take a break!' : 'Back to work!'}`;
                        }

                        // Play sound
                        if (!soundToggle.checked) {
                            document.getElementById('doneSound').play();
                        } else {
                            document.getElementById('timerSound').pause();
                            document.getElementById('doneSound').play();
                            setTimeout(() => {
                                document.getElementById('doneSound').currentTime = 0;
                            }, 3000);
                        }

                        // Update UI
                        progressFill.style.transform = `rotate(-90deg) rotate(${360}deg)`;
                        setTimeout(() => {
                            progressFill.style.transform = `rotate(-90deg)`;
                            if (autoToggle.checked && isWorkPeriod) {
                                isWorkPeriod = false;
                                startTimer();
                            }
                        }, 500);
                    }
                }, 1000);
            }

            function pauseTimer() {
                if (!isRunning) return;

                clearInterval(timerInterval);
                isRunning = false;
                stateElement.textContent = 'Timer paused';
            }

            function resetTimer() {
                if (isRunning) {
                    clearInterval(timerInterval);
                    isRunning = false;
                    pauseBtn.disabled = true;
                    startBtn.textContent = 'Start';
                    stateElement.textContent = 'Timer reset';
                }

                timeLeft = totalSeconds;
                isWorkPeriod = true;
                progressFill.style.transform = `rotate(-90deg)`;
                updateDisplay();
            }

            function updateDisplay() {
                const minutes = Math.floor(timeLeft / 60);
                const seconds = timeLeft % 60;
                timeElement.textContent = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;

                const progress = (1 - timeLeft / totalSeconds) * 360;
                progressFill.style.transform = `rotate(-90deg) rotate(${progress}deg)`;
            }

            // Start initialization
            init();
        });
    </script>
</body>
</html>