A!leys Galerie

```swift
import SwiftUI
import Combine

// MARK: - MODELS

struct Flashcard: Identifiable, Codable {
    let id = UUID()
    var question: String
    var answer: String
    var lastReview: Date?
    var difficulty: Int = 1

    var nextReview: Date? {
        guard let lastReview = lastReview else { return nil }
        return lastReview.addingTimeInterval(TimeInterval(difficulty * 24 * 3600))
    }
}

class FlashcardStore: ObservableObject {
    @Published var flashcards: [Flashcard] = []

    init() {
        load()
    }

    func save() {
        do {
            try PropertyListEncoder().encode(flashcards).write(to: getDocumentsDirectory().appendingPathComponent("flashcards.plist"))
        } catch {
            print("Save error: \(error)")
        }
    }

    func load() {
        let path = getDocumentsDirectory().appendingPathComponent("flashcards.plist")
        guard FileManager.default.fileExists(atPath: path.path) else {
            return
        }
        do {
            flashcards = try PropertyListDecoder().decode([Flashcard].self, from: Data(contentsOf: path))
        } catch {
            print("Load error: \(error)")
        }
    }

    func addFlashcard(question: String, answer: String) {
        let newCard = Flashcard(question: question, answer: answer)
        flashcards.append(newCard)
        save()
    }

    func updateFlashcard(_ flashcard: Flashcard, question: String? = nil, answer: String? = nil) {
        if let index = flashcards.firstIndex(where: { $0.id == flashcard.id }) {
            flashcards[index].question = question ?? flashcards[index].question
            flashcards[index].answer = answer ?? flashcards[index].answer
            flashcards[index].lastReview = Date()
            save()
        }
    }

    func deleteFlashcard(at offsets: IndexSet) {
        flashcards.remove(atOffsets: offsets)
        save()
    }

    func markAsReviewed(_ flashcard: Flashcard) {
        if let index = flashcards.firstIndex(where: { $0.id == flashcard.id }) {
            flashcards[index].lastReview = Date()
            flashcards[index].difficulty = min(flashcards[index].difficulty + 1, 5)
            save()
        }
    }

    func getNextFlashcard() -> Flashcard? {
        guard var now = Date().addingTimeInterval(-300) else { return nil } // Look 5 minutes back
        let candidates = flashcards.filter { $0.lastReview == nil || $0.nextReview! <= now }
        return candidates.sorted { $0.nextReview ?? Date.distantPast < $1.nextReview ?? Date.distantPast }.first
    }

    private func getDocumentsDirectory() -> URL {
        FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
    }
}

// MARK: - VIEWS

struct LuminaView: View {
    @StateObject private var store = FlashcardStore()
    @State private var showingAddCard = false
    @State private var currentFlashcard: Flashcard?
    @State private var showingEditCard = false
    @State private var editFlashcard: Flashcard?

    var body: some View {
        NavigationStack {
            VStack {
                if let card = currentFlashcard {
                    FlashcardDetailView(flashcard: card, onReview: { store.markAsReviewed(card) },
                                       onEdit: { editFlashcard = card; showingEditCard = true },
                                       onDelete: { currentFlashcard = nil; showingAddCard = true },
                                       onNext: { currentFlashcard = nil; showingAddCard = true })
                } else {
                    if !store.flashcards.isEmpty {
                        FlashcardsListView(store: store, onFlashcardTapped: { currentFlashcard = $0 })
                    } else {
                        EmptyStateView(action: { showingAddCard = true })
                    }
                }
            }
            .navigationTitle("Lumina")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { showingAddCard = true }) {
                        Image(systemName: "plus")
                    }
                }
            }
            .sheet(isPresented: $showingAddCard) {
                AddEditFlashcardView(store: store, isEditing: false, onDismiss: { showingAddCard = false })
            }
            .sheet(isPresented: $showingEditCard) {
                if let card = editFlashcard {
                    AddEditFlashcardView(store: store, isEditing: true, flashcard: card, onDismiss: {
                        showingEditCard = false
                    })
                }
            }
        }
    }
}

struct FlashcardDetailView: View {
    let flashcard: Flashcard
    let onReview: () -> Void
    let onEdit: () -> Void
    let onDelete: () -> Void
    let onNext: () -> Void

    @State private var showingAnswer = false
    @State private var scaleFactor: CGFloat = 0.95

    var body: some View {
        VStack(spacing: 40) {
            Text(flashcard.question)
                .font(.title2)
                .multilineTextAlignment(.center)
                .padding()
                .background(NeumorphicBackgroundView(scale: 1.1, isSelected: true))
                .clipShape(RoundedRectangle(cornerRadius: 24))
                .shadow(color: .black.opacity(0.1), radius: 5, x: 0, y: 2)
                .scaleEffect(scaleFactor)
                .animation(.spring(response: 0.4, dampingFraction: 0.6), value: showingAnswer)
                .onAppear {
                    withAnimation(.spring(response: 0.5, dampingFraction: 0.6)) {
                        scaleFactor = 1.0
                    }
                }

            if showingAnswer {
                VStack(spacing: 20) {
                    Text(flashcard.answer)
                        .font(.title3)
                        .multilineTextAlignment(.center)
                        .padding()
                        .background(NeumorphicBackgroundView(scale: 1.1, isSelected: true))
                        .clipShape(RoundedRectangle(cornerRadius: 24))
                        .shadow(color: .black.opacity(0.1), radius: 5, x: 0, y: 2)

                    Spacer()

                    HStack {
                        Spacer()
                        Button(action: onReview) {
                            Label("Reviewed", systemImage: "checkmark.circle.fill")
                                .font(.headline)
                                .padding()
                                .background(NeumorphicButtonBackground())
                                .clipShape(Circle())
                                .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                        }
                        Spacer()
                        Button(action: onNext) {
                            Label("Next", systemImage: "arrow.right.circle.fill")
                                .font(.headline)
                                .padding()
                                .background(NeumorphicButtonBackground())
                                .clipShape(Circle())
                                .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                        }
                        Spacer()
                    }
                }
                .padding(.vertical, 20)
            } else {
                Button(action: { showingAnswer = true }) {
                    Label("Show Answer", systemImage: "eye.fill")
                        .font(.headline)
                        .padding()
                        .background(NeumorphicButtonBackground())
                        .clipShape(Capsule())
                        .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                }
                .padding(.top, 40)

                HStack {
                    Spacer()
                    Button(action: onEdit) {
                        Label("Edit", systemImage: "pencil")
                            .font(.subheadline)
                            .padding()
                            .background(NeumorphicButtonBackground())
                            .clipShape(Circle())
                            .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                    }
                    Spacer()
                    Button(action: onDelete) {
                        Label("Delete", systemImage: "trash")
                            .font(.subheadline)
                            .foregroundColor(.red)
                            .padding()
                            .background(NeumorphicButtonBackground())
                            .clipShape(Circle())
                            .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
                    }
                    Spacer()
                }
            }
        }
        .padding()
    }
}

struct FlashcardsListView: View {
    @ObservedObject var store: FlashcardStore
    let onFlashcardTapped: (Flashcard) -> Void

    var body: some View {
        if store.flashcards.isEmpty {
            EmptyStateView(action: { })
        } else {
            List {
                ForEach(store.flashcards.sorted(by: { $0.nextReview ?? Date.distantPast < $1.nextReview ?? Date.distantPast })) { card in
                    FlashcardRow(flashcard: card, onTap: { onFlashcardTapped(card) })
                }
                .listRowBackground(Color.clear)
                .listRowSeparator(.hidden)
            }
            .listStyle(PlainListStyle())
            .padding(.horizontal)
        }
    }
}

struct FlashcardRow: View {
    let flashcard: Flashcard
    let onTap: () -> Void

    var timeRemaining: String {
        guard let next = flashcard.nextReview else { return "New" }
        let components = Calendar.current.dateComponents([.day, .hour, .minute], from: Date(), to: next)
        var result = ""
        if let day = components.day, day > 0 { result = "\(day)d" }
        if let hour = components.hour, hour > 0 || result.isEmpty { result = "\(hour)h\(result)" }
        if let minute = components.minute, minute > 0 || result.isEmpty { result = "\(minute)m\(result)" }
        return result
    }

    var difficultyColor: Color {
        switch flashcard.difficulty {
        case 1: return .green
        case 2: return .green.opacity(0.7)
        case 3: return .yellow
        case 4: return .orange
        case 5: return .red
        default: return .green
        }
    }

    var body: some View {
        Button(action: onTap) {
            HStack(spacing: 16) {
                VStack(alignment: .leading, spacing: 4) {
                    Text(flashcard.question.prefix(20))
                        .font(.headline)
                        .lineLimit(1)

                    Text(timeRemaining)
                        .font(.caption)
                        .foregroundColor(.secondary)

                    HStack {
                        Text("Difficulty \(flashcard.difficulty)")
                        Spacer()
                        Image(systemName: "star.fill")
                            .foregroundColor(difficultyColor)
                    }
                    .font(.caption)
                }

                Spacer()

                Image(systemName: "chevron.right")
                    .foregroundColor(.secondary)
            }
            .padding(.vertical, 8)
            .background(NeumorphicListRowBackground())
            .cornerRadius(12)
            .shadow(color: .black.opacity(0.1), radius: 2, x: 0, y: 1)
        }
    }
}

struct AddEditFlashcardView: View {
    @ObservedObject var store: FlashcardStore
    @Environment(\.dismiss) private var dismiss

    let isEditing: Bool
    var flashcard: Flashcard?
    let onDismiss: () -> Void

    @State private var question: String = ""
    @State private var answer: String = ""
    @State private var difficulty: Int = 1

    var body: some View {
        NavigationStack {
            Form {
                Section {
                    TextField("Question", text: $question)
                        .font(.headline)
                        .multilineTextAlignment(.leading)

                    TextField("Answer", text: $answer)
                        .font(.headline)
                        .multilineTextAlignment(.leading)
                }

                Section {
                    Picker("Difficulty", selection: $difficulty) {
                        ForEach(1..<6) { level in
                            Text("Level \(level)").tag(level)
                        }
                    }
                    .pickerStyle(.segmented)
                    .padding(.horizontal)

                    HStack {
                        Text("Preview")
                        Spacer()
                        Text(difficulty == 1 ? "Easy" : difficulty == 5 ? "Hard" : "Balanced")
                    }
                    .font(.caption)
                    .foregroundColor(.secondary)
                }
            }
            .navigationTitle(isEditing ? "Edit Flashcard" : "New Flashcard")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button(action: saveFlashcard) {
                        Text(isEditing ? "Update" : "Add")
                    }
                }
                ToolbarItem(placement: .cancellationAction) {
                    Button(action: dismissFlashcard) {
                        Text("Cancel")
                    }
                }
            }
        }
    }

    private func saveFlashcard() {
        if !question.isEmpty && !answer.isEmpty {
            if isEditing, let card = flashcard {
                store.updateFlashcard(card, question: question, answer: answer)
            } else {
                store.addFlashcard(question: question, answer: answer)
            }
            dismiss()
            onDismiss()
        }
    }

    private func dismissFlashcard() {
        dismiss()
        onDismiss()
    }
}

struct EmptyStateView: View {
    let action: () -> Void

    var body: some View {
        VStack(spacing: 20) {
            Image(systemName: "note.text")
                .font(.system(size: 50))
                .foregroundColor(.secondary)

            Text("No flashcards yet")
                .font(.title2)
                .foregroundColor(.secondary)

            Text("Tap the + button to add your first flashcard")
                .font(.subheadline)
                .foregroundColor(.secondary.opacity(0.7))
                .multilineTextAlignment(.center)

            Button(action: action) {
                Label("Add First Flashcard", systemImage: "plus.circle.fill")
                    .font(.headline)
                    .padding()
                    .background(NeumorphicButtonBackground())
                    .clipShape(Circle())
                    .shadow(color: .black.opacity(0.2), radius: 3, x: 0, y: 1)
            }
        }
        .padding()
    }
}

// MARK: - NEUMORPHIC STYLES

struct NeumorphicBackgroundView: View {
    let scale: CGFloat
    let isSelected: Bool

    var body: some View {
        RoundedRectangle(cornerRadius: 24)
            .fill(
                LinearGradient(
                    gradient: Gradient(colors: [
                        isSelected ? Color.white : Color-white.opacity(0.9),
                        isSelected ? Color-white.opacity(0.7) : Color.white
                    ]),
                    startPoint: .topLeading,
                    endPoint: .bottomTrailing
                )
            )
            .shadow(
                color: isSelected ? Color.black.opacity(0.1) : Color.black.opacity(0.05),
                radius: scale * 2,
                x: scale,
                y: scale
            )
            .shadow(
                color: isSelected ? Color.white.opacity(0.3) : Color.white.opacity(0.15),
                radius: scale * 2,
                x: -scale,
                y: -scale
            )
    }
}

struct NeumorphicListRowBackground: ViewModifier {
    func body(matcher: View) -> some View {
        matcher
            .background(
                RoundedRectangle(cornerRadius: 12)
                    .fill(
                        LinearGradient(
                            gradient: Gradient(colors: [
                                Color.white.opacity(0.85),
                                Color.white.opacity(0.9)
                            ]),
                            startPoint: .topLeading,
                            endPoint: .bottomTrailing
                        )
                    )
                    .shadow(
                        color: Color.black.opacity(0.05),
                        radius: 3,
                        x: 1.5,
                        y: 1.5
                    )
                    .shadow(
                        color: Color.white.opacity(0.1),
                        radius: 3,
                        x: -1.5,
                        y: -1.5
                    )
            )
    }
}

struct NeumorphicButtonBackground: ViewModifier {
    func body(matcher: View) -> some View {
        matcher
            .background(
                RoundedRectangle(cornerRadius: 16)
                    .fill(
                        LinearGradient(
                            gradient: Gradient(colors: [
                                Color.white.opacity(0.9),
                                Color.white.opacity(0.95)
                            ]),
                            startPoint: .topLeading,
                            endPoint: .bottomTrailing
                        )
                    )
                    .shadow(
                        color: Color.black.opacity(0.1),
                        radius: 2,
                        x: 1,
                        y: 1
                    )
                    .shadow(
                        color: Color.white.opacity(0.2),
                        radius: 2,
                        x: -1,
                        y: -1
                    )
            )
    }
}

extension View {
    func neumorphicBackground() -> some View {
        self.modifier(NeumorphicListRowBackground())
    }
}

// MARK: - PREVIEW

struct LuminaView_Previews: PreviewProvider {
    static var previews: some View {
        LuminaView()
            .previewDevice("iPhone 13 Pro")
            .previewDisplayName("Lumina