A!leys Galerie

use wasm_bindgen::prelude::*;
use js_sys::{
    Array, Reflect, Object, Undefinable, Uint8Array, console,
};
use web_sys::{
    window, local_storage, HttpRequest, HttpRequestResponse, FetchOptions, RequestInit,
    RequestCache, RequestCredentials, RequestMode, RequestReferrerPolicy, RequestDestination,
};
use serde::{Serialize, Deserialize};
use std::error::Error;
use wasm_bindgen_futures::JsFuture;

// Custom highlight pattern that includes colors and fonts
const HIGHLIGHT_PATTERN: &str = r#"
    background: #FFD700;
    color: #000000;
    font-weight: bold;
    padding: 0 2px;
    border-radius: 2px;
    white-space: pre-wrap;
"#;

// Configuration struct with Serialize/Deserialize
#[derive(Serialize, Deserialize, Debug)]
struct Config {
    highlight_color: String,
    history_limit: usize,
    search_history: Vec<String>,
}

impl Default for Config {
    fn default() -> Self {
        Config {
            highlight_color: "#FFD700".to_string(),
            history_limit: 10,
            search_history: Vec::new(),
        }
    }
}

// Load or initialize config from localStorage
fn load_config() -> Config {
    if let Some(storage) = window().and_then(|w| w.local_storage()) {
        if let Ok(Some(config_json)) = JsFuture::from(storage.get("aileygrep_config")) {
            if let Ok(Some(config_string)) = config_json.dyn_into::<String>() {
                if let Ok(config) = serde_json::from_str(&config_string) {
                    return config;
                }
            }
        }
    }
    Config::default()
}

// Save config to localStorage
fn save_config(config: &Config) -> Result<(), JsValue> {
    if let Some(storage) = window().and_then(|w| w.local_storage()) {
        let config_json = serde_json::to_string(config)?;
        storage.set("aileygrep_config", &config_json)?;
    }
    Ok(())
}

// Apply highlight to matches
fn apply_highlight(matches: Vec<(usize, usize)>) -> String {
    let mut result = String::new();
    let mut last_pos = 0;
    for (start, end) in matches {
        result.push_str(&js_sys::Reflect::get(&result, &last_pos.to_string()).unwrap_or(&JsvValue::UNDEFINED));
        result.push_str("<span style=\"");
        result.push_str(HIGHLIGHT_PATTERN);
        result.push_str("\">");
        if let Some(text) = js_sys::Reflect::get(&result, &end.to_string()).unwrap_or(&JsvValue::UNDEFINED).dyn_into::<String>().ok() {
            result.push_str(&text);
        }
        result.push_str("</span>");
        last_pos = end + 1;
    }
    result.push_str(&js_sys::Reflect::get(&result, &last_pos.to_string()).unwrap_or(&JsvValue::UNDEFINED));
    result
}

// Search files using fetch (simulated file system)
async fn search_files(query: &str) -> Result<String, JsValue> {
    // Simulate a file system with a fetch request
    let mut opts = FetchOptions::new();
    opts.method("GET");
    let request = RequestInit::new_with_str(&format!("/api/search?query={}", query))?;
    let response = window().fetch_with_request_and_init(&request, &opts).await?;

    if response.status() == 200 {
        let text = JsFuture::from(response.text()).await?;
        Ok(text)
    } else {
        Err(JsValue::from_str(&format!("HTTP error {}!", response.status())))
    }
}

// Main function with WebAssembly entry point
#[wasm_bindgen(start)]
pub async fn main() -> Result<(), JsValue> {
    console::log_1(&"AileyGrep: Search tool started".into());

    // Load configuration
    let mut config = load_config();

    // Simulate user input (in a real app, this would be from UI)
    let search_terms = ["main.rs", "pub mod", "AileyGrep"];

    for term in search_terms {
        // Search files
        match search_files(&term).await {
            Ok(result) => {
                console::log_1(&format!("Search results for '{}':", term).into());
                console::log_1(&result.into());
                // Apply highlighting
                let highlighted = apply_highlight(vec![(0, term.len())]);
                console::log_1(&format!("Highlighted results: {}", highlighted).into());

                // Update search history
                if !config.search_history.contains(&term.to_string()) {
                    config.search_history.push(term.to_string());
                    if config.search_history.len() > config.history_limit {
                        config.search_history.remove(0);
                    }
                    save_config(&config)?;
                }
            }
            Err(e) => console::log_1(&e),
        }
    }

    // Final status log
    console::log_1(&format!("AileyGrep: Saved {} search terms to localStorage", config.search_history.len()).into());

    Ok(())
}

