import { syncLinkedInPosts } from './linkedin-sync'

let prochaine: NodeJS.Timeout | null = null

/** Millisecondes jusqu'au prochain minuit, heure du serveur. */
function jusquAMinuit(): number {
  const maintenant = new Date()
  const minuit = new Date(maintenant)
  minuit.setDate(minuit.getDate() + 1)
  minuit.setHours(0, 0, 0, 0)
  return minuit.getTime() - maintenant.getTime()
}

async function synchroniser() {
  const debut = new Date().toISOString()
  console.log(`[LinkedIn] Synchronisation lancée à ${debut}`)

  const resultat = await syncLinkedInPosts()

  if (resultat.success) {
    console.log(`[LinkedIn] ${resultat.count} publication(s) synchronisée(s)`)
  } else {
    // Le jeton d'accès vit soixante jours : son expiration est la panne la
    // plus fréquente, et le message doit dire quoi faire plutôt que de
    // laisser lire une erreur d'API brute.
    const erreur = String(resultat.error ?? '')
    console.error(`[LinkedIn] Échec : ${erreur}`)
    if (/expired|401|invalid.token/i.test(erreur)) {
      console.error(
        '[LinkedIn] Le jeton semble expiré. Relancer : node scripts/setup-linkedin.js'
      )
    }
  }
}

/**
 * Programme la synchronisation LinkedIn à minuit, chaque nuit.
 *
 * Deux défauts corrigés par rapport à la version précédente.
 *
 * Elle synchronisait d'abord au démarrage : en développement, chaque
 * redémarrage du serveur appelait donc LinkedIn, ce qui use le quota d'appels
 * sans rien apporter. La synchronisation de rattrapage se demande désormais
 * explicitement, par LINKEDIN_SYNC_AU_DEMARRAGE=true.
 *
 * Elle programmait ensuite un intervalle de vingt-quatre heures, qui dérive :
 * un serveur démarré à 8 h 03 voyait sa synchronisation glisser d'un peu plus
 * chaque jour, et les changements d'heure la décalaient d'une heure entière.
 * Chaque exécution reprogramme maintenant la suivante sur le minuit réel.
 */
export function startLinkedInCron() {
  stopLinkedInCron()

  const programmer = () => {
    const attente = jusquAMinuit()
    prochaine = setTimeout(async () => {
      await synchroniser()
      programmer()
    }, attente)

    const heures = Math.floor(attente / 3_600_000)
    const minutes = Math.round((attente % 3_600_000) / 60_000)
    console.log(`[LinkedIn] Prochaine synchronisation dans ${heures} h ${minutes} min`)
  }

  if (process.env.LINKEDIN_SYNC_AU_DEMARRAGE === 'true') {
    void synchroniser()
  }

  programmer()
}

export function stopLinkedInCron() {
  if (prochaine) {
    clearTimeout(prochaine)
    prochaine = null
  }
}