package com.doublesymmetry.trackplayer.models

import org.junit.Test
import org.junit.Assert.*

class EmitEventTest {

    @Test
    fun `PlaybackStateChangedEvent produces correct pairs`() {
        val event = PlaybackStateChangedEvent("ready")
        assertEquals(EmitEventType.PLAYBACK_STATE_CHANGED, event.type)
        assertEquals(1, event.pairs().size)
        assertEquals("state" to "ready", event.pairs()[0])
    }

    @Test
    fun `IsPlayingChangedEvent produces correct pairs`() {
        val event = IsPlayingChangedEvent(true)
        assertEquals("playing" to true, event.pairs()[0])
    }

    @Test
    fun `MediaItemTransitionEvent with null item omits item`() {
        val event = MediaItemTransitionEvent(null, 3)
        assertEquals(1, event.pairs().size)
        assertEquals("index" to 3, event.pairs()[0])
    }

    @Test
    fun `MediaItemTransitionEvent with item includes both`() {
        val event = MediaItemTransitionEvent("item-data", 0)
        assertEquals(2, event.pairs().size)
        assertTrue(event.pairs().any { it.first == "index" && it.second == 0 })
        assertTrue(event.pairs().any { it.first == "item" && it.second == "item-data" })
    }

    @Test
    fun `SleepTimerTriggeredEvent produces correct pairs`() {
        val event = SleepTimerTriggeredEvent("time")
        assertEquals(EmitEventType.SLEEP_TIMER_TRIGGERED, event.type)
        assertEquals("type" to "time", event.pairs()[0])
    }

    @Test
    fun `PlaybackErrorEvent produces code and message`() {
        val event = PlaybackErrorEvent("network", "Connection failed")
        assertTrue(event.pairs().any { it.first == "code" && it.second == "network" })
        assertTrue(event.pairs().any { it.first == "message" && it.second == "Connection failed" })
    }

    @Test
    fun `MetadataReceivedEvent with partial fields only includes non-null`() {
        val event = MetadataReceivedEvent(title = "Song", artist = null)
        assertEquals(1, event.pairs().size)
        assertEquals("title" to "Song", event.pairs()[0])
    }

    @Test
    fun `MediaMetadataChangedEvent uses media-metadata-changed event type`() {
        val event = MediaMetadataChangedEvent(title = "Song", artist = "Artist")
        assertEquals(EmitEventType.MEDIA_METADATA_CHANGED, event.type)
        assertEquals("event.media-metadata-changed", event.type.value)
    }

    @Test
    fun `MediaMetadataChangedEvent emits all set fields with normalized keys`() {
        val event = MediaMetadataChangedEvent(
            title = "Song",
            artist = "Artist",
            albumTitle = "Album",
            artworkUri = "https://art",
            genre = "Jazz",
        )
        val pairs = event.pairs().toMap()
        assertEquals("Song", pairs["title"])
        assertEquals("Artist", pairs["artist"])
        assertEquals("Album", pairs["albumTitle"])
        // artwork is published under the JS-facing `artworkUrl` key, matching
        // the public MediaItem schema (not the Media3 `artworkUri`).
        assertEquals("https://art", pairs["artworkUrl"])
        assertEquals("Jazz", pairs["genre"])
    }

    @Test
    fun `MediaMetadataChangedEvent only emits non-null fields`() {
        val event = MediaMetadataChangedEvent(title = "Song", artist = null)
        assertEquals(1, event.pairs().size)
        assertEquals("title" to "Song", event.pairs()[0])
    }

    @Test
    fun `QueueChangedEvent has empty pairs`() {
        assertEquals(0, QueueChangedEvent().pairs().size)
    }

    @Test
    fun `all EmitEventType values have unique string values`() {
        val values = EmitEventType.entries.map { it.value }
        assertEquals(values.size, values.toSet().size)
    }
}