SIRH/frontend/composables/useEmployeeRtt.ts

import type { Ref } from 'vue'
import type { EmployeeRttSummary } from '~/services/dto/employee-rtt-summary'
import type { Employee } from '~/services/dto/employee'
import { getEmployeeRttSummary, createRttPayment } from '~/services/employee-rtt-summary'

export type RttYearOption = {
  value: number
  label: string
}

export const useEmployeeRtt = (employee: Ref<Employee | null>, reloadEmployee: () => Promise<void>) => {
  const rttSummary = ref<EmployeeRttSummary | null>(null)
  const isRttLoading = ref(false)
  const rttDataLoaded = ref(false)
  const selectedRttYear = ref<number | null>(null)

  // Exercice RTT : Juin (Y-1) → Mai (Y). Toujours, peu importe le type de contrat
  // (l'onglet RTT est masqué pour les FORFAIT côté page).
  const computeRttYearForDate = (date: Date): number =>
    date.getMonth() >= 5 ? date.getFullYear() + 1 : date.getFullYear()

  const currentRttYear = computed<number | null>(() => {
    if (!employee.value) return null
    return computeRttYearForDate(new Date())
  })

  const availableRttYears = computed<RttYearOption[]>(() => {
    if (!employee.value || currentRttYear.value === null) return []
    const current = currentRttYear.value

    const startDates: string[] = []
    for (const period of employee.value.contractHistory ?? []) {
      if (period.startDate) startDates.push(period.startDate)
    }
    if (employee.value.entryDate) startDates.push(employee.value.entryDate)

    let contractFloor = current
    for (const raw of startDates) {
      const date = new Date(`${raw.substring(0, 10)}T00:00:00`)
      if (Number.isNaN(date.getTime())) continue
      const rttYear = computeRttYearForDate(date)
      if (rttYear < contractFloor) contractFloor = rttYear
    }

    // Hard floor : rttStartDate (env RTT_START_DATE) — pas d'historique avant.
    let dataFloor: number | null = null
    const dataStart = rttSummary.value?.rttStartDate
    if (dataStart) {
      const dataStartDate = new Date(`${dataStart.substring(0, 10)}T00:00:00`)
      if (!Number.isNaN(dataStartDate.getTime())) {
        dataFloor = computeRttYearForDate(dataStartDate)
      }
    }

    const minYear = dataFloor !== null ? Math.max(contractFloor, dataFloor) : contractFloor

    const years: RttYearOption[] = []
    for (let y = current; y >= minYear; y -= 1) {
      years.push({ value: y, label: `Juin ${y - 1} → Mai ${y}` })
    }
    return years
  })

  const initSelectedRttYear = () => {
    if (selectedRttYear.value !== null) return
    if (currentRttYear.value !== null) {
      selectedRttYear.value = currentRttYear.value
    }
  }

  const loadRttData = async () => {
    if (!employee.value || isRttLoading.value) return
    initSelectedRttYear()
    if (selectedRttYear.value === null) return
    isRttLoading.value = true
    try {
      rttSummary.value = await getEmployeeRttSummary(employee.value.id, selectedRttYear.value)
      rttDataLoaded.value = true
    } finally {
      isRttLoading.value = false
    }
  }

  const setSelectedRttYear = async (year: number) => {
    if (selectedRttYear.value === year) return
    selectedRttYear.value = year
    rttDataLoaded.value = false
    await loadRttData()
  }

  const resetLoaded = () => {
    rttDataLoaded.value = false
    selectedRttYear.value = null
  }

  const submitRttPayment = async (month: number, base25Minutes: number, bonus25Minutes: number, base50Minutes: number, bonus50Minutes: number) => {
    if (!employee.value) return
    const year = rttSummary.value?.year ?? undefined
    await createRttPayment(employee.value.id, month, base25Minutes, bonus25Minutes, base50Minutes, bonus50Minutes, year)
    await reloadEmployee()
  }

  return {
    rttSummary,
    isRttLoading,
    rttDataLoaded,
    selectedRttYear,
    currentRttYear,
    availableRttYears,
    setSelectedRttYear,
    loadRttData,
    resetLoaded,
    submitRttPayment
  }
}