import SwiftUI
import Combine

struct ZenGridGallery: View {
    // MARK: - State
    @State private var images: [Image] = []
    @State private var selectedImageIndex: Int? = nil
    @State private var isEditing: Bool = false
    @State private var photoLibraryPermission: Bool = false
    @State private var showZoomedImage: Bool = false

    // MARK: - Preview Images
    private let previewImages: [Image] = [
        Image("tate1"),
        Image("tate2"),
        Image("tate3")
    ]

    // MARK: - Body
    var body: some View {
        NavigationStack {
            ZStack {
                // Background
                RadialGradient(
                    gradient: Gradient(colors: [.clear, .black.opacity(0.3)]),
                    center: .center,
                    startRadius: 0,
                    endRadius: 200
                )
                .ignoresSafeArea()

                // Main View
                ScrollView {
                    LazyVGrid(columns: [GridItem(.adaptive(minimum: 200), spacing: 10)],
                              spacing: 10) {
                        ForEach(images.indices, id: \.self) { index in
                            ImageView(image: images[index], selected: selectedImageIndex == index)
                                .onTapGesture {
                                    selectedImageIndex = index
                                    isEditing = true
                                }
                        }
                    }
                    .padding()

                    // Edit Button
                    Button(action: {
                        isEditing = true
                    }) {
                        Label("Edit", systemImage: "pencil")
                            .font(.headline)
                            .foregroundColor(.primary)
                    }
                    .padding(.top, 20)
                }
                .background(Color.clear)

                // Zoomed Image Overlay
                if showZoomedImage && let index = selectedImageIndex {
                    ZStack {
                        Color.black.opacity(0.9)
                            .ignoresSafeArea()
                            .onTapGesture {
                                withAnimation {
                                    showZoomedImage = false
                                }
                            }

                        Image(images[index].name ?? "")
                            .resizable()
                            .scaledToFit()
                            .frame(maxWidth: .infinity, maxHeight: .infinity)
                            .transition(.opacity)
                    }
                    .zIndex(1)
                }
            }
            .navigationTitle("Zen Grid")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: {
                        addImage()
                    }) {
                        Label("Add", systemImage: "plus")
                    }
                }
            }
            .onAppear {
                checkPhotoLibraryPermission()
                if images.isEmpty {
                    images = previewImages
                }
            }
            .sheet(isPresented: $isEditing) {
                ImageEditor(image: $images[selectedImageIndex ?? 0])
            }
        }
    }

    // MARK: - Functions
    private func addImage() {
        if !photoLibraryPermission {
            return
        }

        let picker = UIImagePickerController()
        picker.delegate = self
        UIApplication.shared.windows.first?.rootViewController?.present(picker, animated: true)
    }

    private func checkPhotoLibraryPermission() {
        let status = PHPhotoLibrary.authorizationStatus()
        if status == .notDetermined {
            PHPhotoLibrary.requestAuthorization { granted in
                DispatchQueue.main.async {
                    photoLibraryPermission = granted
                }
            }
        } else {
            photoLibraryPermission = status == .authorized
        }
    }
}

// MARK: - Image View
struct ImageView: View {
    let image: Image
    let selected: Bool

    var body: some View {
        ZStack {
            RoundedRectangle(cornerRadius: 8)
                .stroke(selected ? Color.accentColor : Color.clear, lineWidth: 2)

            image
                .resizable()
                .scaledToFill()
                .frame(height: 200)
                .clipped()
                .opacity(selected ? 1 : 0.9)
        }
        .frame(height: 200)
    }
}

// MARK: - Image Editor
struct ImageEditor: View {
    @Binding var image: Image

    @State private var zoomScale: CGFloat = 1.0
    @State private var panOffset: CGSize = .zero

    var body: some View {
        VStack {
            // Image View
            GeometryReader { geometry in
                Image(image)
                    .resizable()
                    .scaledToFit()
                    .frame(width: geometry.size.width, height: geometry.size.height)
                    .offset(x: panOffset.width, y: panOffset.height)
                    .scaleEffect(zoomScale)
                    .gesture(
                        MagnificationGesture()
                            .onChanged { value in
                                zoomScale = value.magnification
                            }
                    )
                    .gesture(
                        DragGesture()
                            .onChanged { value in
                                panOffset = value.translation
                            }
                            .onEnded { _ in
                                panOffset = .zero
                            }
                    )
            }
            .frame(height: 300)
            .padding(.horizontal)

            // Save Button
            Button(action: {
                UIApplication.shared.windows.first?.rootViewController?.dismiss(animated: true)
            }) {
                Text("Done")
                    .font(.headline)
                    .foregroundColor(.white)
                    .frame(width: 200, height: 44)
                    .background(Color.accentColor)
                    .cornerRadius(8)
            }
            .padding(.top)
        }
        .background(Color.black)
        .ignoresSafeArea()
    }
}

