AppDelegateReducer.swift

public struct AppDelegateReducer: Reducer {
  public typealias State = UserSettings

  public enum Action: Equatable {
    case didFinishLaunching
    case userNotifications(UserNotificationClient.DelegateEvent)
    case userSettingsLoaded(TaskResult<UserSettings>)
  }

  public init() {}

  @Dependency(\.userNotifications) var userNotifications
  @Dependency(\.applicationClient.setUserInterfaceStyle) var setUserInterfaceStyle
  @Dependency(\.remoteNotifications) var remoteNotifications

  public var body: some Reducer<State, Action> {

    Reduce(self.core)
  }

  func core(state: inout State, action: Action) -> Effect<Action> {
    switch action {
      case .didFinishLaunching:
        return .run { send in
          await withThrowingTaskGroup(of: Void.self) { group in
            group.addTask {
              for await event in self.userNotifications.delegate() {
                await send(.userNotifications(event))
              }
            }

            group.addTask {
              let settings = await self.userNotifications.getNotificationSettings()
              switch settings.authorizationStatus {
                case .authorized:
                  guard
                    try await self.userNotifications.requestAuthorization([.alert, .badge, .sound])
                  else { return }
                case .notDetermined, .provisional:
                  guard try await self.userNotifications.requestAuthorization(.provisional)
                  else { return }
                default:
                  return
              }
            }
          }
        }

      case let .userNotifications(.willPresentNotification(_, completion)):
        return .run { _ in
          completion([.list, .banner, .sound])
        }

      case let .userNotifications(.didReceiveResponse(_, completion)):
        return  .run { @MainActor _ in
          completion()
        }

      case .userNotifications:
        return .none

      case let .userSettingsLoaded(result):
        state = (try? result.value) ?? state
        return .run { [state] _ in
          async let setUI: Void =
          await self.setUserInterfaceStyle(state.colorScheme.userInterfaceStyle)
          _ = await (setUI)
        }
    }
  }
}