import Foundation
import ComposableArchitecture

@Reducer
struct InitFeature {
    @ObservableState
    struct State: Equatable {
        var isLoading = false
        var response: InitResponse?
        var error: String?
        
        init() {
            // 默认初始化
        }
    }
    
    enum Action: Equatable {
        case initialize
        case initializeResponse(TaskResult<InitResponse>)
    }
    
    @Dependency(\.apiService) var apiService
    
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .initialize:
                state.isLoading = true
                state.error = nil
                
                return .run { send in
                    let request = InitRequest()
                    await send(.initializeResponse(
                        TaskResult {
                            try await apiService.request(request)
                        }
                    ))
                }
                
            case let .initializeResponse(.success(response)):
                state.isLoading = false
                state.response = response
                return .none
                
            case let .initializeResponse(.failure(error)):
                state.isLoading = false
                if let apiError = error as? APIError {
                    state.error = apiError.localizedDescription
                } else {
                    state.error = error.localizedDescription
                }
                return .none
            }
        }
    }
}

// MARK: - Init API Request
struct InitRequest: APIRequestProtocol {
    typealias Response = InitResponse
    
    var endpoint: String { APIEndpoint.config.path }
    var method: HTTPMethod { .GET }
    var queryParameters: [String: String]? { nil }
    var bodyParameters: [String: Any]? { nil }
    var timeout: TimeInterval { 15.0 }
}