eric / piclead-client

package fr.ebii.card2vcf.planning

import java.time.LocalDate
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue

/**
 * Port Kotlin de `Server/tests/calendrier.rs` : **les mêmes cas, les mêmes
 * valeurs attendues**. Si les deux suites divergent, le téléphone affichera une
 * date de fin différente de celle du Gantt web.
 *
 * Repères : 2026-01-05 est un lundi, 2026-01-09 un vendredi, 2026-01-10 un
 * samedi et 2026-01-11 un dimanche.
 */
class CalendrierOuvreTest {
    private fun j(s: String) = LocalDate.parse(s)

    @Test
    fun estOuvreDependDuRythme() {
        val samedi = j("2026-01-10")
        val dimanche = j("2026-01-11")
        val lundi = j("2026-01-05")

        for (rythme in listOf(5, 6, 7)) {
            assertTrue(CalendrierOuvre(rythme).estOuvre(lundi))
        }
        assertFalse(CalendrierOuvre(5).estOuvre(samedi))
        assertTrue(CalendrierOuvre(6).estOuvre(samedi))
        assertTrue(CalendrierOuvre(7).estOuvre(samedi))
        assertFalse(CalendrierOuvre(5).estOuvre(dimanche))
        assertFalse(CalendrierOuvre(6).estOuvre(dimanche))
        assertTrue(CalendrierOuvre(7).estOuvre(dimanche))
    }

    @Test
    fun calerAvanceAuProchainJourOuvre() {
        val samedi = j("2026-01-10")
        assertEquals(j("2026-01-12"), CalendrierOuvre(5).caler(samedi))
        assertEquals(samedi, CalendrierOuvre(6).caler(samedi))
        assertEquals(samedi, CalendrierOuvre(7).caler(samedi))
        val mardi = j("2026-01-06")
        assertEquals(mardi, CalendrierOuvre(5).caler(mardi), "jour déjà ouvré")
    }

    @Test
    fun finCompteDesJoursOuvres() {
        val vendredi = j("2026-01-09")
        assertEquals(j("2026-01-13"), CalendrierOuvre(5).fin(vendredi, 3))
        assertEquals(j("2026-01-12"), CalendrierOuvre(6).fin(vendredi, 3))
        assertEquals(j("2026-01-11"), CalendrierOuvre(7).fin(vendredi, 3))
    }

    @Test
    fun finDUneTacheDUnJourEstSonDebut() {
        val vendredi = j("2026-01-09")
        assertEquals(vendredi, CalendrierOuvre(5).fin(vendredi, 1))
        assertEquals(vendredi, CalendrierOuvre(5).fin(vendredi, 0), "durée nulle = un jour")
    }

    @Test
    fun finCaleUnDebutTombantUnJourChome() {
        val samedi = j("2026-01-10")
        assertEquals(j("2026-01-13"), CalendrierOuvre(5).fin(samedi, 2))
    }

    @Test
    fun avancerSauteLesJoursChomes() {
        val vendredi = j("2026-01-09")
        assertEquals(vendredi, CalendrierOuvre(5).avancer(vendredi, 0))
        assertEquals(j("2026-01-12"), CalendrierOuvre(5).avancer(vendredi, 1))
        assertEquals(j("2026-01-10"), CalendrierOuvre(6).avancer(vendredi, 1))
        assertEquals(j("2026-01-10"), CalendrierOuvre(7).avancer(vendredi, 1))
    }

    @Test
    fun compterLesJoursOuvresDUnIntervalle() {
        val lundi = j("2026-01-05")
        val dimanche = j("2026-01-11")
        assertEquals(5, CalendrierOuvre(5).compter(lundi, dimanche))
        assertEquals(6, CalendrierOuvre(6).compter(lundi, dimanche))
        assertEquals(7, CalendrierOuvre(7).compter(lundi, dimanche))
        assertEquals(10, CalendrierOuvre(5).compter(lundi, j("2026-01-18")))
        assertEquals(1, CalendrierOuvre(5).compter(lundi, lundi))
        assertEquals(0, CalendrierOuvre(5).compter(dimanche, lundi), "intervalle inversé")
    }

    @Test
    fun unRythmeAberrantRetombeSurSeptJours() {
        assertTrue(CalendrierOuvre(0).estOuvre(j("2026-01-11")))
        assertTrue(CalendrierOuvre(99).estOuvre(j("2026-01-11")))
    }

    @Test
    fun periodeAffichee() {
        assertEquals("09/01 → 13/01", CalendrierOuvre(5).periodeAffichee(j("2026-01-09"), 3))
        assertEquals("09/01", CalendrierOuvre(5).periodeAffichee(j("2026-01-09"), 1))
    }
}