A!leys Galerie

using UnityEngine;
using UnityEngine.InputSystem;
using System;
using System.Collections.Generic;
using System.Linq;

[DisallowMultipleComponent]
public class AileyInputRebinder : MonoBehaviour
{
    [Header("Input System Settings")]
    [SerializeField] private PlayerInputManager playerInputManager;
    [SerializeField] private InputActionAsset inputActionAsset;
    [SerializeField] private string actionMapToMonitor = "Player";

    [Header("Rebinding Features")]
    [SerializeField] private bool enableAIAssistedRebinding = true;
    [SerializeField] private bool showHapticFeedback = true;
    [SerializeField] private float rebindCooldown = 0.3f;

    private Dictionary<string, string> currentBindings;
    private Dictionary<string, string> originalBindings;
    private Coroutine rebindCoroutine;
    private float lastRebindTime;
    private InputActionReference[] allActions;

    // AI-assisted rebinding suggestions
    private Dictionary<string, List<string>> actionToSuggestionMap = new Dictionary<string, List<string>>();
    private List<string> allSuggestedKeys = new List<string>
    {
        "W", "A", "S", "D", "Q", "E",
        "Space", "LeftShift", "LeftControl",
        "Mouse left", "Mouse right",
        "Gamepad leftstick up", "Gamepad leftstick down",
        "Gamepad A", "Gamepad B"
    };

    [Header("UI Elements")]
    [SerializeField] private TMPro.TextMeshProUGUI bindingDisplay;
    [SerializeField] private GameObject rebindUI;
    [SerializeField] private TMPro.TMP_InputField currentBindingField;
    [SerializeField] private TMPro.TMP_Dropdown suggestedBindingsDropdown;

    private InputActionReference currentlyBindingAction;
    private string currentlyBindingActionName;

    private void Awake()
    {
        if (playerInputManager == null)
        {
            playerInputManager = GetComponent<PlayerInputManager>();
            if (playerInputManager == null)
            {
                Debug.LogError("No PlayerInputManager reference found. Please assign one in the inspector or add PlayerInputManager component.");
                enabled = false;
                return;
            }
        }

        if (inputActionAsset == null)
        {
            Debug.LogError("No InputActionAsset assigned. Please assign your InputActionAsset.");
            enabled = false;
            return;
        }

        InitializeInputSystem();
        InitializeAISuggestions();
        UpdateBindingDisplay();
    }

    private void InitializeInputSystem()
    {
        if (playerInputManager == null) return;

        // Get all input actions from the action map
        InputActionMap actionMap = inputActionAsset.FindActionMap(actionMapToMonitor);
        if (actionMap == null)
        {
            Debug.LogError($"Action map '{actionMapToMonitor}' not found in the InputActionAsset.");
            return;
        }

        allActions = actionMap.actions
            .Select(a => new InputActionReference(a))
            .ToArray();

        // Store original bindings
        currentBindings = new Dictionary<string, string>();
        originalBindings = new Dictionary<string, string>();

        foreach (var action in allActions)
        {
            string[] bindings = action.action.bindings
                .Select(b => b.path)
                .Where(b => b != null)
                .ToArray();

            string bindingKey = string.Join(", ", bindings);
            currentBindings[action.action.name] = bindingKey;
            originalBindings[action.action.name] = bindingKey;
        }
    }

