commonMain.dependencies {
    implementation("io.github.marcinsiwak:klocalnet:1.0.6")
}

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        KLocalNet.init(this)
    }
}

fun initializeApp() {
    KLocalNet.init()
}

// Get the manager instance
val manager = KLocalNet.getKLocalNetManager()

// Observe WiFi connection state
launch {
    manager.isWifiConnected.collect { isConnected ->
        println("WiFi connected: $isConnected")
    }
}

// Observe loading state
launch {
    manager.isLoading.collect { isLoading ->
        println("Loading: $isLoading")
    }
}

// Connect to the network
launch {
    manager.connect()
}

@Serializable
data class ChatMessage(
    val userId: String,
    val message: String,
    val timestamp: Long
) : WebSocketEvent()

@Serializable
data class GameStateUpdate(
    val gameId: String,
    val state: String
) : WebSocketEvent()

manager.setCustomEvents(
    listOf(
        ChatMessage::class to serializer<ChatMessage>(),
        GameStateUpdate::class to serializer<GameStateUpdate>()
    )
)

launch {
    manager.serverMessages.collect { event ->
        when (event) {
            is ClientActions.UserConnected -> {
                println("User connected: ${event.id}, isHost: ${event.isHost}")
            }
            is ClientActions.UserDisconnected -> {
                println("User disconnected: ${event.id}")
            }
            is ChatMessage -> {
                println("Received chat: ${event.message}")
                // Process the message
            }
            // Handle other custom events
        }
    }
}

launch {
    manager.clientMessages.collect { event ->
        when (event) {
            is ServerActions.ServerStarted -> {
                println("Server has started")
            }
            is ClientActions.ServerDownDetected -> {
                println("Server is down, re-election in progress")
            }
            is ChatMessage -> {
                println("Received chat: ${event.message}")
            }
            // Handle other custom events
        }
    }
}

val userId = "192.168.1.5"
val message = ChatMessage(
    userId = manager.getDeviceId(),
    message = "Hello from server!",
    timestamp = System.currentTimeMillis()
)

launch {
    manager.send(id = userId, webSocketEvent = message)
}

val message = GameStateUpdate(
    gameId = "game123",
    state = "started"
)

launch {
    manager.sendToAll(webSocketEvent = message)
}

val message = ChatMessage(
    userId = manager.getDeviceId(),
    message = "Hello from client!",
    timestamp = System.currentTimeMillis()
)

launch {
    manager.sendFromClient(webSocketEvent = message)
}

val isServer = manager.isServerRunning()
if (isServer) {
    println("This device is the host")
}

val deviceId = manager.getDeviceId()
println("My device ID: $deviceId") // e.g., "192.168.1.5"

// Device with an active session gets priority in server election
manager.setHasSession(
    hasSession = true,
    lastUpdate = System.currentTimeMillis()
)

launch {
    manager.disconnectUsers()
}

@Serializable
data class ChatMessage(
    val userId: String,
    val message: String
) : WebSocketEvent()

class ChatManager {
    private val manager = KLocalNet.getKLocalNetManager()
    
    init {
        // Register custom events
        manager.setCustomEvents(
            listOf(ChatMessage::class to serializer<ChatMessage>())
        )
        
        // Start observing messages
        observeMessages()
    }
    
    private fun observeMessages() {
        // Listen for messages as server
        launch {
            manager.serverMessages.collect { event ->
                when (event) {
                    is ChatMessage -> {
                        println("${event.userId}: ${event.message}")
                        // Broadcast to all clients
                        manager.sendToAll(event)
                    }
                    is ClientActions.UserConnected -> {
                        println("${event.id} joined the chat")
                    }
                }
            }
        }
        
        // Listen for messages as client
        launch {
            manager.clientMessages.collect { event ->
                if (event is ChatMessage) {
                    println("${event.userId}: ${event.message}")
                }
            }
        }
    }
    
    suspend fun sendMessage(text: String) {
        val message = ChatMessage(
            userId = manager.getDeviceId(),
            message = text
        )
        
        if (manager.isServerRunning()) {
            // If we're the server, broadcast to everyone
            manager.sendToAll(message)
        } else {
            // If we're a client, send to server
            manager.sendFromClient(message)
        }
    }
}