A!leys Galerie

use std::{
    fs,
    io,
    path::{Path, PathBuf},
    sync::{Arc, Mutex},
};
use hyper::{Body, Request, Response, Server, StatusCode};
use hyper::service::{make_service_fn, service_fn};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// Struktur für den Server-Zustand (shared zwischen Requests)
#[derive(Clone, Default)]
struct ServerState {
    current_dir: Arc<Mutex<PathBuf>>,
    history: Arc<Mutex<Vec<PathBuf>>>,
}

// Struktur für das URL-Query-Objekt
#[derive(Deserialize)]
struct QueryParams {
    path: Option<String>,
    save: Option<bool>,
}

// Hauptfunktion mit asynchronem HTTP-Server
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Standardverzeichnis (wird später geladen)
    let mut current_dir = PathBuf::from(".");

    // Lade letzten Stand aus localStorage (Simuliert)
    if let Ok(history) = load_history() {
        current_dir = if history.is_empty() {
            PathBuf::from(".")
        } else {
            history.last().unwrap().clone()
        };
    }

    // Erstelle den Server-Zustand
    let state = ServerState {
        current_dir: Arc::new(Mutex::new(current_dir)),
        history: Arc::new(Mutex::new(load_history().unwrap_or_default())),
    };

    // URL: http://localhost:8080
    let addr = ([127, 0, 0, 1], 8080).into();

    // Erstelle den HTTP-Server
    let make_svc = make_service_fn(|_conn| {
        let state = state.clone();
        async move {
            Ok::<_, hyper::Error>(service_fn(move |req: Request<Body>| {
                handle_request(req, state.clone())
            }))
        }
    });

    println!("Server läuft auf http://localhost:8080");
    Server::bind(&addr).serve(make_svc).await?;

    Ok(())
}

// Verarbeitet eingehende HTTP-Requests
async fn handle_request(
    req: Request<Body>,
    state: ServerState,
) -> Result<Response<Body>, hyper::Error> {
    // Parsen der URL
    let path = req.uri().path().to_string();
    let query_string = req.uri().query().unwrap_or_default();
    let query_params: QueryParams = match serde_urlencoded::from_str(query_string) {
        Ok(p) => p,
        Err(_) => QueryParams { path: None, save: None },
    };

    // Aktuelle Pfad-Konstruktion
    let mut current_dir = state.current_dir.lock().unwrap().clone();
    if let Some(ref path) = query_params.path {
        current_dir = if path.is_empty() {
            PathBuf::from(".")
        } else {
            PathBuf::from(path)
        };
        // Aktualisiere den Pfad im Zustand
        let mut history = state.history.lock().unwrap();
        history.push(current_dir.clone());
        if query_params.save.unwrap_or(true) {
            save_history(&history);
        }
    }

    // Versuche, den Ordner zu lesen
    match fs::read_dir(&current_dir) {
        Ok(entries) => {
            // Erstelle die Baumansicht
            let tree = generate_tree(&current_dir, entries);
            let response = Response::builder()
                .status(StatusCode::OK)
                .header("Content-Type", "text/html")
                .body(Body::from(tree))?;
            Ok(response)
        }
        Err(_) => {
            // Falls der Ordner ungültig ist, zeige Fehlerseite
            let response = Response::builder()
                .status(StatusCode::NOT_FOUND)
                .body(Body::from(
                    format!(
                        r#"
                        <h1>404 Not Found</h1>
                        <p>Die angegebene Pfad: {} existiert nicht.</p>
                        <a href="/?save=true">Zurück zur Startseite</a>
                        "#,
                        current_dir.display()
                    ),
                ))?;
            Ok(response)
        }
    }
}

// Generiert einen Baum aus den Dateien
fn generate_tree(parent: &Path, entries: io::Result<fs::ReadDir>) -> String {
    let mut tree = String::new();
    tree.push_str("<html><head><title>Dateibaum</title></head><body><h1>Dateibaum: ");
    tree.push_str(parent.display().to_string().as_str());
    tree.push_str("</h1><ul>");

    for entry in entries.unwrap() {
        let entry = entry.unwrap();
        let name = entry.file_name().to_string_lossy();
        let path = entry.path();

        if path.is_dir() {
            tree.push_str(&format!("<li><a href=\"/?path={}\">{}/</a>", path.display(), name));
        } else {
            tree.push_str(&format!("<li>{}", name));
        }
    }

    tree.push_str("</ul><a href=\"/?save=true\">Zurück zur Startseite</a></body></html>");
    tree
}