    private void InitializeAISuggestions()
    {
        if (!enableAIAssistedRebinding) return;

        // Create suggestion map based on action names
        foreach (var action in allActions)
        {
            string actionName = action.action.name.ToLower();

            // Simple AI logic - different suggestions based on action type
            List<string> suggestions = new List<string>();

            if (actionName.Contains("jump") || actionName.Contains("jumpbutton"))
            {
                suggestions = allSuggestedKeys.Where(k => k == "Space" || k == "Mouse left" || k.Contains("Gamepad")).ToList();
            }
            else if (actionName.Contains("move") || actionName.Contains("direction"))
            {
                suggestions = new List<string> { "W", "A", "S", "D", "Mouse left", "Gamepad leftstick" };
            }
            else if (actionName.Contains("attack") || actionName.Contains("fire"))
            {
                suggestions = allSuggestedKeys.Where(k => k == "Mouse right" || k == "Gamepad A" || k == "Q").ToList();
            }
            else if (actionName.Contains("dash") || actionName.Contains("dashbutton"))
            {
                suggestions = allSuggestedKeys.Where(k => k == "LeftShift" || k == "Gamepad B" || k == "E").ToList();
            }
            else if (actionName.Contains("interact") || actionName.Contains("interactbutton"))
            {
                suggestions = allSuggestedKeys.Where(k => k == "E" || k == "Mouse left").ToList();
            }
            else
            {
                suggestions = allSuggestedKeys.ToList();
            }

            actionToSuggestionMap[action.action.name] = suggestions;
        }

        // Initialize dropdown
        UpdateSuggestedBindingsDropdown();
    }

    private void UpdateSuggestedBindingsDropdown()
    {
        if (suggestedBindingsDropdown == null || !enableAIAssistedRebinding) return;

        suggestedBindingsDropdown.ClearOptions();
        List<TMP_Dropdown.OptionData> options = new List<TMP_Dropdown.OptionData>();

        if (currentlyBindingAction != null && actionToSuggestionMap.ContainsKey(currentlyBindingAction.action.name))
        {
            options.AddRange(actionToSuggestionMap[currentlyBindingAction.action.name]
                .Select(s => new TMP_Dropdown.OptionData(s)));
        }

        suggestedBindingsDropdown.AddOptions(options);
    }

    private void UpdateBindingDisplay()
    {
        if (bindingDisplay == null) return;

        bindingDisplay.text = "";
        foreach (var kvp in currentBindings)
        {
            bindingDisplay.text += $"{kvp.Key}: {kvp.Value}\n";
        }
    }

    #region Keyboard Shortcuts
    private void Update()
    {
        if (rebindUI.activeSelf)
        {
            if (Keyboard.current rinp wasd Enter)
            {
                StartRebinding(currentlyBindingActionName);
            }
            else if (Keyboard.current rinp wasd Escape)
            {
                ExitRebindUI();
            }
        }
    }

    [InputCaptureLocal KeyCode.F11]
    private void ToggleRebindUI()
    {
        if (rebindUI.activeSelf)
        {
            ExitRebindUI();
        }
        else
        {
            rebindUI.SetActive(true);
        }
    }

    [InputCaptureLocal KeyCode.F12]
    private void ResetAllBindings()
    {
        if (playerInputManager == null) return;

        foreach (var action in allActions)
        {
            string[] originalBindings = this.originalBindings[action.action.name].Split(',');
            action.action bindings = originalBindings
                .Select(b => new InputBinding { path = b.Trim() })
                .ToArray();
        }

        currentBindings = new Dictionary<string, string>(originalBindings);
        UpdateBindingDisplay();
        rebindUI.SetActive(false);
    }
    #endregion

    private void StartRebinding(string actionName)
    {
        InputActionReference action = allActions.FirstOrDefault(a => a.action.name == actionName);
        if (action == null) return;

        currentlyBindingAction = action;
        currentlyBindingActionName = actionName;

        currentBindingField.text = currentBindings[actionName];
        currentBindingField.Select();
        currentBindingField.ActivateInputField();

        UpdateSuggestedBindingsDropdown();

        if (showHapticFeedback && InputSystem.supportedInputDevices.Any(d => d is Gamepad))
        {
            foreach (var device in InputSystem.supportedDevices.OfType<Gamepad>())
            {
                device.SendHaptic Pulse(0.5f, 0.1f);
            }
        }
    }

    private void ExitRebindUI()
    {
        rebindUI.SetActive(false);
        currentlyBindingAction = null;
        currentlyBindingActionName = null;
    }

    public void ApplyBinding(string newBinding)
    {
        if (currentlyBindingAction == null) return;

        currentlyBindingAction.action bindings = new InputBinding[] { new InputBinding { path = newBinding } };
        currentBindings[currentlyBindingActionName] = newBinding;
        UpdateBindingDisplay();

        ExitRebindUI();
    }

