package com.example.aiapp

import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue

class PendingMessagesTest {
    private fun local(text: String = "keep this") =
        QueuedMessage("local-1", text, emptyList(), local = true)

    @Test
    fun a_server_queue_replaces_the_local_bridge_instead_of_duplicating_it() {
        val queued =
            reconcileQueuedMessage(
                listOf(local()),
                SessionEvent.MessageQueued("server-1", "keep this", emptyList()),
            )

        assertEquals(1, queued.size)
        assertEquals("server-1", queued.single().id)
        assertTrue(!queued.single().local)
    }

    @Test
    fun an_immediately_received_message_removes_its_local_bridge() {
        val queued =
            reconcileUserMessage(
                listOf(local()),
                SessionEvent.UserMessage("keep this", id = null, attachments = emptyList()),
            )

        assertTrue(queued.isEmpty())
    }

    @Test
    fun a_transport_failure_stays_on_its_message() {
        val queued = markPendingFailure(listOf(local()), "local-1", "Can't reach the server")

        assertEquals("Can't reach the server", queued.single().refusal)
        assertTrue(queued.single().local)
    }

    @Test
    fun server_acceptance_keeps_the_bubble_until_the_provider_event() {
        val queued = markPendingAccepted(listOf(local()), "local-1")

        assertEquals(1, queued.size)
        assertTrue(queued.single().serverAccepted)
    }

    @Test
    fun discarding_a_failed_send_removes_only_that_local_copy() {
        val server = QueuedMessage("server-1", "already accepted", emptyList())
        val queued = listOf(local(), local("keep this one").copy(id = "local-2"), server)

        val discarded = discardPendingMessage(queued, "local-1")

        assertEquals(listOf("local-2", "server-1"), discarded.map { it.id })
    }

    @Test
    fun identical_messages_are_reconciled_one_at_a_time() {
        val queued = listOf(local(), local().copy(id = "local-2"))
        val afterFirst =
            reconcileUserMessage(
                queued,
                SessionEvent.UserMessage("keep this", id = null, attachments = emptyList()),
            )

        assertEquals(listOf("local-2"), afterFirst.map { it.id })
    }
}