// Simuliert localStorage für den letzten Stand
fn save_history(history: &[PathBuf]) -> Result<(), Box<dyn std::error::Error>> {
    // In einer echten App würdest du hier e.g. eine Datei oder echte localStorage (z.B. über wasm-bindgen) verwenden
    // Für dieses Beispiel speichern wir nur in einem HashMap (Simuliert)
    let history_str: String = history.iter().map(|p| p.to_string_lossy().into_owned()).collect();
    std::env::set_var("RUSTY_FILE_TREE_HISTORY", history_str);
    Ok(())
}

// Lädt den letzten Stand
fn load_history() -> Result<Vec<PathBuf>, Box<dyn std::error::Error>> {
    if let Some(history_str) = std::env::var("RUSTY_FILE_TREE_HISTORY").ok() {
        let history: Vec<PathBuf> = history_str
            .split(',')
            .map(|s| PathBuf::from(s.trim()))
            .collect();
        Ok(history)
    } else {
        Ok(vec![])
    }
}

#!/usr/bin/env python3
"""
HashSleuth - Interactive Duplicate File Finder

Features:
- Finds duplicate files using SHA-256 hashing
- Visualizes hash distribution and clusters
- Smooth animations between states
- Interactive file selection
- Progress tracking
"""

import os
import hashlib
import time
import typing as t
from pathlib import Path
from dataclasses import dataclass, field
from collections import defaultdict

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.colors import ListedColormap
import PySimpleGUI as sg

# Constants
MAX_FILE_SIZE = 100 * 1024 * 1024  # 100MB
HASH_FINGERPRINT_LENGTH = 6
VISUAL_DENSITY = 0.1
ANIMATION_DURATION = 1000  # ms

@dataclass(order=True)
class FileHash:
    """Immutable file hash representation for comparison."""
    path: str
    size: int
    hash: str
    timestamp: float = field(compare=False)
    display_name: str = field(compare=False)

class HashVisualizer:
    """Handles the visualization of hash distributions."""

    def __init__(self):
        self.fig, self.ax = plt.subplots(figsize=(10, 8))
        plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
        plt.axis('off')

        # Create colormap
        self.colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFBE0B',
                      '#FB5607', '#8338EC', '#3A86FF', '#FF006E']
        self.cmap = ListedColormap(self.colors)

        self.sc = self.ax.scatter([], [], s=5, color='white', alpha=0)
        self.ax.set_facecolor('#222222')
        self.ax.grid(False)
        self.fig.patch.set_facecolor('#222222')

        # Store previous state for animation
        self.prev_x = []
        self.prev_y = []
        self.prev_colors = []

    def update_plot(self, x: np.ndarray, y: np.ndarray, colors: np.ndarray):
        """Updates the visualization with new data."""
        self.sc.set_offsets(np.c_[x, y])
        self.sc.set_color(colors)

        self.prev_x = x.copy()
        self.prev_y = y.copy()
        self.prev_colors = colors.copy()

        # Smooth transition
        return self.sc,

    def animate_to(self, x: np.ndarray, y: np.ndarray, colors: np.ndarray):
        """Animates transition between visualizations."""
        def update(frame):
            t = frame / ANIMATION_DURATION
            current_x = (1-t) * np.array(self.prev_x) + t * x
            current_y = (1-t) * np.array(self.prev_y) + t * y
            current_colors = (1-t) * self.prev_colors + t * colors
            return self.update_plot(current_x, current_y, current_colors)

        return FuncAnimation(
            self.fig, update, frames=ANIMATION_DURATION, interval=10,
            blit=True, repeat=False
        )

