import Foundation
import ComposableArchitecture

// MARK: - Config Response Model
struct ConfigResponse: Codable, Equatable {
    let status: String?
    let message: String?
    let data: ConfigData?
}

struct ConfigData: Codable, Equatable {
    let version: String?
    let features: [String]?
    let settings: ConfigSettings?
}

struct ConfigSettings: Codable, Equatable {
    let enableDebug: Bool?
    let apiTimeout: Int?
    let maxRetries: Int?
}

// MARK: - Config API Request
struct ConfigRequest: APIRequestProtocol {
    typealias Response = ConfigResponse
    
    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 } // Config 请求使用较短超时
}

// MARK: - Config Feature
@Reducer
struct ConfigFeature {
    @ObservableState
    struct State: Equatable {
        var isLoading = false
        var configData: ConfigData?
        var errorMessage: String?
        var lastUpdated: Date?
        
        init() {
            // 默认初始化
        }
    }
    
    enum Action: Equatable {
        case loadConfig
        case configResponse(TaskResult<ConfigResponse>)
        case clearError
    }
    
    @Dependency(\.apiService) var apiService
    
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .loadConfig:
                state.isLoading = true
                state.errorMessage = nil
                
                return .run { send in
                    let request = ConfigRequest()
                    await send(.configResponse(
                        TaskResult {
                            try await apiService.request(request)
                        }
                    ))
                }
                
            case let .configResponse(.success(response)):
                state.isLoading = false
                state.lastUpdated = Date()
                
                if response.status == "success" {
                    state.configData = response.data
                } else {
                    state.errorMessage = response.message ?? "配置加载失败"
                }
                return .none
                
            case let .configResponse(.failure(error)):
                state.isLoading = false
                if let apiError = error as? APIError {
                    state.errorMessage = apiError.localizedDescription
                } else {
                    state.errorMessage = error.localizedDescription
                }
                return .none
                
            case .clearError:
                state.errorMessage = nil
                return .none
            }
        }
    }
}