dependencies {
    implementation("global.deveng:networking-kmp:latest")
}

// 1. Configure the module
val config = DevengNetworkingConfig(
    loggingEnabled = true,                         // Optional - defaults to true
    requestTimeoutMillis = 30_000L,               // Optional - defaults to 60 seconds
    connectTimeoutMillis = 10_000L,               // Optional - defaults to 10 seconds
    socketTimeoutMillis = 30_000L,                // Optional - defaults to 60 seconds
    token = "your-auth-token",                    // Optional - for authentication
    locale = Locale.EN,                           // Optional - defaults to EN
    customHeaders = mapOf(                        // Optional - for global headers
        "X-API-Version" to "1.0",
        "X-Client-Platform" to "Android"
    ),
    socketBaseUrl = "wss://ws.example.com"        // Optional - only needed for WebSocket
)

// 2. Initialize
DevengNetworkingModule.initDevengNetworkingModule(
    restBaseUrl = "https://api.example.com",      // Required - your REST API base URL
    config = config
)

// 3. Make your first API call
suspend fun getUser(userId: String): User? {
    return DevengNetworkingModule.sendRequest<Unit, User?>(
        endpoint = "/users/{userId}",
        requestMethod = DevengHttpMethod.GET,
        pathParameters = mapOf("userId" to userId)
    )
}

// For Java < 21, use this approach:
suspend fun getUser(userId: String): User {
    return DevengNetworkingModule.sendRequest(
        endpoint = "/users/{userId}",
        requestMethod = DevengHttpMethod.GET,
        pathParameters = mapOf("userId" to userId),
        requestSerializer = null,              // No request body
        responseSerializer = User.serializer() // Explicit response serializer
    )
}

// Development
val devConfig = DevengNetworkingConfig(
    loggingEnabled = true,
    requestTimeoutMillis = 120_000L,
    token = "dev-token"
)

// Production
val prodConfig = DevengNetworkingConfig(
    loggingEnabled = false,
    requestTimeoutMillis = 30_000L,
    customHeaders = mapOf("X-Client-Version" to "2.1.0")
)

// GET Request
suspend fun getUser(id: String): User? {
    return DevengNetworkingModule.sendRequest<Unit, User?>(
        endpoint = "/users/{id}",
        requestMethod = DevengHttpMethod.GET,
        pathParameters = mapOf("id" to id)
    )
}

// POST Request
suspend fun createUser(user: CreateUserRequest): User? {
    return DevengNetworkingModule.sendRequest<CreateUserRequest, User?>(
        endpoint = "/users",
        requestBody = user,
        requestMethod = DevengHttpMethod.POST
    )
}

// PUT Request
suspend fun updateUser(id: String, user: UpdateUserRequest) {
    DevengNetworkingModule.sendRequest<UpdateUserRequest, Unit>(
        endpoint = "/users/{id}",
        requestBody = user,
        requestMethod = DevengHttpMethod.PUT,
        pathParameters = mapOf("id" to id)
    )
}

// DELETE Request
suspend fun deleteUser(id: String) {
    DevengNetworkingModule.sendRequest<Unit, Unit>(
        endpoint = "/users/{id}",
        requestMethod = DevengHttpMethod.DELETE,
        pathParameters = mapOf("id" to id)
    )
}

suspend fun searchUsers(query: String, limit: Int): List<User>? {
    return DevengNetworkingModule.sendRequest<Unit, List<User>?>(
        endpoint = "/users/search",
        requestMethod = DevengHttpMethod.GET,
        queryParameters = mapOf(
            "query" to query,
            "limit" to limit.toString()
        )
    )
}

suspend fun getRawResponse(): HttpResponse {
    return DevengNetworkingModule.sendRequestForHttpResponse<Unit>(
        endpoint = "/status",
        requestMethod = DevengHttpMethod.GET
    )
}

// Example usage - accessing response metadata
suspend fun checkApiLimits() {
    val response = DevengNetworkingModule.sendRequestForHttpResponse<Unit>(
        endpoint = "/api/limits",
        requestMethod = DevengHttpMethod.GET
    )
    
    // Access headers for rate limiting info
    val remainingRequests = response.headers["X-RateLimit-Remaining"]
    val resetTime = response.headers["X-RateLimit-Reset"]
    
    // Check exact status code
    when (response.status.value) {
        200 -> println("API healthy")
        429 -> println("Rate limited - retry after $resetTime")
        else -> println("Status: ${response.status}")
    }
}

