Ausgaben-Tracker mit SwiftData und Charts (Teil 1)

struct ContentView: View {
    var body: some View {
        Text("Ausgaben")
    }
}

import SwiftUI
import SwiftData

enum CategoryTint: String, Codable, CaseIterable {
    case orange, blue, green, purple, pink, teal, red, gray

    var color: Color {
        switch self {
        case .orange: .orange
        case .blue: .blue
        case .green: .green
        case .purple: .purple
        case .pink: .pink
        case .teal: .teal
        case .red: .red
        case .gray: .gray
        }
    }
}

@Model
final class Category {
    var name: String
    var icon: String
    var tint: CategoryTint

    @Relationship(deleteRule: .nullify, inverse: \Expense.category)
    var expenses: [Expense] = []

    init(name: String, icon: String, tint: CategoryTint) {
        self.name = name
        self.icon = icon
        self.tint = tint
    }
}

@Model
final class Expense {
    var title: String
    var amount: Double
    var date: Date
    var note: String
    var category: Category?

    init(title: String, amount: Double, date: Date = .now, note: String = "", category: Category? = nil) {
        self.title = title
        self.amount = amount
        self.date = date
        self.note = note
        self.category = category
    }
}

import SwiftUI
import SwiftData

@main
struct AusgabenApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: [Expense.self, Category.self])
    }
}

import SwiftData
import Foundation

enum SampleData {
    @discardableResult
    static func insertCategories(into context: ModelContext) -> [Category] {
        let categories = [
            Category(name: "Lebensmittel", icon: "cart.fill", tint: .green),
            Category(name: "Essen gehen", icon: "fork.knife", tint: .orange),
            Category(name: "Verkehr", icon: "tram.fill", tint: .blue),
            Category(name: "Freizeit", icon: "gamecontroller.fill", tint: .purple),
            Category(name: "Wohnen", icon: "house.fill", tint: .teal),
            Category(name: "Sonstiges", icon: "ellipsis", tint: .gray)
        ]
        for category in categories {
            context.insert(category)
        }
        return categories
    }

    static func insertExamples(into context: ModelContext) {
        let categories = insertCategories(into: context)
        let titles = [
            "Lebensmittel": ["Wocheneinkauf", "Bäckerei", "Markt"],
            "Essen gehen": ["Pizza", "Mittagessen", "Café"],
            "Verkehr": ["Monatskarte", "Tanken", "Taxi"],
            "Freizeit": ["Kino", "Konzert", "Buch"],
            "Wohnen": ["Strom", "Internet", "Möbel"],
            "Sonstiges": ["Geschenk", "Apotheke", "Friseur"]
        ]

        for _ in 0..<40 {
            let category = categories.randomElement()!
            let title = titles[category.name]?.randomElement() ?? "Ausgabe"
            let daysAgo = Int.random(in: 0...60)
            let date = Calendar.current.date(byAdding: .day, value: -daysAgo, to: .now)!
            let amount = (Double.random(in: 3...90) * 100).rounded() / 100

            context.insert(Expense(title: title, amount: amount, date: date, category: category))
        }
    }
}

@MainActor
let previewContainer: ModelContainer = {
    let container = try! ModelContainer(
        for: Expense.self, Category.self,
        configurations: ModelConfiguration(isStoredInMemoryOnly: true)
    )
    SampleData.insertExamples(into: container.mainContext)
    return container
}()

struct ContentView: View {
    @Environment(\.modelContext) private var context

    var body: some View {
        ExpenseListView()
            .task {
                let count = (try? context.fetchCount(FetchDescriptor<Category>())) ?? 0
                if count == 0 {
                    SampleData.insertCategories(into: context)
                }
            }
    }
}

struct ExpenseRow: View {
    let expense: Expense

    var body: some View {
        HStack(spacing: 12) {
            Image(systemName: expense.category?.icon ?? "questionmark")
                .font(.body.weight(.semibold))
                .foregroundStyle(.white)
                .frame(width: 36, height: 36)
                .background(expense.category?.tint.color ?? .gray, in: .circle)

            VStack(alignment: .leading, spacing: 2) {
                Text(expense.title)
                Text(expense.category?.name ?? "Ohne Kategorie")
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }

            Spacer()

            Text(expense.amount, format: .currency(code: "EUR"))
                .monospacedDigit()
        }
    }
}

#Preview {
    let expense = Expense(title: "Wocheneinkauf", amount: 64.2,
                          category: Category(name: "Lebensmittel", icon: "cart.fill", tint: .green))
    return List { ExpenseRow(expense: expense) }
        .modelContainer(previewContainer)
}

struct ExpenseListView: View {
    @Environment(\.modelContext) private var context
    @Query(sort: \Expense.date, order: .reverse) private var expenses: [Expense]

    private var days: [(date: Date, items: [Expense])] {
        let groups = Dictionary(grouping: expenses) { expense in
            Calendar.current.startOfDay(for: expense.date)
        }
        return groups
            .map { (date: $0.key, items: $0.value) }
            .sorted { $0.date > $1.date }
    }

    var body: some View {
        NavigationStack {
            List {
                ForEach(days, id: \.date) { day in
                    Section {
                        ForEach(day.items) { expense in
                            ExpenseRow(expense: expense)
                        }
                        .onDelete { offsets in
                            for index in offsets {
                                context.delete(day.items[index])
                            }
                        }
                    } header: {
                        HStack {
                            Text(title(for: day.date))
                            Spacer()
                            Text(day.items.reduce(0) { $0 + $1.amount }, format: .currency(code: "EUR"))
                        }
                    }
                }
            }
            .navigationTitle("Ausgaben")
        }
    }

    private func title(for date: Date) -> String {
        if Calendar.current.isDateInToday(date) { return "Heute" }
        if Calendar.current.isDateInYesterday(date) { return "Gestern" }
        return date.formatted(.dateTime.weekday(.wide).day().month(.wide))
    }
}

#Preview {
    ExpenseListView()
        .modelContainer(previewContainer)
}

private var monthTotal: Double {
    expenses
        .filter { Calendar.current.isDate($0.date, equalTo: .now, toGranularity: .month) }
        .reduce(0) { $0 + $1.amount }
}

Section {
    VStack(alignment: .leading, spacing: 4) {
        Text("Diesen Monat")
            .font(.subheadline)
            .foregroundStyle(.secondary)
        Text(monthTotal, format: .currency(code: "EUR"))
            .font(.largeTitle.bold())
    }
    .padding(.vertical, 4)
}

.overlay {
    if expenses.isEmpty {
        ContentUnavailableView(
            "Noch keine Ausgaben",
            systemImage: "eurosign.circle",
            description: Text("Tippe auf Plus, um deine erste Ausgabe zu erfassen.")
        )
    }
}