// MARK: - Preview Provider
struct ZenGridGallery_Previews: PreviewProvider {
    static var previews: some View {
        ZenGridGallery()
            .preferredColorScheme(.dark)
    }
}

// MARK: - UIImagePickerController Delegate
extension ZenGridGallery: UINavigationControllerDelegate, UIImagePickerControllerDelegate {
    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
        if let uiImage = info[.originalImage] as? UIImage {
            let swiftUIImage = Image(uiImage: uiImage)
            images.append(swiftUIImage)
        }
        picker.dismiss(animated: true)
    }
}

// MARK: - Preview Images
struct PreviewImage: View {
    var body: some View {
        Image(systemName: "photo")
            .resizable()
            .scaledToFill()
            .frame(width: 200, height: 200)
            .clipped()
            .opacity(0.5)
    }
}

use serde_json::{Value, from_reader, to_writer, ser::PrettyGenerator};
use std::io::{self, Read, Write};
use std::error::Error;
use rand::Rng;
use crossterm::{
    execute,
    style::{Color, Print, SetForegroundColor},
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
    cursor::Hide, queue,
    Event, KeyCode,
};
use ratatui::{
    backend::CrosstermBackend,
    Terminal,
    text::{Span, Text},
    widgets::{Block, Borders, Paragraph},
    layout::{Constraint, Direction, Layout, Rectangle},
    style::{Style, Stylize},
};
use std::time::Duration;

const CONFETTI_CHARS: [char; 12] = ['♥', '☆', '★', '♦', '♣', '♠', '•', '◕', '◈', '◑', '☺', '☻'];
const COLORS: [Color; 8] = [
    Color::Red,
    Color::Green,
    Color::Yellow,
    Color::Blue,
    Color::Magenta,
    Color::Cyan,
    Color::White,
    Color::Gray,
];

struct JSONFormatter {
    terminal: Terminal<CrosstermBackend>,
    confetti_active: bool,
    confetti_timeout: Duration,
}

impl JSONFormatter {
    fn new(terminal: Terminal<CrosstermBackend>) -> Self {
        JSONFormatter {
            terminal,
            confetti_active: false,
            confetti_timeout: Duration::from_millis(100),
        }
    }

    fn handle_confetti(&mut self) {
        if !self.confetti_active {
            return;
        }

        let width = self.terminal.size().unwrap().width as usize;
        let height = self.terminal.size().unwrap().height as usize;

        let mut rng = rand::thread_rng();
        let mut confetti_lines = Vec::new();

        for _ in 0..(rng.gen_range(5..15)) {
            let char_index = rng.gen_range(0..CONFETTI_CHARS.len());
            let color_index = rng.gen_range(0..COLORS.len());
            let x = rng.gen_range(0..width);
            let y = rng.gen_range(0..height);
            let speed = rng.gen_range(1..4);
            let char_span = Span::from(CONFETTI_CHARS[char_index].to_string())
                .fg(COLORS[color_index])
                .bold();
            confetti_lines.push((x, y, speed, char_span));
        }

        self.draw_confetti(confetti_lines);
        if self.confetti_active {
            std::thread::spawn(|| {
                std::thread::sleep(self.confetti_timeout);
                let mut term = self.terminal.clone();
                term.clear().unwrap();
                term.draw(|f| {
                    f.render_widget(
                        Paragraph::new("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n")
                            .block(Block::default().borders(Borders::NONE))
                            .style(Style::default().add_modifier(ratatui::style::Modifier::REVERSED)),
                        f.size(),
                    );
                }).unwrap();
            });
        }
    }

    fn draw_confetti(&mut self, lines: Vec<(usize, usize, usize, Span)>) {
        let mut term = self.terminal.clone();
        term.clear().unwrap();
        term.draw(|f| {
            for (x, y, speed, char_span) in lines {
                let mut y_pos = y;
                for _ in 0..speed {
                    if y_pos > 0 {
                        y_pos -= 1;
                    } else {
                        break;
                    }
                }
                if y_pos < f.size().height as usize {
                    let position = (x, y_pos);
                    f.render_widget(
                        Paragraph::new(char_span)
                            .block(Block::default().borders(Borders::NONE))
                            .position(position),
                        f.size(),
                    );
                }
            }
        }).unwrap();
    }

