import Foundation
import ComposableArchitecture
import CasePaths

struct MainFeature: Reducer {
    enum Tab: Int, Equatable, CaseIterable {
        case feed, other
    }
    
    struct State: Equatable {
        var selectedTab: Tab = .feed
        var feedList: FeedListFeature.State = .init()
        var me: MeFeature.State = .init()
        var accountModel: AccountModel? = nil
        // 新增：导航路径和设置页面 State
        var navigationPath: [Destination] = []
        var settingState: SettingFeature.State? = nil
        var appSettingState: AppSettingFeature.State? = nil
    }
    
    // 新增：导航目标
    enum Destination: Hashable, Equatable {
        case setting
        case test
        case appSetting
    }
    
    @CasePathable
    enum Action: Equatable {
        case onAppear
        case selectTab(Tab)
        case feedList(FeedListFeature.Action)
        case me(MeFeature.Action)
        case accountModelLoaded(AccountModel?)
        // 新增：导航相关
        case navigationPathChanged([Destination])
        case settingButtonTapped
        case settingAction(SettingFeature.Action)
        case testButtonTapped
        case appSettingButtonTapped
        case appSettingAction(AppSettingFeature.Action)
    }
    
    var body: some ReducerOf<Self> {
        Scope(state: \.feedList, action: \.feedList) {
            FeedListFeature()
        }
        Scope(state: \.me, action: \.me) {
            MeFeature()
        }
        Reduce { state, action in
            switch action {
            case .onAppear:
                return .run { send in
                    let accountModel = await UserInfoManager.getAccountModel()
                    await send(.accountModelLoaded(accountModel))
                }
            case .selectTab(let tab):
                state.selectedTab = tab
                state.navigationPath = []
                if tab == .other, let uidStr = state.accountModel?.uid, let uid = Int(uidStr), uid > 0 {
                    if state.me.uid != uid {
                        state.me.uid = uid
                        state.me.isFirstLoad = true // 仅当用户切换时才重置首次加载
                    }
                    return .send(.me(.onAppear))
                }
                return .none
            case .feedList:
                return .none
            case let .accountModelLoaded(accountModel):
                state.accountModel = accountModel
                return .none
            case .me(.settingButtonTapped):
                // 触发 push 到设置页
                state.appSettingState = AppSettingFeature.State()
                state.navigationPath.append(.appSetting)
                return .none
            case .me:
                return .none
            case .navigationPathChanged(let newPath):
                // pop 回来时清空 settingState
                if !newPath.contains(.setting) {
                    state.settingState = nil
                }
                if !newPath.contains(.appSetting) {
                    state.appSettingState = nil
                }
                state.navigationPath = newPath
                return .none
            case .settingButtonTapped:
                state.settingState = SettingFeature.State()
                state.navigationPath.append(.setting)
                return .none
            case .settingAction:
                return .none
            case .testButtonTapped:
                state.navigationPath.append(.test)
                return .none
            case .appSettingButtonTapped:
                state.appSettingState = AppSettingFeature.State()
                state.navigationPath.append(.appSetting)
                return .none
            case .appSettingAction:
                return .none
            }
        }
        // 设置页作用域
        .ifLet(\ .settingState, action: \.settingAction) {
            SettingFeature()
        }
        .ifLet(\ .appSettingState, action: \.appSettingAction) {
            AppSettingFeature()
        }
    }
}