A!leys Galerie

```swift
import SwiftUI
import CoreData
import CoreHaptics
import UniformTypeIdentifiers

// MARK: - CoreData Setup

extension MemoryMazeApp {
    static let shared = MemoryMazeApp()

    static var preview: MemoryMazeApp = {
        let result = MemoryMazeApp()
        let container = NSPersistentContainer(name: "MemoryMazeCoreData")
        container.persistentStoreDescriptions.first!.url = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: "group.com.ailey.memorymaze")?.appendingPathComponent("MemoryMazeCoreData.sqlite")
        container.loadPersistentStores { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        }
        result.container = container
        return result
    }()

    @Environment(\.managedObjectContext) private var viewContext

    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "MemoryMazeCoreData")
        container.loadPersistentStores { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        }
        return container
    }()

    var managedObjectContext: NSManagedObjectContext {
        return persistentContainer.viewContext
    }

    func save() {
        if managedObjectContext.hasChanges {
            do {
                try managedObjectContext.save()
            } catch {
                let nserror = error as NSError
                fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
            }
        }
    }
}

class Note: NSManagedObject, Identifiable {
    @NSManaged var title: String
    @NSManaged var content: String
    @NSManaged var positionX: Double
    @NSManaged var positionY: Double
    @NSManaged var color: String
    @NSManaged var isLocked: Bool
    @NSManaged var createdAt: Date
    @NSManaged var updatedAt: Date

    var coordinates: (x: Double, y: Double) {
        return (positionX, positionY)
    }
}

class NoteColor: NSManagedObject, Identifiable {
    @NSManaged var name: String
    @NSManaged var hexColor: String
}

class MemoryMazeApp: NSObject, ObservableObject {
    @Published var notes: [Note] = []
    @Published var selectedNote: Note?
    @Published var showAddNoteSheet = false
    @Published var showNoteDetail = false
    @Published var showColorPicker = false
    @Published var selectedColor: String = "FF5722"
    @Published var mazeSize: Double = 300
    @Published var mazeLevel: Int = 1
    @Published var showSettings = false
    @Published var isEditing = false
    @Published var searchText: String = ""
    @Published var showDeleteAlert = false

    lazy var engine = try? CHHapticEngine()

    override init() {
        super.init()
        fetchNotes()
        fetchColors()
        setupHaptics()
    }

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

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

    func fetchNotes() {
        let fetchRequest: NSFetchRequest<Note> = Note.fetchRequest()
        do {
            notes = try viewContext.fetch(fetchRequest)
            notes.sort { $0.createdAt > $1.createdAt }
        } catch {
            print("Fetch failed: \(error)")
        }
    }

    func fetchColors() {
        let fetchRequest: NSFetchRequest<NoteColor> = NoteColor.fetchRequest()
        do {
            let colors = try viewContext.fetch(fetchRequest)
            if colors.isEmpty {
                let defaultColors = [
                    NoteColor(name: "Red", hexColor: "FF5722"),
                    NoteColor(name: "Blue", hexColor: "2196F3"),
                    NoteColor(name: "Green", hexColor: "4CAF50"),
                    NoteColor(name: "Yellow", hexColor: "FFEB3B"),
                    NoteColor(name: "Purple", hexColor: "9C27B0")
                ]

                for color in defaultColors {
                    viewContext.insert(color)
                }

                try viewContext.save()
            }
        } catch {
            print("Fetch colors failed: \(error)")
        }
    }

    func saveNote(_ note: Note) {
        note.updatedAt = Date()
        do {
            try viewContext.save()
            fetchNotes()
        } catch {
            print("Save note failed: \(error)")
        }
    }

    func addNote(title: String, content: String, position: (x: Double, y: Double) = (0, 0)) {
        let note = Note(context: viewContext)
        note.title = title
        note.content = content
        note.positionX = position.x
        note.positionY = position.y
        note.color = selectedColor
        note.isLocked = false
        note.createdAt = Date()
        note.updatedAt = Date()

        saveNote(note)
    }

    func deleteNote(_ note: Note) {
        viewContext.delete(note)
        save()
    }

    func toggleLock(_ note: Note) {
        note.isLocked.toggle()
        saveNote(note)
    }

    func updateNoteColor(_ note: Note, color: String) {
        note.color = color
        saveNote(note)
    }

    func changeMazeSize(size: Double) {
        mazeSize = size
    }

    func increaseMazeLevel() {
        mazeLevel = min(mazeLevel + 1, 5)
    }

    func decreaseMazeLevel() {
        mazeLevel = max(mazeLevel - 1, 1)
    }

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

        let intensity = CHHapticEventParameter(parameterID: .hapticIntensity, value: 0.5)
        let sharpness = CHHapticEventParameter(parameterID: .hapticSharpness, value: 0.3)

        let event = CHHapticEvent(eventType: .click, parameters: [intensity, sharpness], relativeTime: 0)

        do {
            let pattern = try CHHapticPattern(events: [event], parameters: [])
            try engine?.play(pattern)
        } catch {
            print("Failed to play pattern: \(error.localizedDescription)")
        }
    }

    func save() {
        do {
            try viewContext.save()
            fetchNotes()
        } catch {
            let nserror = error as NSError
            print("Unresolved error \(nserror), \(nserror.userInfo)")
        }
    }
}

// MARK: - Models

struct NotePreview: View {
    var note: Note

    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(note.title)
                .font(.headline)
            Text(note.content)
                .font(.subheadline)
                .lineLimit(2)
        }
        .padding(8)
        .background(Color.white.opacity(0.9))
        .cornerRadius(8)
        .shadow(radius: 2)
    }
}

// MARK: - Views

struct MemoryMazeNoteView: View {
    @ObservedObject var app: MemoryMazeApp
    @State private var isEditing = false
    @State private var noteContent = ""
    @State private var noteTitle = ""

    var note: Note

    init(app: MemoryMazeApp, note: Note) {
        self.app = app
        self.note = note
    }

    var body: some View {
        VStack(spacing: 16) {
            HStack {
                if note.isLocked {
                    Image(systemName: "lock.fill")
                        .font(.caption)
                        .foregroundColor(.gray)
                }

                Text(note.title)
                    .font(.headline)
                    .lineLimit(1)

                Spacer()

                if note.isLocked {
                    Button(action: {
                        app.toggleLock(note)
                        app.playHapticFeedback()
                    }) {
                        Image(systemName: "lock.open.fill")
                            .font(.caption)
                            .foregroundColor(.blue)
                    }
                }
            }

            if isEditing {
                VStack(alignment: .leading, spacing: 8) {
                    TextField("Title", text: $noteTitle, prompt: Text("Title"))
                        .font(.headline)
                        .textFieldStyle(.roundedBorder)

                    ScrollView {
                        VStack(alignment: .leading, spacing: 4) {
                            TextEditor(text: .constant(note.content))
                                .font(.body)
                                .frame(minHeight: 100)
                        }
                    }
                    .frame(maxHeight: 200)
                }
                .padding(8)
                .background(Color(.systemBackground))
                .cornerRadius(12)
                .shadow(radius: 4)
                .padding(.horizontal, 8)
            } else {
                Text(note.content)
                    .font(.body)
                    .lineLimit(5)
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding(.horizontal, 8)
                    .padding(.vertical, 4)
            }

            HStack {
                Button(action: {
                    isEditing.toggle()
                    if !isEditing {
                        note.title = noteTitle
                        note.content = noteContent
                        app.saveNote(note)
                    }
                    app.playHapticFeedback()
                }) {
                    Text(isEditing ? "Done" : "Edit")
                        .font(.caption)
                        .fontWeight(.semibold)
                        .foregroundColor(.white)
                        .padding(.horizontal, 8)
                        .padding(.vertical, 4)
                        .background(Color.blue)
                        .cornerRadius(6)
                }

                Spacer()

                Button(action: {
                    app.showColorPicker = true
                    app.playHapticFeedback()
                }) {
                    Circle()
                        .fill(Color(note.color, bundle: nil))
                        .frame(width: 24, height: 24)
                }
                .sheet(isPresented: $app.showColorPicker) {
                    ColorPickerView(app: app, selectedColor: $app.selectedColor, currentColor: note.color)
                }
            }
            .padding(.horizontal, 8)
        }
        .background(
            RoundedRectangle(cornerRadius: 16)
                .fill(Color(note.color, bundle: nil).opacity(0.2))
                .shadow(color: Color(note.color, bundle: nil).opacity(0.3), radius: 8, x: 0, y: 4)
        )
        .frame(width: 120, height: 160)
        .cornerRadius(16)
        .shadow(radius: 8)
        .offset(x: note.positionX, y: note.positionY)
        .gesture(
            DragGesture()
                .onEnded { value in
                    if !note.isLocked && !isEditing {
                        let newX = min(max(note.positionX + value.translation.width, -50), 50)
                        let newY = min(max(note.positionY + value.translation.height, -50), 50)

                        note.positionX = newX
                        note.positionY = newY
                        app.saveNote(note)
                        app.playHapticFeedback()
                    }
                }
        )
        .onAppear {
            noteTitle = note.title
            noteContent = note.content
        }
    }
}

struct ColorPickerView: View {
    @ObservedObject var app: MemoryMazeApp
    @Binding var selectedColor: String
    var currentColor: String

    let colorOptions: [String] = ["FF5722", "2196F3", "4CAF50", "FFEB3B", "9C27B0", "00BCD4", "8BC34A", "FF9800"]

    var body: some View {
        VStack(spacing: 24) {
            Text("Choose Color")
                .font(.title2)
                .fontWeight(.bold)

            VStack(spacing: 12) {
                ForEach(colorOptions, id: \.self) { color in
                    Button(action: {
                        selectedColor = color
                        app.updateNoteColor(app.selectedNote!, color: color)
                        app.showColorPicker = false
                        app.playHapticFeedback()
                    }) {
                        Circle()
                            .fill(Color(color, bundle: nil))
                            .frame(width: 50, height: 50)
                            .shadow(radius: 4)
                            .overlay(
                                Circle()
                                    .stroke(Color.white.opacity(0.3), lineWidth: 2)
                            )
                    }
                    .buttonStyle(PlainButtonStyle())
                }
            }

            Text(currentColor)
                .font(.caption)
                .fontWeight(.light)
                .foregroundColor(.gray)
        }
        .padding()
        .frame(width: 280, height: 400)
        .background(Color(.systemBackground))
        .cornerRadius(16)
        .shadow(radius: 8)
    }
}

struct AddNoteView: View {
    @ObservedObject var app: MemoryMazeApp
    @Environment(\.dismiss) var dismiss

    @State private var noteTitle = ""
    @State private var noteContent = ""

    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("New Note")) {
                    TextField("Title", text: $noteTitle, prompt: Text("Title"))
                        .autocapitalization(.words)
                        .disableAutocorrection(true)

                    TextEditor(text: .constant(noteContent))
                        .font(.body)
                        .frame(minHeight: 150)
                        .overlay(
                            Text("Write your note here...")
                                .foregroundColor(.gray.opacity(0.5))
                                .padding(.horizontal, 8)
                                .padding(.vertical, 16)
                        )
                }

                Section {
                    Button(action: {
                        if !noteTitle.isEmpty || !noteContent.isEmpty {
                            app.addNote(title: noteTitle, content: noteContent)
                            dismiss()
                            app.playHapticFeedback()
                        }
                    }) {
                        Text("Save Note")
                            .fontWeight(.semibold)
                            .frame(maxWidth: .infinity)
                    }
                }
            }
            .navigationTitle("Add Note")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button("Cancel") {
                        dismiss()
                    }
                }
            }
        }
    }
}

struct MemoryMazeMainView: View {
    @ObservedObject var app = MemoryMazeApp.shared
    @State private var isAddingNote = false
    @State private var mazeSize: Double = 300
    @State private var mazeLevel: Int = 1
    @State private var selectedNote: Note?
    @State private var searchText: String = ""

    var filteredNotes: [Note] {
        if searchText.isEmpty {
            return app.notes
        } else {
            return app.notes.filter { note in
                note.title.localizedCaseInsensitiveContains(searchText) ||
                note.content.localizedCaseInsensitiveContains(searchText)
            }
        }
    }

    var body: some View {
        NavigationView {
            ZStack {
                // Maze Background
                Color(.systemBackground)
                    .ignoresSafeArea()

                // Maze Grid
                ForEach(0..<mazeLevel*5, id: \.self) { x in
                    ForEach(0..<mazeLevel*5, id: \.self) { y in
                        Rectangle()
                            .fill(Color.gray.opacity(0.1))
                            .frame(width: mazeSize / 5, height: mazeSize / 5)
                            .offset(x: mazeSize / 5 * Double(x), y: mazeSize / 5 * Double(y))
                    }
                }

                // Notes
                ForEach(filteredNotes) { note in
                    MemoryMazeNoteView(app: app, note: note)
                        .onTapGesture {
                            selectedNote = note
                            app.selectedNote = note
                            app.showNoteDetail = true
                        }
                }

                // Add Note Button (Floating Action Button)
                Button(action: {
                    isAddingNote = true
                }) {
                    Image(systemName: "plus.circle.fill")
                        .font(.title)
                        .foregroundColor(.white)
                        .padding(12)
                        .background(Color.blue)
                        .clipShape(Circle())
                        .shadow(radius: 10)
                }
                .offset(y: 100)
                .sheet(isPresented: $isAddingNote) {
                    AddNoteView(app: app)
                }

                // Search
                SearchView(app: app, searchText: $searchText)
                    .padding(.top, 10)
            }
            .navigationTitle("Memory Maze")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: {
                        app.showSettings = true
                    }) {
                        Image(systemName: "slider.horizontal.3")
                            .font(.caption)
                    }
                }
            }
            .sheet(isPresented: $app.showSettings) {
                SettingsView(app: app)
            }
            .sheet(item: $selectedNote) { note in
                NoteDetailView(app: app, note: note)
            }
        }
        .preferredColorScheme(.light)
    }
}

struct SearchView: View {
    @ObservedObject var app: MemoryMazeApp
    @Binding var searchText: String

    var body: some View

import SwiftUI
import CoreData

@main
struct WhimsyNotesApp: App {
    let persistenceController = PersistenceController.shared

    var body: some Scene {
        WindowGroup {
            NotesListView()
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
                .keyboardShortcuts([
                    KeyboardShortcut("N", modifiers: [.command], action: AddNoteAction()),
                    KeyboardShortcut("E", modifiers: [.command, .shift], action: EditNoteAction()),
                    KeyboardShortcut("D", modifiers: [.command, .shift], action: DeleteNoteAction())
                ])
        }
    }
}

class PersistenceController: ObservableObject {
    static let shared = PersistenceController()
    let container: NSPersistentContainer

    init() {
        container = NSPersistentContainer(name: "WhimsyNotes")
        container.loadPersistentStores { description, error in
            if let error = error {
                fatalError("CoreData failed to load: \(error.localizedDescription)")
            }
        }
    }

    func save() {
        do {
            try container.viewContext.save()
        } catch {
            let nsError = error as NSError
            fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
        }
    }
}

struct Note: Identifiable, PersistentModel {
    @Attribute var id: String
    @Attribute var title: String
    @Attribute var content: String
    @Attribute var color: String
    @Attribute var emoji: String
}

struct NotesListView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Note.title, ascending: true)],
        animation: .default
    ) private var notes: FetchedResults<Note>

    @State private var newTitle = ""
    @State private var newContent = ""
    @State private var selectedColor = Color.blue.opacity(0.7)
    @State private var selectedEmoji = "😊"

    var body: some View {
        NavigationView {
            List {
                ForEach(notes) { note in
                    NoteRow(note: note, selectedColor: selectedColor, selectedEmoji: selectedEmoji)
                        .onTapGesture {
                            withAnimation {
                                selectedColor = Color(note.color)
                                selectedEmoji = note.emoji
                            }
                        }
                }
                .onDelete { indices in
                    let objects = indices.map { notes[$0] }
                    deleteObjects(objects)
                }
            }
            .navigationTitle("WhimsyNotes")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    EditButton()
                }
                ToolbarItem(placement: .navigationBarTrailing) {
                    AddButton { withAnimation {
                        let newNote = Note(context: viewContext)
                        newNote.id = UUID().uuidString
                        newNote.title = newTitle
                        newNote.content = newContent
                        newNote.color = selectedColor.description
                        newNote.emoji = selectedEmoji
                        do {
                            try viewContext.save()
                            newTitle = ""
                            newContent = ""
                        } catch {
                            print("Save failed: \(error)")
                        }
                    }}
                }
            }
            .sheet(isPresented: .constant(false)) { // Placeholder for edit sheet
                EmptyView()
            }
        }
    }

    private func deleteObjects(_ notes: [Note]) {
        notes.forEach { viewContext.delete($0) }
        PersistenceController.shared.save()
    }
}

struct NoteRow: View {
    let note: Note
    let selectedColor: Color
    let selectedEmoji: String

    var body: some View {
        HStack(spacing: 12) {
            Circle()
                .fill(Color(note.color))
                .frame(width: 40, height: 40)
                .overlay(
                    Text(note.emoji)
                        .font(.system(size: 20))
                )
            VStack(alignment: .leading, spacing: 4) {
                Text(note.title)
                    .font(.headline)
                Text(note.content)
                    .font(.subheadline)
                    .foregroundColor(.secondary)
                if note.content.count > 20 {
                    Text("...")
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
            }
        }
        .padding(.vertical, 8)
        .transition(.opacity.combined(with: .scale))
    }
}

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

    var body: some View {
        Button(action: action) {
            Image(systemName: "plus")
        }
    }
}

struct EditButton: View {
    var body: some View {
        Button("Edit") {
            print("Edit")
        }
    }
}

struct AddNoteAction: KeyboardShortcutProvider {
    var keyboardShortcuts: [KeyboardShortcut<NoteAction>] {
        [KeyboardShortcut("N", modifiers: [.command], action: NoteAction.add)]
    }
}

struct EditNoteAction: KeyboardShortcutProvider {
    var keyboardShortcuts: [KeyboardShortcut<NoteAction>] {
        [KeyboardShortcut("E", modifiers: [.command, .shift], action: NoteAction.edit)]
    }
}

struct DeleteNoteAction: KeyboardShortcutProvider {
    var keyboardShortcuts: [KeyboardShortcut<NoteAction>] {
        [KeyboardShortcut("D", modifiers: [.command, .shift], action: NoteAction.delete)]
    }
}

enum NoteAction: KeyboardShortcutPhase {
    case add, edit, delete

    var shortcutPhase: KeyboardShortcutPhase {
        self
    }

    var displayRepresentation: String? {
        switch self {
        case .add: return "Add Note"
        case .edit: return "Edit Note"
        case .delete: return "Delete Note"
        }
    }
}

struct WhimsyNotes_Previews: PreviewProvider {
    static var previews: some View {
        NotesListView()
            .environment(\.managedObjectContext, PersistenceController.shared.container.viewContext)
    }
}