    public void ApplySuggestedBinding()
    {
        if (suggestedBindingsDropdown.value >= 0 &&
            suggestedBindingsDropdown.options.Count > suggestedBindingsDropdown.value)
        {
            string suggestedBinding = suggestedBindingsDropdown.options[suggestedBindingsDropdown.value].text;
            ApplyBinding(suggestedBinding);
        }
    }

    public void ResetBinding()
    {
        if (currentlyBindingAction == null) return;

        string originalBinding = originalBindings[currentlyBindingActionName];
        currentlyBindingAction.action bindings = originalBinding.Split(',')
            .Select(b => new InputBinding { path = b.Trim() })
            .ToArray();

        currentBindings[currentlyBindingActionName] = originalBinding;
        UpdateBindingDisplay();
        ExitRebindUI();
    }
}

#!/usr/bin/env python3
import re
import sys
from typing import List, Tuple, Optional, Dict
from dataclasses import dataclass
import textwrap
import random

@dataclass
class RegexExplanation:
    """Holds the breakdown of a regex pattern."""
    match_groups: List[str]
    explanation_steps: List[Tuple[str, str]]
    full_pattern: str

class RegexShow:
    """Interactive regex testing tool with visual explanations."""

    def __init__(self):
        self.history: List[RegexExplanation] = []
        self.current_pattern = ""
        self.test_string = ""
        self.visual_chars = [
            "░", "▒", "▓", "█", "▚", "▝", "▛", "▄", "▁", "▀",
            "░", "▕", "▖", "▗", "▔", "▝", "▛", "▄", "▂", "▁"
        ]
        self.emoji_library = {
            'start': '🔮',
            'end': '🔚',
            'literal': '🔤',
            'quantifier': '🔢',
            'group': '🔗',
            'character_class': '🔡',
            'escape': '🛡️',
            'alternation': '⚖️',
            'wildcard': '✨'
        }

    def test_regex(self, pattern: str, test_str: str) -> RegexExplanation:
        """Test a regex pattern against a string and generate explanations."""
        self.current_pattern = pattern
        self.test_string = test_str
        matches = re.finditer(pattern, test_str, re.DEBUG)
        match_groups = [m.group(0) for m in matches]

        explanation_steps = self._generate_explanation_steps(pattern)

        return RegexExplanation(
            match_groups=match_groups,
            explanation_steps=explanation_steps,
            full_pattern=pattern
        )

    def _generate_explanation_steps(self, pattern: str) -> List[Tuple[str, str]]:
        """Break down the regex into step-by-step explanations."""
        steps = []
        components = self._tokenize_pattern(pattern)

        for i, (token, meta) in enumerate(components, 1):
            emoji = self.emoji_library.get(meta, '❓')
            explanation = self._get_explanation_for_token(token, meta)
            steps.append((f"Step {i}", f"{emoji} {explanation}"))

        return steps

    def _tokenize_pattern(self, pattern: str) -> List[Tuple[str, str]]:
        """Tokenize the regex pattern with metadata."""
        tokens = []
        i = 0
        n = len(pattern)

        while i < n:
            c = pattern[i]

            if c == '\\':
                if i + 1 < n:
                    tokens.append((pattern[i:i+2], 'escape'))
                    i += 2
                else:
                    tokens.append((c, 'escape'))
                    i += 1
            elif c in '.^$*+?{}[]|()':
                if c in '.^$*+?':
                    tokens.append((c, 'quantifier' if c in '*+' else 'special'))
                    i += 1
                elif c in '{}[]|()':
                    tokens.append((c, 'group' if c in '()' else 'character_class' if c in '[]' else 'alternation'))
                    i += 1
                else:
                    tokens.append((c, 'special'))
                    i += 1
            elif c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
                tokens.append((c, 'literal'))
                i += 1
            else:
                tokens.append((c, 'unknown'))
                i += 1

        return tokens

    def _get_explanation_for_token(self, token: str, meta: str) -> str:
        """Generate human-readable explanation for a token."""
        explanations = {
            'start': "Start of string anchor",
            'end': "End of string anchor",
            'literal': f"Exact character '{token}'",
            'quantifier': {
                '*': "Zero or more",
                '+': "One or more",
                '?': "Zero or one",
                '.': "Any single character",
                '^': "Start of line",
                '$': "End of line"
            }.get(token, f"Quantifier '{token}'"),
            'group': "Capturing group",
            'character_class': "Character class",
            'escape': f"Escaped character '{token}'",
            'alternation': "Alternation",
            'wildcard': "Wildcard match"
        }

        if meta in explanations:
            if isinstance(explanations[meta], dict):
                return explanations[meta].get(token, f"Quantifier '{token}'")
            return explanations[meta]
        return f"Token '{token}' with meta '{meta}'"

    def visualize_match(self, pattern: str, test_str: str) -> str:
        """Create a visual representation of the regex match."""
        matches = [m.span() for m in re.finditer(pattern, test_str, re.DEBUG)]

        if not matches:
            return "No matches found. Try a different pattern!"

        # Create a visual string with intensity based on match positions
        visual = []
        max_pos = max(m[1] for m in matches)
        for i in range(max_pos):
            if any(m[0] <= i < m[1] for m in matches):
                visual.append(random.choice(self.visual_chars[0::2]))
            else:
                visual.append(random.choice(self.visual_chars[1::2]))

        # Highlight matched characters
        highlighted = []
        for i, char in enumerate(test_str):
            if any(m[0] <= i < m[1] for m in matches):
                highlighted.append(f"\033[1;32m{char}\033[0m")
            else:
                highlighted.append(char)
        highlighted_str = ''.join(highlighted)

        return '\n'.join([
            f"Visual Match Intensity:",
            ''.join(visual),
            f"\nHighlighted Matches in '{test_str}':",
            highlighted_str
        ])

