todos/App/Sources/Extensions/TodoFetchDescriptor+Inits.swift

import Foundation
import SwiftData

/// Extension providing convenient initializers for fetching todos by group category.
///
/// This extension allows creating fetch descriptors that automatically filter and sort todos
/// based on their completion status and due dates according to the specified `TodoGroup`.
extension FetchDescriptor where T == Todo {

    /// Creates a fetch descriptor for todos filtered and sorted by a specific group.
    ///
    /// This initializer provides a convenient way to fetch todos categorized by their temporal
    /// relevance and completion status. Each group applies appropriate predicates and sort orders:
    ///
    /// - **Completed**: All tasks marked as done, sorted by completion date (most recent first)
    /// - **Overdue**: Incomplete tasks with due dates before today, sorted by due date (most recent first)
    /// - **Today**: Incomplete tasks due today, sorted by due date (earliest first)
    /// - **Upcoming**: Incomplete tasks due after today, sorted by due date (earliest first)
    ///
    /// - Parameters:
    ///   - group: The todo group category to filter by.
    ///   - showCompleted: Whether to include completed tasks. Only applies to groups other than `.completed`.
    ///   - calendar: The calendar to use for date calculations. Defaults to `.current`.
    init(
        group: TodoGroup,
        showCompleted: Bool,
        calendar: Calendar = .current
    ) {
        let predicate: Predicate<Todo>
        let today = calendar.startOfDay(for: .now)
        let tomorrow = calendar.date(byAdding: .day, value: 1, to: today) ?? today

        switch group {
            case .completed:
                predicate = #Predicate { $0.completed != nil }
            case .overdue:
                predicate = showCompleted
                    ? #Predicate { $0.due < today }
                    : #Predicate { $0.completed == nil && $0.due < today }
            case .today:
                predicate = showCompleted
                    ? #Predicate { $0.due >= today && $0.due < tomorrow }
                    : #Predicate { $0.completed == nil && $0.due >= today && $0.due < tomorrow }
            case .upcoming:
                predicate = showCompleted
                    ? #Predicate { $0.due >= tomorrow }
                    : #Predicate { $0.completed == nil && $0.due >= tomorrow }
        }

        let sortDescriptors: [SortDescriptor] =
            switch group {
                case .completed:
                    [.init(\Todo.completed, order: .reverse)]
                case .overdue:
                    [.init(\Todo.due, order: .reverse)]
                case .today:
                    [.init(\Todo.due, order: .forward)]
                case .upcoming:
                    [.init(\Todo.due, order: .forward)]
            }

        self.init(
            predicate: predicate,
            sortBy: sortDescriptors
        )
    }

}