package com.suno.android.common_networking.sse

import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test

class SseLineParserTest {
    private val subject = SseLineParser()

    @Test
    fun `given line starting with id colon when parseLine called then returns Id with trimmed content`() {
        val line = "id: event-123"

        val result = subject.parseLine(rawLine = line)

        assertIdResult(result = result, expectedId = "event-123")
    }

    @Test
    fun `given line with id prefix and only spaces when parseLine called then returns Id with empty string`() {
        val line = "id:     "

        val result = subject.parseLine(rawLine = line)

        assertIdResult(result = result, expectedId = "")
    }

    @Test
    fun `given line with id and no space after colon when parseLine called then returns Id with content`() {
        val line = "id:abc-xyz-789"

        val result = subject.parseLine(rawLine = line)

        assertIdResult(result = result, expectedId = "abc-xyz-789")
    }

    @Test
    fun `given line starting with data colon when parseLine called then returns Data with trimmed content`() {
        val line = "data: {\"id\":\"123\"}"

        val result = subject.parseLine(rawLine = line)

        assertDataResult(result = result, expectedData = "{\"id\":\"123\"}")
    }

    @Test
    fun `given line with data prefix and only spaces when parseLine called then returns Data with empty string`() {
        val line = "data:     "

        val result = subject.parseLine(rawLine = line)

        assertDataResult(result = result, expectedData = "")
    }

    @Test
    fun `given line starting with event colon when parseLine called then returns Event with trimmed content`() {
        val line = "event: custom-event"

        val result = subject.parseLine(rawLine = line)

        assertEventResult(result = result, expectedEventType = "custom-event")
    }

    @Test
    fun `given line with event prefix and only spaces when parseLine called then returns Event with empty string`() {
        val line = "event:     "

        val result = subject.parseLine(rawLine = line)

        assertEventResult(result = result, expectedEventType = "")
    }

    @Test
    fun `given retry line with valid number when parseLine called then returns Retry with parsed value`() {
        val line = "retry: 5000"

        val result = subject.parseLine(rawLine = line)

        assertRetryResult(result = result, expectedRetryMs = 5000L)
    }

    @Test
    fun `given retry line with invalid number when parseLine called then returns Retry with null`() {
        val line = "retry: not-a-number"

        val result = subject.parseLine(rawLine = line)

        assertRetryResult(result = result, expectedRetryMs = null)
    }

    @Test
    fun `given line starting with colon when parseLine called then returns Comment`() {
        val line = ": this is a comment"

        val result = subject.parseLine(rawLine = line)

        assertCommentResult(result = result)
    }

    @Test
    fun `given blank line when parseLine called then returns EndOfEvent`() {
        val line = ""

        val result = subject.parseLine(rawLine = line)

        assertEndOfEventResult(result = result)
    }

    @Test
    fun `given line with only spaces when parseLine called then returns EndOfEvent`() {
        val line = "    "

        val result = subject.parseLine(rawLine = line)

        assertEndOfEventResult(result = result)
    }

    @Test
    fun `given unrecognized line format when parseLine called then returns Other`() {
        val line = "random text without prefix"

        val result = subject.parseLine(rawLine = line)

        assertOtherResult(result = result)
    }

    private fun assertIdResult(
        result: SseLineParser.ParsedLine,
        expectedId: String,
    ) {
        assertTrue(result is SseLineParser.ParsedLine.Id)
        assertEquals(expectedId, (result as SseLineParser.ParsedLine.Id).id)
    }

    private fun assertDataResult(
        result: SseLineParser.ParsedLine,
        expectedData: String,
    ) {
        assertTrue(result is SseLineParser.ParsedLine.Data)
        assertEquals(expectedData, (result as SseLineParser.ParsedLine.Data).data)
    }

    private fun assertEventResult(
        result: SseLineParser.ParsedLine,
        expectedEventType: String,
    ) {
        assertTrue(result is SseLineParser.ParsedLine.Event)
        assertEquals(expectedEventType, (result as SseLineParser.ParsedLine.Event).eventType)
    }

    private fun assertRetryResult(
        result: SseLineParser.ParsedLine,
        expectedRetryMs: Long?,
    ) {
        assertTrue(result is SseLineParser.ParsedLine.Retry)
        if (expectedRetryMs == null) {
            assertNull((result as SseLineParser.ParsedLine.Retry).retryMs)
        } else {
            assertEquals(expectedRetryMs, (result as SseLineParser.ParsedLine.Retry).retryMs)
        }
    }

    private fun assertCommentResult(
        result: SseLineParser.ParsedLine,
    ) {
        assertTrue(result is SseLineParser.ParsedLine.Comment)
    }

    private fun assertEndOfEventResult(
        result: SseLineParser.ParsedLine,
    ) {
        assertTrue(result is SseLineParser.ParsedLine.EndOfEvent)
    }

    private fun assertOtherResult(
        result: SseLineParser.ParsedLine,
    ) {
        assertTrue(result is SseLineParser.ParsedLine.Other)
    }
}