def clear_screen():
    """Clear the terminal screen."""
    print("\033[H\033[J", end="")

def main():
    """Run the Regex Magic Show."""
    show = RegexShow()

    print("""
    ▄▄▄▄    ▄▄▄       ▄▄▄▄    ▄▄▄       ▄▄▄       ▄▄▄
    █  █    █  █      █  █    █  █      █  █      █  █
    █  █    █  █      █  █    █  █      █  █      █  █
    █  █    █▄▄█      █  █    █▄▄█      █  █      █▄▄█
    █  █    █  █      █  █    █  █      █  █      █  █
    █  █    █  █      █  █    █  █      █  █      █  █
    █▄▄█    █  █      █▄▄█    █  █      █▄▄█      █▄▄█
    """)
    print("REGEX MAGIC SHOW - Type your regex pattern and a test string!")
    print("Type 'history' to see previous tests, 'clear' to clear the screen, 'quit' to exit.\n")

    while True:
        clear_screen()
        print("REGEX MAGIC SHOW\n")

        pattern_input = input("Enter your regex pattern: ").strip()
        if not pattern_input:
            continue

        if pattern_input.lower() == 'history':
            clear_screen()
            print("HISTORY\n")
            if not show.history:
                print("No history yet!")
                input("Press Enter to continue...")
                continue

            for i, entry in enumerate(show.history, 1):
                print(f"\n{i}. Pattern: {entry.full_pattern}")
                print(f"   Matches: {entry.match_groups}")
                print("   Explanation:")
                for step in entry.explanation_steps:
                    print(f"     {step[0]}: {step[1]}")
                print()

            input("Press Enter to return to main menu...")
            continue

        if pattern_input.lower() == 'clear':
            clear_screen()
            print("Screen cleared!\n")
            input("Press Enter to continue...")
            continue

        if pattern_input.lower() == 'quit':
            print("Thanks for playing Regex Magic Show! ✨")
            break

        test_str = input("Enter your test string: ").strip()
        if not test_str:
            print("Test string cannot be empty!")
            input("Press Enter to continue...")
            continue

        try:
            explanation = show.test_regex(pattern_input, test_str)
            show.history.append(explanation)

            clear_screen()
            print("REGEX MAGIC SHOW - RESULTS\n")

            print(f"Pattern: {explanation.full_pattern}")
            print(f"Test String: '{test_str}'")
            print(f"\nMatches Found: {len(explanation.match_groups)}")
            if explanation.match_groups:
                print(f"  Matched strings: {explanation.match_groups}")

            print("\nStep-by-Step Explanation:")
            for step in explanation.explanation_steps:
                print(f"  {step[0]}: {step[1]}")

            print("\n" + show.visualize_match(pattern_input, test_str))

            print("\nType 'history' to see previous tests, 'clear' to clear the screen, 'quit' to exit.")
            input("\nPress Enter to continue...")

        except re.error as e:
            print(f"Invalid regex: {e}")
            input("Press Enter to continue...")

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nGoodbye! 👋")
        sys.exit(0)