class HashSleuth:
    """Main class for finding duplicate files."""

    def __init__(self):
        self.file_hashes = []
        self.hash_clusters = defaultdict(list)
        self.current_files = []
        self.visualizer = HashVisualizer()

    def _compute_hash(self, file_path: str) -> str:
        """Computes SHA-256 hash of a file."""
        if not os.path.exists(file_path):
            return ""

        sha256 = hashlib.sha256()
        try:
            with open(file_path, 'rb') as f:
                # Read in chunks to handle large files
                for chunk in iter(lambda: f.read(4096), b""):
                    sha256.update(chunk)
            return sha256.hexdigest()
        except (IOError, PermissionError):
            return ""

    def _process_file(self, file_path: str) -> t.Optional[FileHash]:
        """Processes a single file and returns its hash information."""
        if os.path.islink(file_path):
            return None

        file_stat = os.stat(file_path)
        if file_stat.st_size > MAX_FILE_SIZE:
            return None

        file_hash = self._compute_hash(file_path)
        if not file_hash:
            return None

        return FileHash(
            path=file_path,
            size=file_stat.st_size,
            hash=file_hash,
            timestamp=file_stat.st_mtime,
            display_name=os.path.basename(file_path)
        )

    def scan_directory(self, directory: str):
        """Scans a directory for duplicate files."""
        self.file_hashes = []
        self.hash_clusters.clear()

        if not os.path.isdir(directory):
            return False, 0, 0

        start_time = time.time()
        processed = 0

        for root, _, files in os.walk(directory):
            for file in files:
                file_path = os.path.join(root, file)
                file_hash = self._process_file(file_path)
                if file_hash:
                    self.file_hashes.append(file_hash)
                    self.hash_clusters[file_hash.hash].append(file_hash)
                    processed += 1

                    # Update progress in UI
                    if sg.WINDOWS and sg.WINDOWS[0].visible:
                        event, values = sg.WINDOWS[0].read(timeout=0)
                        if event == sg.TIMEOUT_EVENT:
                            sg.WINDOWS[0].read_non_blocking()

        elapsed = time.time() - start_time
        return True, processed, elapsed

    def visualize_hashes(self):
        """Creates a visualization of the hash distribution."""
        if not self.file_hashes:
            return False

        # Extract hash fingerprints (first 6 chars for visualization)
        fingerprints = [fh.hash[:HASH_FINGERPRINT_LENGTH] for fh in self.file_hashes]

        # Create hash vector (normalized coordinates)
        hash_vectors = []
        for fp in fingerprints:
            # Simple hash-to-2D mapping
            h1 = sum(ord(c) for c in fp[::2]) % 256
            h2 = sum(ord(c) for c in fp[1::2]) % 256
            hash_vectors.append((h1, h2))

        # Convert to numpy array
        x = np.array([v[0] for v in hash_vectors])
        y = np.array([v[1] for v in hash_vectors])

        # Create color array based on cluster size
        colors = []
        for i, (fp, fh) in enumerate(zip(fingerprints, self.file_hashes)):
            cluster_size = len(self.hash_clusters[fp])
            color_index = min(cluster_size - 1, len(self.colors) - 1)
            colors.append(self.colors[color_index])

        colors = np.array(colors)

        # Show visualization
        anim = self.visualizer.animate_to(x, y, colors)
        plt.show()

        return True

    def show_duplicates(self):
        """Displays duplicate files in the UI."""
        if not self.hash_clusters:
            return False

        # Prepare data for the UI
        duplicates = []
        for hash_val, files in self.hash_clusters.items():
            if len(files) > 1:
                duplicates.append((hash_val, files))

        # Sort by cluster size (descending)
        duplicates.sort(key=lambda x: len(x[1]), reverse=True)

        # Update the UI
        if sg.WINDOWS and sg.WINDOWS[0].visible:
            layout = [
                [sg.Text("Duplicate Files Found:", font=('Helvetica', 16, 'bold'))],
                [sg.HSeparator()],
                [sg.Column([
                    [sg.Text(f"Cluster {i+1} (Size: {len(files)})", font=('Helvetica', 10))],
                    [sg.Text(f"Hash: {hash_val[:HASH_FINGERPRINT_LENGTH]}...", font=('Courier', 10))],
                    [sg.Listbox(
                        [f"{fh.display_name} ({fh.size/1024/1024:.2f}MB)" for fh in files],
                        size=(60, len(files)),
                        key=f"-LISTBOX-{i}-",
                        enable_events=True
                    )],
                    [sg.HSeparator()],
                ], element_justification='c') for i, (hash_val, files) in enumerate(duplicates)],
                [sg.Button("Close", size=(10, 1))]
            ]

            window = sg.Window(
                "Duplicate Files",
                layout,
                size=(600, 400),
                element_justification='c',
                background_color='#222222',
                text_color='#FFFFFF',
                font=('Helvetica', 10)
            )

            while True:
                event, values = window.read()
                if event == sg.WIN_CLOSED or event == "Close":
                    window.close()
                    break
                elif event.startswith("-LISTBOX-"):
                    idx = int(event.split("-")[2])
                    window[f"-LISTBOX-{idx}-"].update(values[f"-LISTBOX-{idx}-"], set_to_index=0)

            sg.WINDOWS[0].close()

        return True

