e-party-iOS/yana/Features/HomeFeature.swift

import Foundation
import ComposableArchitecture

struct HomeFeature: Reducer {
    enum Route: Equatable {
        case createFeed
    }

    struct State: Equatable {
        var isInitialized = false
        var userInfo: UserInfo?
        var accountModel: AccountModel?
        var error: String?
        var feedState = FeedFeature.State()
        var meDynamic = MeDynamicFeature.State(uid: 0)
        var isLoggedOut = false
        var route: Route? = nil
    }

    @CasePathable
    enum Action: Equatable {
        case onAppear
        case loadUserInfo
        case userInfoLoaded(UserInfo?)
        case loadAccountModel
        case accountModelLoaded(AccountModel?)
        case logoutTapped
        case logout
        case feed(FeedFeature.Action)
        case meDynamic(MeDynamicFeature.Action)
        case logoutCompleted
        case showCreateFeed
        case createFeedDismissed
    }

    var body: some ReducerOf<Self> {
        Scope(state: \.feedState, action: \.feed) {
            FeedFeature()
        }
        Scope(state: \.meDynamic, action: \.meDynamic) {
            MeDynamicFeature()
        }
        Reduce { state, action in
            switch action {
            case .onAppear:
                guard !state.isInitialized else { return .none }
                state.isInitialized = true
                return .concatenate(
                    .send(.loadUserInfo),
                    .send(.loadAccountModel)
                )
            case .loadUserInfo:
                return .run { send in
                    let userInfo = await UserInfoManager.getUserInfo()
                    await send(.userInfoLoaded(userInfo))
                }
            case let .userInfoLoaded(userInfo):
                state.userInfo = userInfo
                state.meDynamic.uid = userInfo?.uid ?? 0
                return .none
            case .loadAccountModel:
                return .run { send in
                    let accountModel = await UserInfoManager.getAccountModel()
                    await send(.accountModelLoaded(accountModel))
                }
            case let .accountModelLoaded(accountModel):
                state.accountModel = accountModel
                return .none
            case .logoutTapped:
                return .send(.logout)
            case .logout:
                return .run { send in
                    await UserInfoManager.clearAllAuthenticationData()
                    await send(.logoutCompleted)
                }
            case .logoutCompleted:
                state.isLoggedOut = true
                return .none
            case .feed:
                return .none
            case .meDynamic:
                return .none
            case .showCreateFeed:
                state.route = .createFeed
                return .none
            case .createFeedDismissed:
                state.route = nil
                return .none
            }
        }
    }
}