import Foundation
import ComposableArchitecture

@Reducer
struct FeedFeature {
    @ObservableState
    struct State: Equatable {
        var moments: [MomentsInfo] = []
        var isLoading = false
        var hasMoreData = true
        var error: String?
        var nextDynamicId: Int = 0
        
        // 是否已初始化 - 用于防止重复初始化
        var isInitialized = false
        
        // CreateFeedView 相关状态 - 简化为布尔值
        var isCreateFeedPresented = false
    }
    
    enum Action {
        case onAppear
        case loadLatestMoments
        case loadMoreMoments
        case momentsResponse(TaskResult<MomentsLatestResponse>)
        case clearError
        case retryLoad
        
        // CreateFeedView 相关 Action - 简化为布尔控制
        case showCreateFeed
        case createFeedCompleted
        case createFeedDismissed
    }
    
    @Dependency(\.apiService) var apiService
    
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .onAppear:
                // 只在未初始化时才执行首次加载
                guard !state.isInitialized else { 
                    return .none 
                }
                
                return .send(.loadLatestMoments)
                
            case .loadLatestMoments:
                // 添加重复请求防护
                guard !state.isLoading else { 
                    return .none 
                }
                
                // 加载最新数据（下拉刷新）
                state.isLoading = true
                state.error = nil
                
                let request = LatestDynamicsRequest(
                    dynamicId: "", // 首次加载传空字符串
                    pageSize: 20,
                    types: [.text, .picture]
                )
                return .run { send in
                    await send(.momentsResponse(TaskResult {
                        try await apiService.request(request)
                    }))
                }
                
            case .loadMoreMoments:
                // 加载更多数据（分页加载）
                guard !state.isLoading && state.hasMoreData else { return .none }
                
                state.isLoading = true
                state.error = nil
                
                let request = LatestDynamicsRequest(
                    dynamicId: state.nextDynamicId == 0 ? "" : String(state.nextDynamicId),
                    pageSize: 20,
                    types: [.text, .picture]
                )
                
                return .run { send in
                    await send(.momentsResponse(TaskResult {
                        try await apiService.request(request)
                    }))
                }
                
            case let .momentsResponse(.success(response)):
                state.isLoading = false
                
                // 设置初始化状态
                if !state.isInitialized {
                    state.isInitialized = true
                }
                
                // 检查响应状态
                guard response.code == 200, let data = response.data else {
                    let errorMsg = response.message.isEmpty ? "获取动态失败" : response.message
                    state.error = errorMsg
                    return .none
                }
                
                // 判断是刷新还是加载更多
                let isRefresh = state.nextDynamicId == 0
                
                if isRefresh {
                    // 刷新：替换所有数据
                    state.moments = data.dynamicList
                } else {
                    // 加载更多：追加到现有数据
                    state.moments.append(contentsOf: data.dynamicList)
                }
                
                // 更新分页状态
                state.nextDynamicId = data.nextDynamicId
                state.hasMoreData = !data.dynamicList.isEmpty
                
                return .none
                
            case let .momentsResponse(.failure(error)):
                state.isLoading = false
                state.error = error.localizedDescription
                return .none
                
            case .clearError:
                state.error = nil
                return .none
                
            case .retryLoad:
                // 重试加载
                if state.moments.isEmpty {
                    return .send(.loadLatestMoments)
                } else {
                    return .send(.loadMoreMoments)
                }
                
            // CreateFeedView 相关 Action 处理 - 简化为布尔控制
            case .showCreateFeed:
                state.isCreateFeedPresented = true
                return .none
                
            case .createFeedCompleted:
                // 发布完成后刷新动态列表
                state.isCreateFeedPresented = false
                return .send(.loadLatestMoments)
                
            case .createFeedDismissed:
                state.isCreateFeedPresented = false
                return .none
            }
        }
    }
}