def create_ui():
    """Creates the user interface."""
    layout = [
        [sg.Text("HashSleuth - Duplicate File Finder", font=('Helvetica', 16, 'bold'))],
        [sg.HSeparator()],
        [sg.Text("Select directory to scan:"), sg.In(size=(40, 1), key="-DIRECTORY-")],
        [sg.FolderBrowse(button_text="Browse"), sg.Button("Scan Directory")],
        [sg.HSeparator()],
        [sg.Text("Progress:"), sg.ProgressBar(max_value=100, orientation='h', size=(40, 20), key="-PROGRESS-")],
        [sg.Text("", key="-PROGRESS_TEXT-")],
        [sg.Button("Show Visualization"), sg.Button("Show Duplicates"), sg.Button("Exit")],
    ]

    return sg.Window(
        "HashSleuth",
        layout,
        size=(600, 400),
        resizable=True,
        element_justification='c',
        background_color='#222222',
        text_color='#FFFFFF',
        font=('Helvetica', 10)
    )

def main():
    """Main application function."""
    app = HashSleuth()
    window = create_ui()

    while True:
        event, values = window.read()
        if event == sg.WIN_CLOSED or event == "Exit":
            break
        elif event == "Scan Directory":
            directory = values["-DIRECTORY-"]
            if directory:
                success, processed, elapsed = app.scan_directory(directory)
                if success:
                    window["-PROGRESS-"].update(100)
                    window["-PROGRESS_TEXT-"].update(f"Scan complete. Processed {processed} files in {elapsed:.2f} seconds.")
                else:
                    window["-PROGRESS-"].update(0)
                    window["-PROGRESS_TEXT-"].update("Invalid directory path.")
        elif event == "Show Visualization":
            if app.file_hashes:
                app.visualize_hashes()
            else:
                sg.popup("Please scan a directory first.")
        elif event == "Show Duplicates":
            if app.file_hashes:
                app.show_duplicates()
            else:
                sg.popup("Please scan a directory first.")

    window.close()

if __name__ == "__main__":
    main()

"""
MemoMaster - Intelligent Note-Taking API
Features:
- Text analysis with NLP (sentiment, key terms)
- Note organization with automatic tagging
- Search by content and metadata
- Export to Markdown/PDF
"""

from typing import List, Dict, Optional
from datetime import datetime, timedelta
import uuid
import re
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel
from starlette.responses import JSONResponse
import textstat
import nltk
from nltk.sentiment import SentimentIntensityAnalyzer
from fastapi.middleware.cors import CORSMiddleware

# Download NLTK resources
try:
    nltk.data.find('tokenizers/punkt')
    nltk.data.find('sentiment/vader_lexicon')
except LookupError:
    nltk.download('punkt')
    nltk.download('vader_lexicon')

app = FastAPI(
    title="MemoMaster API",
    description="Intelligent Note-Taking API with NLP Features",
    version="1.0.0"
)

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

class Note(BaseModel):
    title: str
    content: str
    tags: List[str] = []
    created_at: Optional[datetime] = None
    updated_at: Optional[datetime] = None
    is_important: bool = False

class NoteResponse(BaseModel):
    id: str
    title: str
    content: str
    tags: List[str]
    created_at: datetime
    updated_at: datetime
    is_important: bool
    sentiment_score: float
    reading_time: int  # in seconds
    key_terms: List[str]

class NoteAnalysis(BaseModel):
    sentiment: Dict[str, float]
    complexity: float
    reading_time: int
    key_terms: List[str]
    summary: str

# In-memory database (for demo purposes)
notes_db: Dict[str, Note] = {}

@app.post("/notes/", response_model=NoteResponse)
async def create_note(note: Note):
    """Create a new note with automatic analysis"""
    note_id = str(uuid.uuid4())
    note.created_at = datetime.utcnow()
    note.updated_at = note.created_at

    # Store note
    notes_db[note_id] = note

    # Return with analysis
    return await analyze_note(note_id)

