package agzam.vyatsu

import agzam.vyatsu.data.remote.TeachersParser
import agzam.vyatsu.domain.model.DateRange
import agzam.vyatsu.domain.model.Season
import java.io.InputStream
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test

class TeachersPipelineMemoryTest {

    private fun fixture(): InputStream =
        checkNotNull(javaClass.getResourceAsStream("/teacher.html")) {
            "Fixture teacher.html not found in src/test/resources"
        }

    @Test
    fun parsesDepartmentsAndFaculties() {
        val result = fixture().use(TeachersParser::parseStream)
        assertTrue("expected >=4 departments", result.departments.size >= 4)

        val ids = result.departments.map { it.departmentId }.toSet()
        assertEquals(setOf("11111", "22222", "33333", "44444"), ids)

        val names = result.departments.map { it.name }
        assertTrue(
            "nested tags must be stripped from kafPeriod names",
            names.contains("Кафедра технологий и конструирования машин и аппаратов")
        )

        val avt = result.departments.first { it.departmentId == "11111" }
        assertTrue("faculty must be mapped via shortname", avt.faculty.contains("ФАВТ"))
    }

    @Test
    fun chunkBoundarySafe() {
        val full = fixture().use(TeachersParser::parseStream)
        val limited = limitReads(fixture(), 64).use(TeachersParser::parseStream)
        assertEquals(full, limited)
    }

    @Test
    fun seasonAndRanges() {
        val result = fixture().use(TeachersParser::parseStream)

        val hasAutumn = result.dateRanges.values.any { it[Season.AUTUMN]?.isNotEmpty() == true }
        val hasSpring = result.dateRanges.values.any { it[Season.SPRING]?.isNotEmpty() == true }
        assertTrue("AUTUMN season must be present", hasAutumn)
        assertTrue("SPRING season must be present", hasSpring)

        val autumn = result.dateRanges["11111"]?.get(Season.AUTUMN).orEmpty()
        assertTrue(
            "DateRange must be parsed from URL groups",
            autumn.contains(DateRange("01092026", "13092026"))
        )
        assertTrue(
            "second AUTUMN range must be present",
            autumn.contains(DateRange("14092026", "27092026"))
        )

        val spring = result.dateRanges["44444"]?.get(Season.SPRING).orEmpty()
        assertTrue(
            "SPRING DateRange must be parsed from URL groups",
            spring.contains(DateRange("02022026", "27022026"))
        )
    }

    private fun limitReads(input: InputStream, maxBytes: Int): InputStream =
        object : InputStream() {
            override fun read(): Int = input.read()

            override fun read(b: ByteArray, off: Int, len: Int): Int =
                input.read(b, off, minOf(len, maxBytes))
        }
}