public struct OnboardingState: Equatable {
  // プレーヤーがオンボーディングをスキップしようとした時念のために出すアラートのための変数
  public var alert: AlertState<OnboardingAction.AlertAction>?
  public var game: GameState
  // オンボーディングをどのように表示するかを決める変数
  public var presentationStyle: PresentationStyle
  // フローの全てのステップを記述した大きな enum
  public var step: Step
}

public enum PresentationStyle {
  // App Clip からオンボーディングを表示する時に使用する
  case demo
  // メインアプリを初めて起動した時にオンボーディングを表示する時に使用する
  case firstLaunch
  // ホーム画面からクエスチョンマークのアイコンをタップした時に使用する
  case help
}

public enum OnboardingAction: Equatable {
  case alert(AlertAction)
  case delayedNextStep
  case delegate(DelegateAction)
  case game(GameAction)
  case getStartedButtonTapped
  case onAppear
  case nextButtonTapped
  case skipButtonTapped

  public enum AlertAction: Equatable {
    case confirmSkipButtonTapped
    case dismiss
    case resumeButtonTapped
    case skipButtonTapped
  }

  public enum DelegateAction {
    case getStarted
  }
}

public struct OnboardingEnvironment {
  var audioPlayer: AudioPlayerClient
  var backgroundQueue: AnySchedulerOf<DispatchQueue>
  var dictionary: DictionaryClient
  var feedbackGenerator: FeedbackGeneratorClient
  var lowPowerMode: LowPowerModeClient
  var mainQueue: AnySchedulerOf<DispatchQueue>
  var mainRunLoop: AnySchedulerOf<RunLoop>
  var userDefaults: UserDefaultsClient

  // ...
  var gameEnvironment: GameEnvironment {
    GameEnvironment(
      apiClient: .noop,
      applicationClient: .noop,
      audioPlayer: self.audioPlayer,
      backgroundQueue: self.backgroundQueue,
      build: .noop,
      database: .noop,
      dictionary: self.dictionary,
      feedbackGenerator: self.feedbackGenerator,
      fileClient: .noop,
      gameCenter: .noop,
      lowPowerMode: self.lowPowerMode,
      mainQueue: self.mainQueue,
      mainRunLoop: self.mainRunLoop,
      remoteNotifications: .noop,
      serverConfig: .noop,
      setUserInterfaceStyle: { _ in .none },
      storeKit: .noop,
      userDefaults: self.userDefaults,
      userNotifications: .noop
    )
  }
}

extension ApiClient {
  public static let noop = Self(
    apiRequest: { _ in .none },
    authenticate: { _ in .none },
    baseUrl: { URL(string: "/")! },
    currentPlayer: { nil },
    logout: { .none },
    refreshCurrentPlayer: { .none },
    request: { _ in .none },
    setBaseUrl: { _ in .none }
  )
}

public let onboardingReducer = Reducer<
  OnboardingState,
  OnboardingAction,
  OnboardingEnvironment
> { state, action, environment in
  ...
}

case .alert(.confirmSkipButtonTapped):
  state.step = OnboardingState.Step.allCases.last!
  return .none

case .nextButtonTapped:
  state.step.next()
  return environment.audioPlayer.play(.uiSfxTap)
    .fireAndForget()

case .game where state.step.isCongratsStep:
  return .none