    fn format_json(&mut self, input: String) -> Result<String, Box<dyn Error>> {
        let value: Value = from_reader(&mut io::Cursor::new(input.clone()))?;
        let mut pretty = PrettyGenerator::new(io::stdout());
        to_writer(&mut pretty, &value)?;

        let output = prettyIntoString(&value)?;

        if output.len() > 500 {
            self.confetti_active = true;
            self.handle_confetti();
        }

        Ok(output)
    }
}

fn prettyIntoString(value: &Value) -> Result<String, Box<dyn Error>> {
    let mut buffer = String::new();
    let mut generator = PrettyGenerator::new(&mut buffer);
    generator.write(value)?;
    Ok(buffer)
}

fn main() -> Result<(), Box<dyn Error>> {
    // Initialize terminal
    let mut stdout = io::stdout();
    enable_raw_mode()?;
    let mut terminal = Terminal::new(CrosstermBackend::new(stdout))?;
    execute!(
        terminal.backend_mut(),
        EnterAlternateScreen,
        Hide,
    )?;
    terminal.clear()?;

    let mut formatter = JSONFormatter::new(terminal);

    // Main loop
    loop {
        // Draw UI
        let size = terminal.size()?;
        let layout = Layout::default()
            .direction(Direction::Vertical)
            .constraints([
                Constraint::Percentage(20),
                Constraint::Percentage(60),
                Constraint::Percentage(20),
            ])
            .split(size);

        terminal.draw(|f| {
            // Header
            let header = Text::from("GlitterJSON - JSON Pretty Printer with Syntax Highlighting")
                .green()
                .bold();
            f.render_widget(
                Paragraph::new(header)
                    .block(Block::default().borders(Borders::ALL).title("GlitterJSON")),
                layout[0],
            );

            // Instructions
            let instructions = Text::from([
                "1. Paste your JSON (max 500 chars for confetti!)",
                "2. Press Enter to format",
                "3. Press Esc to quit",
                "4. Press Backspace to clear",
            ])
            .green()
            .bold();
            f.render_widget(
                Paragraph::new(instructions)
                    .block(Block::default().borders(Borders::ALL).title("Instructions")),
                layout[2],
            );
        })?;

        // Get user input
        let mut input = String::new();
        let event = terminal.backend().poll_event()?;
        match event.code {
            KeyCode::Char(c) if c.is_ascii() => {
                input.push(c);
                let mut term = formatter.terminal.clone();
                term.draw(|f| {
                    let output = Text::from(input.clone()).green();
                    f.render_widget(
                        Paragraph::new(output)
                            .block(Block::default().borders(Borders::ALL).title("Input")),
                        layout[1],
                    );
                })?;
            }
            KeyCode::Backspace => {
                input.pop();
                let mut term = formatter.terminal.clone();
                term.draw(|f| {
                    let output = Text::from(input.clone()).green();
                    f.render_widget(
                        Paragraph::new(output)
                            .block(Block::default().borders(Borders::ALL).title("Input")),
                        layout[1],
                    );
                })?;
            }
            KeyCode::Enter => {
                if input.trim().is_empty() {
                    continue;
                }
                match formatter.format_json(input.clone()) {
                    Ok(output) => {
                        // Display formatted JSON
                        let mut term = formatter.terminal.clone();
                        term.draw(|f| {
                            let formatted = Text::from(output.clone())
                                .green()
                                .bold();
                            f.render_widget(
                                Paragraph::new(formatted)
                                    .block(Block::default().borders(Borders::ALL).title("Formatted JSON")),
                                layout[1],
                            );
                        })?;
                    }
                    Err(e) => {
                        // Display error
                        let mut term = formatter.terminal.clone();
                        term.draw(|f| {
                            let error = Text::from(format!("Error: {}", e))
                                .red()
                                .bold();
                            f.render_widget(
                                Paragraph::new(error)
                                    .block(Block::default().borders(Borders::ALL).title("Error")),
                                layout[1],
                            );
                        })?;
                    }
                }
            }
            KeyCode::Esc => break,
            _ => {}
        }
    }

    // Cleanup
    execute!(
        terminal.backend_mut(),
        LeaveAlternateScreen,
        Hide,
    )?;
    disable_raw_mode()?;
    terminal.show_cursor()?;
    Ok(())
}