A!leys Galerie

import SwiftUI
import CoreData

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

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
        }
    }
}

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

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

    func save() {
        do {
            try container.viewContext.save()
        } catch {
            print("Error saving: \(error)")
        }
    }
}

struct ContentView: View {
    @Environment(\.managedObjectContext) var viewContext
    @State private var showingAddNote = false
    @FetchRequest(entity: Note.entity(),
                  sortDescriptors: [NSSortDescriptor(keyPath: \Note.date, ascending: false)])
    var notes: [Note]

    var body: some View {
        NavigationStack {
            List {
                ForEach(notes) { note in
                    NavigationLink {
                        NoteDetailView(note: note)
                    } label: {
                        VStack(alignment: .leading) {
                            Text(note.title ?? "Unbenannt")
                                .font(.headline)
                            Text(note.content.prefix(50) + (note.content.count > 50 ? "..." : ""))
                                .font(.subheadline)
                                .foregroundColor(.secondary)
                            Stimmungsleiste(stimmung: note.moodValue)
                        }
                    }
                }
                .onDelete(perform: deleteNotes)
            }
            .navigationTitle("MoodNotes")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button {
                        showingAddNote = true
                    } label: {
                        Image(systemName: "plus")
                    }
                }
            }
            .sheet(isPresented: $showingAddNote) {
                AddNoteView()
            }
        }
    }

    private func deleteNotes(offsets: IndexSet) {
        withAnimation {
            offsets.map { notes[$0] }.forEach(viewContext.delete)
            PersistenceController.shared.save()
        }
    }
}

struct NoteDetailView: View {
    @Environment(\.dismiss) var dismiss
    @ObservedObject var note: Note
    @State private var content: String = ""

    init(note: Note) {
        _note = ObservedObject(wrappedValue: note)
        _content = State(initialValue: note.content ?? "")
    }

    var body: some View {
        VStack(alignment: .leading) {
            Stimmungsleiste(stimmung: note.moodValue, height: 15)
            Form {
                Section(header: Text("Titel")) {
                    TextField("Notiz Titel", text: Binding(
                        get: { note.title ?? "" },
                        set: { newValue in note.title = newValue }
                    ))
                }

                Section(header: Text("Inhalt")) {
                    TextEditor(text: $content)
                        .onChange(of: content) { _ in
                            note.content = content
                            PersistenceController.shared.save()
                        }
                }

                Section(header: Text("Stimmung")) {
                    Slider(value: Binding(
                        get: { Double(note.moodValue) },
                        set: { newValue in note.moodValue = Int(newValue.rounded()) }
                    ), in: 0...10, step: 1) { edited in
                        Text("Stimmung: \(edited, specifier: "%.0f")")
                    }
                    .onChange(of: note.moodValue) { _ in
                        PersistenceController.shared.save()
                    }
                }
            }
        }
        .navigationTitle("Notiz bearbeiten")
        .navigationBarTitleDisplayMode(.inline)
        .toolbar {
            ToolbarItem(placement: .navigationBarTrailing) {
                Button("Fertig") {
                    dismiss()
                }
            }
        }
        .onAppear {
            content = note.content ?? ""
        }
    }
}

struct AddNoteView: View {
    @Environment(\.dismiss) var dismiss
    @Environment(\.managedObjectContext) var viewContext
    @State private var title = ""
    @State private var content = ""
    @State private var moodValue = 5
    @State private var showingSuccess = false

    var body: some View {
        NavigationStack {
            Form {
                Section(header: Text("Notiz erstellen")) {
                    TextField("Titel", text: $title)
                    TextEditor(text: $content)
                        .frame(height: 200)
                    Stimmungsleiste(stimmung: moodValue, height: 15)
                    HStack {
                        Text("Stimmung: \(moodValue, specifier: "%.0f")")
                        Spacer()
                        Slider(value: $moodValue, in: 0...10, step: 1)
                    }
                }
            }
            .navigationTitle("Neue Notiz")
            .toolbar {
                ToolbarItem(placement: .navigationBarLeading) {
                    Button("Abbrechen") {
                        dismiss()
                    }
                }
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button("Speichern") {
                        saveNote()
                        dismiss()
                    }
                    .disabled(title.isEmpty)
                }
            }
            .alert("Erfolg!", isPresented: $showingSuccess) {
                Button("OK", role: .cancel) { }
            } message: {
                Text("Notiz wurde erfolgreich gespeichert!")
            }
        }
    }

    private func saveNote() {
        withAnimation {
            let newNote = Note(context: viewContext)
            newNote.title = title
            newNote.content = content
            newNote.moodValue = Int(moodValue.rounded())
            newNote.date = Date()

            do {
                try viewContext.save()
                showingSuccess = true
            } catch {
                print("Error saving note: \(error)")
            }
        }
    }
}

struct Stimmungsleiste: View {
    var stimmung: Int
    var height: CGFloat = 5

    private let stimmungFarben = [
        (0, Color.red),
        (2, Color.orange),
        (4, Color.yellow),
        (6, Color.green),
        (8, Color.blue),
        (10, Color.purple)
    ]

    var body: some View {
        GeometryReader { geometry in
            ZStack(alignment: .leading) {
                ForEach(0..<11) { value in
                    Rectangle()
                        .fill(value <= stimmung ? stimmungFarben.first(where: { $0.0 >= value })?.1 ?? Color.gray : Color.clear)
                        .frame(width: geometry.size.width / 10, height: height)
                }
            }
            .cornerRadius(3)
        }
        .frame(height: height)
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        let context = PersistenceController.shared.container.viewContext
        let previewNote = Note(context: context)
        previewNote.title = "Erste Notiz"
        previewNote.content = "Dies ist meine erste MoodNote. Ich fühle mich heute..."
        previewNote.moodValue = 7
        previewNote.date = Date()

        do {
            try context.save()
        } catch {
            print("Error saving preview note: \(error)")
        }

        return ContentView()
            .environment(\.managedObjectContext, context)
    }
}