import Foundation
import ComposableArchitecture

@Reducer
struct DetailFeature {
    @Dependency(\.apiService) var apiService
    @Dependency(\.isPresented) var isPresented
    
    @ObservableState
    struct State: Equatable {
        var moment: MomentsInfo
        var isLikeLoading = false
        var isDeleteLoading = false
        var showImagePreview = false
        var selectedImageIndex = 0
        var selectedImages: [String] = []
        
        // 新增：当前用户ID状态
        var currentUserId: String?
        var isLoadingCurrentUserId = false
        
        // 新增：是否需要关闭DetailView
        var shouldDismiss = false
        
        // 新增：显示用户主页相关状态
        var showUserProfile = false
        var targetUserId: Int = 0
        
        init(moment: MomentsInfo) {
            self.moment = moment
        }
    }
    
    enum Action: Equatable {
        case onAppear
        case likeDynamic(Int, Int, Int, Int) // dynamicId, uid, likedUid, worldId
        case likeResponse(TaskResult<LikeDynamicResponse>)
        case deleteDynamic
        case deleteResponse(TaskResult<DeleteDynamicResponse>)
        case showImagePreview([String], Int)
        case hideImagePreview
        case imagePreviewDismissed
        case dismissView
        
        // 新增：当前用户ID相关actions
        case loadCurrentUserId
        case currentUserIdLoaded(String?)
        
        // 新增：用户主页相关actions
        case showUserProfile(Int)
        case hideUserProfile
    }
    
    var body: some ReducerOf<Self> {
        Reduce {
 state,
 action in
            switch action {
            case .onAppear:
                // 如果还没有获取过当前用户ID，则开始获取
                if state.currentUserId == nil && !state.isLoadingCurrentUserId {
                    return .send(.loadCurrentUserId)
                }
                return .none
                
            case .loadCurrentUserId:
                state.isLoadingCurrentUserId = true
                return .run { send in
                    let userId = await UserInfoManager.getCurrentUserId()
                    debugInfoSync("🔍 DetailFeature: 获取当前用户ID - \(userId ?? "nil")")
                    await send(.currentUserIdLoaded(userId))
                }
                
            case let .currentUserIdLoaded(userId):
                state.currentUserId = userId
                state.isLoadingCurrentUserId = false
                debugInfoSync("✅ DetailFeature: 当前用户ID已加载 - \(userId ?? "nil")")
                return .none
                
            case let .likeDynamic(dynamicId, uid, likedUid, worldId):
                // 设置loading状态
                state.isLikeLoading = true
                
                let status = state.moment.isLike ? 0 : 1 // 0: 取消点赞, 1: 点赞
                let request = LikeDynamicRequest(
                    dynamicId: dynamicId,
                    uid: uid,
                    status: status,
                    likedUid: likedUid,
                    worldId: worldId
                )
                
                return .run { [apiService] send in
                    do {
                        let response: LikeDynamicResponse = try await apiService.request(request)
                        await send(.likeResponse(.success(response)))
                    } catch {
                        await send(.likeResponse(.failure(error)))
                    }
                }
                
            case let .likeResponse(.success(response)):
                if let data = response.data, let success = data.success, success {
                    // 根据API响应更新点赞状态
                    let newLikeState = !state.moment.isLike // 切换点赞状态
                    
                    // 创建更新后的动态对象
                    let updatedMoment = MomentsInfo(
                        dynamicId: state.moment.dynamicId,
                        uid: state.moment.uid,
                        nick: state.moment.nick,
                        avatar: state.moment.avatar,
                        type: state.moment.type,
                        content: state.moment.content,
                        likeCount: data.likeCount ?? state.moment.likeCount,
                        isLike: newLikeState,
                        commentCount: state.moment.commentCount,
                        publishTime: state.moment.publishTime,
                        worldId: state.moment.worldId,
                        status: state.moment.status,
                        playCount: state.moment.playCount,
                        dynamicResList: state.moment.dynamicResList,
                        gender: state.moment.gender,
                        squareTop: state.moment.squareTop,
                        topicTop: state.moment.topicTop,
                        newUser: state.moment.newUser,
                        defUser: state.moment.defUser,
                        scene: state.moment.scene,
                        userVipInfoVO: state.moment.userVipInfoVO,
                        headwearPic: state.moment.headwearPic,
                        headwearEffect: state.moment.headwearEffect,
                        headwearType: state.moment.headwearType,
                        headwearName: state.moment.headwearName,
                        headwearId: state.moment.headwearId,
                        experLevelPic: state.moment.experLevelPic,
                        charmLevelPic: state.moment.charmLevelPic,
                        isCustomWord: state.moment.isCustomWord,
                        labelList: state.moment.labelList
                    )
                    state.moment = updatedMoment
                    // 移除loading状态
                    state.isLikeLoading = false
                } else {
                    // API返回失败，通过APILoadingManager显示错误信息
                    let errorMessage = response.message.isEmpty ? "点赞失败，请重试" : response.message
                    setAPILoadingErrorSync(UUID(), errorMessage: errorMessage)
                }
                
                // 移除loading状态
                state.isLikeLoading = false
                return .none
                
            case let .likeResponse(.failure(error)):
                // 移除loading状态
                state.isLikeLoading = false
                // 通过APILoadingManager显示错误信息
                setAPILoadingErrorSync(UUID(), errorMessage: error.localizedDescription)
                return .none
                
            case .deleteDynamic:
                state.isDeleteLoading = true
                
                let request = DeleteDynamicRequest(dynamicId: state.moment.dynamicId, uid: state.moment.uid)
                
                return .run { send in
                    let result = await TaskResult {
                        try await apiService.request(request)
                    }
                    await send(.deleteResponse(result))
                }
                
            case let .deleteResponse(.success(response)):
                state.isDeleteLoading = false
                debugInfoSync("✅ DetailFeature: 动态删除成功")
                // 删除成功，返回上一页
                return .send(.dismissView)
                
            case let .deleteResponse(.failure(error)):
                state.isDeleteLoading = false
                // 可以在这里处理错误
                return .none
                
            case let .showImagePreview(images, index):
                state.selectedImages = images
                state.selectedImageIndex = index
                state.showImagePreview = true
                return .none
                
            case .hideImagePreview:
                state.showImagePreview = false
                return .none
                
            case .imagePreviewDismissed:
                state.showImagePreview = false
                return .none
                
            case .dismissView:
                debugInfoSync("🔍 DetailFeature: 请求关闭DetailView")
                state.shouldDismiss = true
                return .none
                
            case let .showUserProfile(userId):
                state.targetUserId = userId
                state.showUserProfile = true
                return .none
                
            case .hideUserProfile:
                state.showUserProfile = false
                return .none
            }
        }
    }
}