suspend fun uploadProfilePicture(userId: String, imageData: ByteArray) {
    DevengNetworkingModule.sendRequest<Unit, Unit>(
        endpoint = "/users/$userId/avatar",
        requestMethod = DevengHttpMethod.MULTIPART,
        fileName = "profile.jpg",
        fileContent = imageData
    )
}

suspend fun uploadDocument(
    fileName: String,
    fileData: ByteArray,
    documentType: String,
    isPublic: Boolean
) {
    DevengNetworkingModule.sendRequest<Unit, UploadResponse>(
        endpoint = "/documents/upload",
        requestMethod = DevengHttpMethod.MULTIPART,
        fileName = fileName,
        fileContent = fileData,
        additionalFormFields = mapOf(
            "type" to documentType,
            "isPublic" to isPublic.toString(),
            "uploadedAt" to System.currentTimeMillis().toString()
        )
    )
}

suspend fun uploadAttachment(fileName: String, fileData: ByteArray) {
    DevengNetworkingModule.sendRequest<Unit, Unit>(
        endpoint = "/attachments",
        requestMethod = DevengHttpMethod.MULTIPART,
        fileName = fileName,
        fileContent = fileData,
        fileFieldName = "attachment" // Custom field name instead of default "File"
    )
}

data class UploadResponse(val fileId: String, val downloadUrl: String)

suspend fun uploadAndGetUrl(fileName: String, fileData: ByteArray): UploadResponse {
    return DevengNetworkingModule.sendRequest<Unit, UploadResponse>(
        endpoint = "/files/upload",
        requestMethod = DevengHttpMethod.MULTIPART,
        fileName = fileName,
        fileContent = fileData,
        additionalFormFields = mapOf("source" to "mobile")
    )
}

suspend fun uploadFile(fileName: String, fileData: ByteArray): UploadResponse {
    return DevengNetworkingModule.sendRequest(
        endpoint = "/files/upload",
        requestMethod = DevengHttpMethod.MULTIPART,
        requestSerializer = null,
        responseSerializer = UploadResponse.serializer(),
        fileName = fileName,
        fileContent = fileData
    )
}

val connection = DevengNetworkingModule.connectToWebSocket(
    endpoint = "/chat",
    onConnected = {
        sendMessage("Hello Server!")
    },
    onMessageReceived = { message ->
        println("Received: $message")
    },
    onError = { error ->
        println("WebSocket Error: $error")
    },
    onClose = {
        println("Connection closed")
    }
)

// Send messages
connection.sendMessage("Hello World!")

scope.launch {
    connection.connectionState.collect { state ->
        when (state) {
            is ConnectionState.Connected -> println("✅ Connected")
            is ConnectionState.Connecting -> println("🔄 Connecting...")
            is ConnectionState.Disconnected -> println("❌ Disconnected")
            is ConnectionState.Error -> println("⚠️ Error: ${state.error}")
        }
    }
}

// Configure max connections (default: 5)
WebSocketConnection.setMaxConnections(3)

// Get connection stats
val activeConnections = WebSocketConnection.getActiveConnections()
val connectionCount = WebSocketConnection.getConnectionCount()

// Close specific connection
DevengNetworkingModule.closeWebSocketConnection("/chat")

// Close all connections
DevengNetworkingModule.closeAllWebSocketConnections()

try {
    val user = DevengNetworkingModule.sendRequest<Unit, User?>(
        endpoint = "/users/123",
        requestMethod = DevengHttpMethod.GET
    )
} catch (e: DevengException) {
    println("Error: ${e.message}") // Localized error message
}

class CustomExceptionHandler : ExceptionHandler {
    override var locale: Locale = Locale.EN

    override fun handleHttpException(
        errorMessage: String?,
        status: HttpStatusCode
    ): DevengUiError {
        // Custom HTTP error logic
        return when (status.value) {
            404 -> DevengUiError("Resource not found")
            500 -> DevengUiError("Server error occurred")
            else -> DevengUiError("Request failed: $errorMessage")
        }
    }

    override fun handleNetworkException(cause: Throwable): DevengUiError {
        // Custom network error logic
        return DevengUiError("Network connection failed")
    }
}

// Update authentication token at runtime
DevengNetworkingModule.setToken("new-auth-token")

dependencies {
    implementation(libs.deveng.networking.kmp)
}