@app.get("/notes/{note_id}", response_model=NoteResponse)
async def read_note(note_id: str):
    """Read a note with analysis"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")
    return await analyze_note(note_id)

@app.get("/notes/", response_model=List[NoteResponse])
async def list_notes(
    tags: Optional[List[str]] = None,
    search: Optional[str] = None,
    limit: int = 10,
    important: Optional[bool] = None
):
    """List notes with optional filtering"""
    filtered_notes = []

    for note in notes_db.values():
        # Filter by tags
        if tags:
            if not any(tag in note.tags for tag in tags):
                continue

        # Filter by importance
        if important is not None:
            if note.is_important != important:
                continue

        # Filter by search term
        if search:
            if (search.lower() not in note.title.lower() and
                search.lower() not in note.content.lower()):
                continue

        filtered_notes.append(note)

    # Apply limit
    filtered_notes = filtered_notes[:limit]

    # Return with analysis
    return [await analyze_note(note_id) for note_id, note in notes_db.items() if note in filtered_notes]

@app.put("/notes/{note_id}", response_model=NoteResponse)
async def update_note(note_id: str, note: Note):
    """Update an existing note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    note.updated_at = datetime.utcnow()
    notes_db[note_id] = note
    return await analyze_note(note_id)

@app.delete("/notes/{note_id}")
async def delete_note(note_id: str):
    """Delete a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    del notes_db[note_id]
    return JSONResponse(status_code=status.HTTP_204_NO_CONTENT)

@app.post("/notes/{note_id}/tag", response_model=NoteResponse)
async def add_tag(note_id: str, tag: str):
    """Add a tag to a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    if tag in notes_db[note_id].tags:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Tag already exists")

    notes_db[note_id].tags.append(tag)
    notes_db[note_id].updated_at = datetime.utcnow()
    return await analyze_note(note_id)

@app.post("/notes/{note_id}/importance", response_model=NoteResponse)
async def toggle_importance(note_id: str):
    """Toggle importance flag on a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    notes_db[note_id].is_important = not notes_db[note_id].is_important
    notes_db[note_id].updated_at = datetime.utcnow()
    return await analyze_note(note_id)

async def analyze_note(note_id: str) -> NoteResponse:
    """Analyze a note and return enhanced response"""
    note = notes_db[note_id]

    # Sentiment analysis
    sia = SentimentIntensityAnalyzer()
    sentiment = sia.polarity_scores(note.content)
    compound_score = sentiment['compound']

    # Text complexity
    complexity = textstat.flesch_reading_ease(note.content)

    # Reading time (words per minute is typically 200)
    word_count = len(re.findall(r'\w+', note.content))
    reading_time = int((word_count / 200) * 60)  # Convert to seconds

    # Extract key terms (simple approach)
    key_terms = [term for term in nltk.word_tokenize(note.title.lower()) if len(term) > 3]

    # Generate summary (very basic)
    summary = f"Note about {note.title} with {len(key_terms)} key terms."

    return NoteResponse(
        id=note_id,
        title=note.title,
        content=note.content,
        tags=note.tags,
        created_at=note.created_at,
        updated_at=note.updated_at,
        is_important=note.is_important,
        sentiment_score=compound_score,
        reading_time=reading_time,
        key_terms=key_terms
    )

@app.get("/notes/analysis/{note_id}", response_model=NoteAnalysis)
async def get_note_analysis(note_id: str):
    """Get detailed analysis of a note"""
    if note_id not in notes_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Note not found")

    note = notes_db[note_id]

    # Sentiment analysis
    sia = SentimentIntensityAnalyzer()
    sentiment = sia.polarity_scores(note.content)

    # Text complexity
    complexity = textstat.flesch_reading_ease(note.content)

    # Reading time
    word_count = len(re.findall(r'\w+', note.content))
    reading_time = int((word_count / 200) * 60)  # Convert to seconds

    # Extract key terms
    key_terms = [term for term in nltk.word_tokenize(note.title.lower()) if len(term) > 3]

    # Generate summary (very basic)
    summary = f"Note about {note.title} with {len(key_terms)} key terms."

    return NoteAnalysis(
        sentiment=sentiment,
        complexity=complexity,
        reading_time=reading_time,
        key_terms=key_terms,
        summary=summary
    )

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)