```swift
import SwiftUI
import CoreHaptics
import Combine

struct Flashcard: Identifiable, Codable, Equatable {
    let id = UUID()
    var question: String
    var answer: String
    var lastReviewed: Date?
    var difficulty: Double = 1.0 // 1 = easy, 3 = hard
    var currentInterval: Double = 1.0 // in days
    var nextReviewDate: Date?
    var isMastered: Bool = false

    var progress: Double {
        guard let lastReviewed = lastReviewed else { return 0.0 }
        let now = Date()
        let daysPassed = now.timeIntervalSince(lastReviewed) / (24 * 60 * 60)
        return min(daysPassed / currentInterval, 1.0)
    }

    mutating func updateBasedOnReview(shouldMaster: Bool, lastAnsweredCorrectly: Bool) {
        let now = Date()

        if shouldMaster {
            isMastered = true
            difficulty = max(difficulty - 0.2, 1.0)
            currentInterval = min(currentInterval * 2, 14.0) // max 14 days for mastered
        } else if lastAnsweredCorrectly {
            difficulty = max(difficulty - 0.1, 1.0)
            currentInterval *= 1.5
        } else {
            difficulty = min(difficulty + 0.1, 3.0)
            currentInterval = max(currentInterval * 0.8, 1.0)
        }

        nextReviewDate = now.addingTimeInterval(currentInterval * 24 * 60 * 60)
    }
}

class CardDeck: ObservableObject, Codable {
    @Published var cards: [Flashcard]
    private let hapticEngine = CHHapticEngine()
    private let persistenceKey = "MemoraCardDeck"

    init(cards: [Flashcard] = []) {
        self.cards = cards
        loadFromPersistence()
        setupHaptics()
    }

    func saveToPersistence() {
        if let encoded = try? JSONEncoder().encode(self) {
            UserDefaults.standard.set(encoded, forKey: persistenceKey)
        }
    }

    func loadFromPersistence() {
        if let data = UserDefaults.standard.data(forKey: persistenceKey),
           let loadedDeck = try? JSONDecoder().decode(CardDeck.self, from: data) {
            self.cards = loadedDeck.cards
        }
    }

    func addCard(question: String, answer: String) {
        let newCard = Flashcard(question: question, answer: answer)
        cards.append(newCard)
        saveToPersistence()
        setupHaptics()
    }

    func deleteCard(at offsets: IndexSet) {
        cards.remove(atOffsets: offsets)
        saveToPersistence()
    }

    func shuffleCards() {
        cards.shuffle()
    }

    func markAsMastered(at index: Int) {
        guard index < cards.count else { return }
        cards[index].isMastered = true
        saveToPersistence()
    }

    func updateCard(at index: Int, shouldMaster: Bool, lastAnsweredCorrectly: Bool) {
        guard index < cards.count else { return }
        cards[index].updateBasedOnReview(shouldMaster: shouldMaster, lastAnsweredCorrectly: lastAnsweredCorrectly)
        saveToPersistence()
    }

    private func setupHaptics() {
        guard CHHapticEngine.capabilitiesForHardware().supportsHaptics else { return }

        do {
            try hapticEngine.start()
        } catch {
            print("Haptic engine error: \(error.localizedDescription)")
        }
    }

    func triggerSuccessHaptic() {
        guard !hapticEngine.isPlaying else { return }

        let successIntensity = Float(cards.first(where: { $0.isMastered })?.difficulty ?? 1.0) / 3.0
        let pattern = CHHapticEvent(
            eventType: .hapticTransient,
            parameters: [
                CHHapticEventParameter(parameterID: .hapticIntensity, value: successIntensity),
                CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.5)
            ],
            relativeTime: 0,
            duration: 0.2
        )

        let event = CHHapticEvent(eventType: .hapticContinuous, parameters: [
            CHHapticEventParameter(parameterID: .hapticIntensity, value: 0.7),
            CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.3)
        ], startTime: 0, duration: 0.3)

        do {
            let pattern = try CHHapticPattern(events: [pattern, event], parameters: [])
            let player = try hapticEngine.makePlayer(with: pattern)
            try player.start(atTime: 0)
        } catch {
            print("Failed to play haptic pattern: \(error.localizedDescription)")
        }
    }
}

struct FlashcardView: View {
    @StateObject var deck = CardDeck()
    @State private var currentCardIndex = 0
    @State private var showingAnswer = false
    @State private var showAddCardSheet = false
    @State private var newQuestion = ""
    @State private var newAnswer = ""
    @State private var showDeckStats = false
    @State private var selectedCardIndex: Int?
    @State private var isCardMastered = false
    @State private var lastAnsweredCorrectly = true

    let hapticEngine = CHHapticEngine()

    var body: some View {
        NavigationStack {
            VStack(spacing: 20) {
                // Card Display
                ZStack {
                    RoundedRectangle(cornerRadius: 25)
                        .fill(
                            LinearGradient(
                                gradient: Gradient(colors: [Color.blue.opacity(0.2), Color.purple.opacity(0.2)]),
                                startPoint: .topLeading,
                                endPoint: .bottomTrailing
                            )
                        )
                        .frame(height: 200)
                        .shadow(color: .blue.opacity(0.3), radius: 10, x: 0, y: 5)

                    if showingAnswer {
                        VStack {
                            Text(deck.cards[currentCardIndex].answer)
                                .font(.title2)
                                .fontWeight(.semibold)
                                .multilineTextAlignment(.leading)
                                .padding()
                                .frame(maxWidth: .infinity, alignment: .leading)
                            HStack {
                                if deck.cards[currentCardIndex].isMastered {
                                    Image(systemName: "checkmark.circle.fill")
                                        .font(.caption)
                                        .foregroundColor(.green)
                                    Text("Mastered")
                                        .font(.caption)
                                        .fontWeight(.bold)
                                        .foregroundColor(.green)
                                }
                                Spacer()
                                Text("Difficulty: \(Int(deck.cards[currentCardIndex].difficulty))")
                                    .font(.caption)
                                    .fontWeight(.bold)
                                    .foregroundColor(deck.cards[currentCardIndex].difficulty < 1.5 ? .green : .red)
                            }
                            .padding(.top, 8)
                        }
                        .padding(.horizontal, 20)
                        .frame(maxWidth: .infinity, alignment: .leading)
                        .transition(.slide)
                    } else {
                        VStack(alignment: .leading) {
                            Text(deck.cards[currentCardIndex].question)
                                .font(.title2)
                                .fontWeight(.semibold)
                                .multilineTextAlignment(.leading)
                                .padding()
                            Spacer()
                            HStack {
                                Spacer()
                                Text("Progress: \(String(format: "%.0f", deck.cards[currentCardIndex].progress * 100))%")
                                    .font(.caption)
                                    .fontWeight(.bold)
                                    .foregroundColor(deck.cards[currentCardIndex].progress > 0.7 ? .green : .blue)
                            }
                            .padding(.bottom, 8)
                        }
                        .padding(.horizontal, 20)
                        .frame(maxWidth: .infinity, alignment: .leading)
                        .transition(.slide)
                    }
                }
                .onTapGesture {
                    withAnimation {
                        showingAnswer.toggle()
                    }
                    deck.triggerSuccessHaptic()
                }

                // Controls
                HStack(spacing: 20) {
                    Button(action: {
                        if currentCardIndex > 0 {
                            withAnimation {
                                currentCardIndex -= 1
                                showingAnswer = false
                            }
                        } else {
                            withAnimation {
                                currentCardIndex = deck.cards.count - 1
                                showingAnswer = false
                            }
                        }
                        deck.triggerSuccessHaptic()
                    }) {
                        Image(systemName: "chevron.left")
                            .font(.title2)
                            .frame(width: 50, height: 50)
                            .background(
                                LinearGradient(
                                    gradient: Gradient(colors: [Color.blue, Color.purple]),
                                    startPoint: .leading,
                                    endPoint: .trailing
                                )
                            )
                            .clipShape(Circle())
                            .shadow(color: .blue.opacity(0.3), radius: 3, x: 0, y: 1)
                    }

                    Spacer()

                    if showingAnswer {
                        Button(action: {
                            deck.updateCard(at: currentCardIndex, shouldMaster: isCardMastered, lastAnsweredCorrectly: lastAnsweredCorrectly)
                            deck.shuffleCards()
                            withAnimation {
                                currentCardIndex = (currentCardIndex + 1) % deck.cards.count
                                showingAnswer = false
                            }
                        }) {
                            Image(systemName: "arrow.right.circle.fill")
                                .font(.title2)
                                .frame(width: 50, height: 50)
                                .background(
                                    LinearGradient(
                                        gradient: Gradient(colors: [Color.green, Color.teal]),
                                        startPoint: .leading,
                                        endPoint: .trailing
                                    )
                                )
                                .clipShape(Circle())
                                .shadow(color: .green.opacity(0.3), radius: 3, x: 0, y: 1)
                        }
                    } else {
                        Button(action: {
                            withAnimation {
                                showingAnswer = true
                            }
                        }) {
                            Image(systemName: "arrow.right.circle.fill")
                                .font(.title2)
                                .frame(width: 50, height: 50)
                                .background(
                                    LinearGradient(
                                        gradient: Gradient(colors: [Color.blue, Color.purple]),
                                        startPoint: .leading,
                                        endPoint: .trailing
                                    )
                                )
                                .clipShape(Circle())
                                .shadow(color: .blue.opacity(0.3), radius: 3, x: 0, y: 1)
                        }
                    }
                }
                .padding(.bottom, 20)

                // Stats Button
                if deck.cards.count > 0 {
                    Button(action: { showDeckStats = true }) {
                        Label("Deck Stats", systemImage: "chart.bar.fill")
                            .font(.headline)
                            .foregroundColor(.blue)
                    }
                    .padding(.bottom)
                }

                Spacer()
            }
            .navigationTitle("Memora")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItemGroup(placement: .navigationBarTrailing) {
                    Button(action: { showAddCardSheet = true }) {
                        Label("Add Card", systemImage: "plus")
                            .font(.headline)
                            .foregroundColor(.blue)
                    }
                    Button(action: { sharingDeckStats() }) {
                        Label("Share", systemImage: "square.and.arrow.up")
                            .font(.headline)
                            .foregroundColor(.blue)
                    }
                }
            }
            .sheet(isPresented: $showAddCardSheet) {
                AddCardView(deck: deck, showAddCardSheet: $showAddCardSheet)
            }
            .sheet(item: $selectedCardIndex) { index in
                if let index = index, index < deck.cards.count {
                    CardDetailView(card: deck.cards[index], deck: deck)
                }
            }
            .sheet(isPresented: $showDeckStats) {
                DeckStatsView(deck: deck)
            }
            .onAppear {
                if deck.cards.isEmpty {
                    // Add some sample cards
                    deck.addCard(question: "What is the capital of France?", answer: "Paris")
                    deck.addCard(question: "What is the largest planet in our solar system?", answer: "Jupiter")
                    deck.addCard(question: "What is the chemical symbol for gold?", answer: "Au")
                    deck.addCard(question: "Who painted the Mona Lisa?", answer: "Leonardo da Vinci")
                    deck.addCard(question: "What is the square root of 64?", answer: "8")
                }
            }
            .onChange(of: deck.cards) { _ in deck.shuffleCards() }
        }
    }

    private func sharingDeckStats() {
        guard !deck.cards.isEmpty else { return }

        let masteredCount = deck.cards.filter { $0.isMastered }.count
        let totalCards = deck.cards.count
        let percentage = Double(masteredCount) / Double(totalCards) * 100

        let text = """
        Memora Deck Stats

        Total Cards: \(totalCards)
        Mastered: \(masteredCount) (\(String(format: "%.1f", percentage))%)

        Difficulty Breakdown:
        \(deck.cards.reduce(into: [Double: Int]()) { $0[$1.difficulty, default: 0] += 1 })
        """

        let av = UIActivityViewController(activityItems: [text], applicationActivities: nil)
        UIApplication.shared.windows.first?.rootViewController?.present(av, animated: true)
    }
}

struct AddCardView: View {
    @ObservedObject var deck: CardDeck
    @Binding var showAddCardSheet: Bool
    @State private var question = ""
    @State private var answer = ""
    @State private var isValid = false

    var body: some View {
        NavigationStack {
            Form {
                Section(header: Text("New Flashcard")) {
                    TextField("Question", text: $question)
                        .disableAutocorrection(true)
                        .textInputAutocapitalization(.sentences)
                        .onChange(of: question) { _ in validateInput() }

                    TextField("Answer", text: $answer)
                        .disableAutocorrection(true)
                        .textInputAutocapitalization(.sentences)
                        .onChange(of: answer) { _ in validateInput() }

                    Toggle("Mark as mastered immediately", isOn: Binding(
                        get: { deck.cards.last?.isMastered ?? false },
                        set: { isMastered in
                            if let lastIndex = deck.cards.last?.id {
                                deck.updateCard(at: deck.cards.firstIndex(where: { $0.id == lastIndex }) ?? 0,
                                                shouldMaster: isMastered, lastAnsweredCorrectly: true)
                            }
                        }
                    ))
                    .disabled(question.isEmpty || answer.isEmpty)
                }
            }
            .navigationTitle("Add Card")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .navigationBarLeading) {
                    Button("Cancel") {
                        showAddCardSheet = false
                    }
                }
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button("Add") {
                        if isValid {
                            deck.addCard(question: question, answer: answer)
                            showAddCardSheet = false
                        }
                    }
                    .disabled(!isValid)
                }
            }
        }
    }

    private func validateInput() {
        isValid = !question.isEmpty && !answer.isEmpty
    }
}

struct CardDetailView: View {
    let card: Flashcard
    @ObservedObject var deck: CardDeck
    @Environment(\.dismiss) var dismiss

    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 20) {
                HStack {
                    Text("Question")
                        .font(.headline)
                        .foregroundColor(.blue)
                    Spacer()
                    Text("Answer")
                        .font(.headline)
                        .foregroundColor(.blue)
                }
                .padding(.horizontal)

                Divider()

                VStack(alignment: .leading, spacing: 10) {
                    Text(card.question)
                        .font(.body)
                        .padding(.vertical, 8)
                        .frame(maxWidth: .infinity, alignment: .leading)

                    Divider()

                    Text(card.answer)
                        .font(.body)
                        .padding(.vertical, 8)
                        .frame(maxWidth: .infinity, alignment: .leading)
                }
                .background(
                    RoundedRectangle(cornerRadius: 10)
                        .fill(LinearGradient(
                            gradient: Gradient(colors: [Color.blue.opacity(0.1), Color.purple.opacity(0.1)]),
                            startPoint: .topLeading,
                            endPoint: .bottomTrailing
                        ))
                )
                .padding(.horizontal)

                Spacer()

                if card.isMastered {
                    VStack(spacing: 10) {
                        HStack {
                            Image(systemName: "checkmark.circle.fill")
                                .font(.title)
                                .foregroundColor(.green)
                            Text("Mastered!")
                                .font(.title2)
                                .fontWeight(.bold)
                                .foregroundColor(.green)
                        }

                        Text("You've mastered this card!")
                            .font(.body)
                            .foregroundColor(.secondary)
                            .multilineTextAlignment(.center)
                            .padding()
                    }
                    .padding()
                    .background(
                        RoundedRectangle(cornerRadius: 10)
                            .fill(Color.green.opacity(0.1))
                    )
                } else {