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

import Foundation
import ComposableArchitecture

@Reducer
struct MeFeature {
    @Dependency(\.apiService) var apiService
    struct State: Equatable {
        var userInfo: UserInfo?
        var isLoadingUserInfo: Bool = false
        var userInfoError: String?
        var moments: [MomentsInfo] = []
        var isLoadingMoments: Bool = false
        var momentsError: String?
        var hasMore: Bool = true
        var isLoadingMore: Bool = false
        var isRefreshing: Bool = false
        var page: Int = 1
        var pageSize: Int = 20
        var uid: Int = 0
    }
    
    enum Action: Equatable {
        case onAppear
        case refresh
        case loadMore
        case userInfoResponse(Result<UserInfo, APIError>)
        case momentsResponse(Result<MyMomentsResponse, APIError>)
    }
    
    func reduce(into state: inout State, action: Action) -> Effect<Action> {
        switch action {
        case .onAppear:
            guard state.uid > 0 else { return .none }
            state.isLoadingUserInfo = true
            state.isLoadingMoments = true
            state.userInfoError = nil
            state.momentsError = nil
            state.page = 1
            state.hasMore = true
            return .merge(
                fetchUserInfo(uid: state.uid),
                fetchMoments(uid: state.uid, page: 1, pageSize: state.pageSize)
            )
        case .refresh:
            guard state.uid > 0 else { return .none }
            state.isRefreshing = true
            state.page = 1
            state.hasMore = true
            return .merge(
                fetchUserInfo(uid: state.uid),
                fetchMoments(uid: state.uid, page: 1, pageSize: state.pageSize)
            )
        case .loadMore:
            guard state.uid > 0, state.hasMore, !state.isLoadingMore else { return .none }
            state.isLoadingMore = true
            return fetchMoments(uid: state.uid, page: state.page + 1, pageSize: state.pageSize)
        case let .userInfoResponse(result):
            state.isLoadingUserInfo = false
            state.isRefreshing = false
            switch result {
            case let .success(userInfo):
                state.userInfo = userInfo
                state.userInfoError = nil
            case let .failure(error):
                state.userInfoError = error.localizedDescription
            }
            return .none
        case let .momentsResponse(result):
            state.isLoadingMoments = false
            state.isLoadingMore = false
            state.isRefreshing = false
            switch result {
            case let .success(resp):
                let newMoments = resp.data ?? []
                if state.page == 1 {
                    state.moments = newMoments
                } else {
                    state.moments += newMoments
                }
                state.hasMore = newMoments.count == state.pageSize
                if state.hasMore { state.page += 1 }
                state.momentsError = nil
            case let .failure(error):
                state.momentsError = error.localizedDescription
            }
            return .none
        }
    }
    
    private func fetchUserInfo(uid: Int) -> Effect<Action> {
        .run { send in
            do {
                if let userInfo = try await UserInfoManager.fetchUserInfoFromServer(uid: String(uid), apiService: apiService) {
                    await send(.userInfoResponse(.success(userInfo)))
                } else {
                    await send(.userInfoResponse(.failure(.noData)))
                }
            } catch {
                await send(.userInfoResponse(.failure(error as? APIError ?? .unknown(error.localizedDescription))))
            }
        }
    }
    
    private func fetchMoments(uid: Int, page: Int, pageSize: Int) -> Effect<Action> {
        .run { send in
            do {
                let req = GetMyDynamicRequest(fromUid: uid, uid: uid, page: page, pageSize: pageSize)
                let resp = try await apiService.request(req)
                await send(.momentsResponse(.success(resp)))
            } catch {
                await send(.momentsResponse(.failure(error as? APIError ?? .unknown(error.localizedDescription))))
            }
        }
    }
}