case .game(.submitButtonTapped):
  switch state.step {
  case .step5_Submit where state.game.selectedWordString == "GAME",
    .step8_FindCubes where state.game.selectedWordString == "CUBES",
    .step12_CubeIsShaking where state.game.selectedWordString.isRemove,
    .step16_FindAnyWord where environment.dictionary.contains(state.game.selectedWordString, .en):

    state.step.next()

    return onboardingGameReducer.run(
      &state,
      .game(.submitButtonTapped(nil)),
      environment
    )

.onChange(of: \.game.selectedWordString) { selectedWord, state, _, _ in
  switch state.step {
  case .step4_FindGame where selectedWord == "GAME",
    .step11_FindRemove where selectedWord.isRemove:
    state.step.next()
    return .none
  case .step5_Submit where selectedWord != "GAME",
    .step12_CubeIsShaking where !selectedWord.isRemove:
    state.step.previous()
    return .none
  default:
    return .none
  }
}

public var body: some View {
  ZStack(alignment: .topTrailing) {
    CubeView(
      store: self.store.scope(
        state: cubeSceneViewState(onboardingState:),
        action: { .game(CubeSceneView.ViewAction.to(gameAction: $0)) }
      )
    )
    .opacity(viewStore.step.isFullscreen ? 0 : 1)

    OnboardingStepView(store: self.store)

    if viewStore.isSkipButtonVisible {
      Button("Skip") { viewStore.send(.skipButtonTapped, animation: .default) }
        .adaptiveFont(.matterMedium, size: 18)
        .buttonStyle(PlainButtonStyle())
        .padding([.leading, .trailing])
        .foregroundColor(
          self.colorScheme == .dark
            ? viewStore.step.color
            : Color.isowordsBlack
        )
    }
  }
}

extension OnboardingEnvironment {
  static let failing = Self(
    audioPlayer: .failing,
    backgroundQueue: .failing("backgroundQueue"),
    dictionary: .failing,
    feedbackGenerator: .failing,
    lowPowerMode: .failing,
    mainQueue: .failing("mainQueue"),
    mainRunLoop: .failing,
    userDefaults: .failing
  )
}

#if DEBUG
  import XCTestDynamicOverlay

  extension AudioPlayerClient {
    public static let failing = Self(
      load: { _ in .failing("\(Self.self).load is unimplemented") },
      loop: { _ in .failing("\(Self.self).loop is unimplemented") },
      play: { _ in .failing("\(Self.self).play is unimplemented") },
      secondaryAudioShouldBeSilencedHint: {
        XCTFail("\(Self.self).secondaryAudioShouldBeSilencedHint is unimplemented")
        return false
      },
      setGlobalVolumeForMusic: { _ in
        .failing("\(Self.self).setGlobalVolumeForMusic is unimplemented")
      },
      setGlobalVolumeForSoundEffects: { _ in
        .failing("\(Self.self).setGlobalVolumeForSoundEffects is unimplemented")
      },
      setVolume: { _, _ in .failing("\(Self.self).setVolume is unimplemented") },
      stop: { _ in .failing("\(Self.self).stop is unimplemented") }
    )
  }
#endif

    var environment = OnboardingEnvironment.failing
    environment.audioPlayer = .noop
    environment.backgroundQueue = .immediate
    environment.dictionary.load = { _ in true }
    environment.dictionary.contains = { word, _ in
      ["GAME", "CUBES", "REMOVE", "WORD"].contains(word)
    }
    environment.feedbackGenerator = .noop
    environment.mainRunLoop = .immediate
    environment.mainQueue = self.mainQueue.eraseToAnyScheduler()
    environment.userDefaults.setBool = { value, key in
      .fireAndForget {
        XCTAssertEqual(key, "hasShownFirstLaunchOnboardingKey")
        XCTAssertEqual(value, true)
        isFirstLaunchOnboardingKeySet = true
      }
    }

@main
struct AppClipApp: App {
  init() {
    Styleguide.registerFonts()
  }

  var body: some Scene {
    WindowGroup {
      DemoView(
        store: Store(
          initialState: DemoState(),
          reducer: demoReducer,
          environment: .live
        )
      )
    }
  }
}

extension DemoEnvironment {
  static var live: Self {
    Self(
      // こちらについては後ほど見ていく
      apiClient: .appClip,
      applicationClient: .live,
      audioPlayer: .live(bundles: [AppClipAudioLibrary.bundle]),
      backgroundQueue: DispatchQueue(label: "background-queue").eraseToAnyScheduler(),
      build: .live,
      dictionary: .file(),
      feedbackGenerator: .live,
      lowPowerMode: .live,
      mainQueue: .main,
      mainRunLoop: .main,
      userDefaults: .live()
    )
  }
}

    .target(
      name: "DemoFeature",
      dependencies: [
        "ApiClient",
        "Build",
        "GameCore",
        "DictionaryClient",
        "FeedbackGeneratorClient",
        "LowPowerModeClient",
        "OnboardingFeature",
        "SharedModels",
        "UserDefaultsClient",
        .product(name: "ComposableArchitecture", package: "swift-composable-architecture"),
      ]
    ),

@main
struct CubeCorePreviewApp: App {
  var body: some Scene {
    WindowGroup {
      CubeView(
        store: .init(
          initialState: .init(
            cubes: .mock,
            isOnLowPowerMode: false,
            nub: nil,
            playedWords: [],
            selectedFaceCount: 0,
            selectedWordIsValid: false,
            selectedWordString: "",
            settings: .init(showSceneStatistics: true)
          ),
          reducer: .empty,
          environment: ()
        )
      )
    }
  }
}

import LeaderboardFeature
...
LeaderboardView(
  store: .init(
    initialState: .init(isHapticsEnabled: false, settings: .init()),
    reducer: leaderboardReducer,
    // environment は noop によって構築することができる
    environment: .init(
      apiClient: .noop,
      audioPlayer: .noop,
      feedbackGenerator: .noop,
      lowPowerMode: .false,
      mainQueue: DispatchQueue.main.eraseToAnyScheduler()
    )
  )
)

var apiClient = ApiClient.noop

apiClient.override(
  route: .leaderboard(
    .fetch(
      gameMode: .timed,
      language: .en,
      timeScope: .lastWeek
    )
  ),
  withResponse: .ok(
    FetchLeaderboardResponse(
      entries: [
        .init(
          id: .init(rawValue: UUID()),
          isSupporter: false,
          isYourScore: false,
          outOf: 1_000,
          playerDisplayName: "Blob",
          rank: 5,
          score: 3_000
        )
      ]
    )
  )
)

environment: .init(
  apiClient: apiClient,
  ...
)

@main
struct TrailerPreviewApp: App {
  init() {
    Styleguide.registerFonts()
  }

  var body: some Scene {
    WindowGroup {
      TrailerView(
        store: .init(
          initialState: .init(),
          reducer: trailerReducer,
          environment: .init(
            audioPlayer: .live(
              bundles: [
                AppAudioLibrary.bundle,
                AppClipAudioLibrary.bundle,
              ]
            ),
            backgroundQueue: .main,
            dictionary: .init(
              // トレーラーのために認識する必要がある単語のセットは限られているためこのような実装になっている
              contains: { string, _ in
                [
                  "SAY", "HELLO", "TO", "ISOWORDS",
                  "A", "NEW", "WORD", "SEARCH", "GAME",
                  "FOR", "YOUR", "PHONE",
                  "COMING", "NEXT", "YEAR",
                ]
                .contains(string.uppercased())
              },
              load: { _ in true },
              lookup: { _, _ in nil },
              randomCubes: { _ in .mock },
              unload: { _ in }
            ),
            mainQueue: .main,
            mainRunLoop: .main
          )
        )
      )
      .statusBar(hidden: true)
    }
  }
}

public struct TrailerState: Equatable {
  var game: GameState
  var nub: CubeSceneView.ViewState.NubState
  var opacity: Double

  ...
}

case .onAppear:
  return .merge(
    environment.audioPlayer.load(AudioPlayerClient.Sound.allCases)
      .fireAndForget(),

    Effect(value: .delayedOnAppear)
      .delay(
        for: 1,
        scheduler: environment.mainQueue.animation(.easeInOut(duration: fadeInDuration))
      )
      .eraseToEffect()
  )

case .delayedOnAppear:
  state.opacity = 1

  ...

// Move the nub to the face being played
effects.append(
  Effect(value: .binding(.set(\.nub.location, .face(face))))
    .delay(
      for: moveNubDelay(wordIndex: wordIndex, characterIndex: characterIndex),
      scheduler: environment.mainQueue
        .animate(withDuration: moveNubToFaceDuration, options: .curveEaseInOut)
    )
    .eraseToEffect()
)

public func animate(
  withDuration duration: TimeInterval,
  delay: TimeInterval = 0,
  options animationOptions: UIView.AnimationOptions = []
) -> AnySchedulerOf<Self> {
  AnyScheduler(
    minimumTolerance: { self.minimumTolerance },
    now: { self.now },
    scheduleImmediately: { options, action in
      self.schedule(options: options) {
        UIView.animate(
          withDuration: duration,
          delay: delay,
          options: animationOptions,
          animations: action
        )
      }
    },
    delayed: { date, tolerance, options, action in
      self.schedule(after: date, tolerance: tolerance, options: options) {
        UIView.animate(
          withDuration: duration,
          delay: delay,
          options: animationOptions,
          animations: action
        )
      }
    },
    interval: { date, interval, tolerance, options, action in
      self.schedule(after: date, interval: interval, tolerance: tolerance, options: options) {
        UIView.animate(
          withDuration: duration,
          delay: delay,
          options: animationOptions,
          animations: action
        )
      }
    }
  )
}

private let firstCharacterDelay: DispatchQueue.SchedulerTimeType.Stride = 0.3
private let firstWordDelay: DispatchQueue.SchedulerTimeType.Stride = 1.5
private let moveNubToFaceDuration = 0.45
private let moveNubToSubmitButtonDuration = 0.4
private let moveNubOffScreenDuration = 0.5
private let fadeInDuration = 0.3
private let fadeOutDuration = 0.3
private let submitPressDuration = 0.05
private let submitHesitationDuration = 0.15