Module 1 - Introduction à WikiJS et concepts de base

// IMPéRATIF : Comment faire étape par étape
var somme = 0
for (i <- 0 until liste.length) {
  somme += liste(i)
}

// FONCTIONNEL : Quoi faire, pas comment
val somme = liste.sum
// ou
val somme = liste.reduce(_ + _)

// Style impératif - étape par étape
def findMax(numbers: Array[Int]): Int = {
  var max = numbers(0)              // 1. Initialiser le maximum
  var i = 1                         // 2. Initialiser l'index
  
  while (i < numbers.length) {      // 3. Boucler tant qu'il y a des éléments
    if (numbers(i) > max) {         // 4. Comparer l'élément actuel
      max = numbers(i)              // 5. Mettre à  jour si nécessaire
    }
    i += 1                          // 6. Passer à  l'élément suivant
  }
  
  max                               // 7. Retourner le résultat
}

// Classe abstraite : définit le contrat
abstract class Forme {
  def aire(): Double
  def perimetre(): Double
  
  // Méthode concrète commune
  def description(): String = s"Aire: ${aire()}, Périmètre: ${perimetre()}"
}

// Implémentation spécifique : Rectangle
class Rectangle(val largeur: Double, val hauteur: Double) extends Forme {
  def aire(): Double = largeur * hauteur
  def perimetre(): Double = 2 * (largeur + hauteur)
}

// Implémentation spécifique : Cercle
class Cercle(val rayon: Double) extends Forme {
  def aire(): Double = math.Pi * rayon * rayon
  def perimetre(): Double = 2 * math.Pi * rayon
}

// Utilisation polymorphe
val formes: List[Forme] = List(
  new Rectangle(5, 3),
  new Cercle(2)
)

formes.foreach(forme => println(forme.description()))

// Données immutables
val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// Fonctions pures
def estPair(n: Int): Boolean = n % 2 == 0
def doubler(n: Int): Int = n * 2
def additionner(a: Int, b: Int): Int = a + b

// Composition de fonctions
val resultat = numbers
  .filter(estPair)           // Garder seulement les pairs: [2, 4, 6, 8, 10]
  .map(doubler)              // Doubler chaque nombre: [4, 8, 12, 16, 20]
  .reduce(additionner)       // Additionner tous: 60

println(s"Résultat: $resultat") // Résultat: 60

// Version encore plus concise
val resultatConcis = numbers
  .filter(_ % 2 == 0)
  .map(_ * 2)
  .sum

// ❌ FONCTION IMPURE : résultat dépend d'un état externe
var compteur = 0
def incrementerImpure(): Int = {
  compteur += 1  // Modifie l'état global
  compteur       // Résultat différent à  chaque appel
}

// ✅ FONCTION PURE : résultat déterministe
def incrementerPure(valeur: Int): Int = {
  valeur + 1     // Ne modifie rien, retourne simplement valeur + 1
}

// Utilisation
println(incrementerImpure()) // 1
println(incrementerImpure()) // 2 - Résultat différent !

println(incrementerPure(5))  // 6
println(incrementerPure(5))  // 6 - Toujours le même résultat

// ===== ORIENTé OBJET : Définition des structures =====
case class Personne(nom: String, age: Int, salaire: Double)

class Entreprise(val nom: String) {
  private var employes: List[Personne] = List()
  
  // Méthode OOP pour ajouter un employé
  def ajouterEmploye(personne: Personne): Unit = {
    employes = personne :: employes  // Style hybride : immutable + mutable
  }
  
  // ===== FONCTIONNEL : Traitement des données =====
  def calculerMoyenneSalaire(): Double = {
    employes
      .map(_.salaire)           // Transformation fonctionnelle
      .sum / employes.length    // Réduction fonctionnelle
  }
  
  def employesEligiblesBonus(seuilAge: Int): List[Personne] = {
    employes
      .filter(_.age >= seuilAge)    // Filtrage fonctionnel
      .sortBy(_.salaire)            // Tri fonctionnel
  }
  
  // ===== IMPéRATIF : Quand c'est plus clair =====
  def afficherStatistiques(): Unit = {
    println(s"Entreprise: $nom")
    println(s"Nombre d'employés: ${employes.length}")
    
    if (employes.nonEmpty) {
      val moyenne = calculerMoyenneSalaire()
      println(f"Salaire moyen: $moyenne%.2f€")
      
      // Boucle impérative pour l'affichage détaillé
      for (employe <- employes.sortBy(_.nom)) {
        println(s"  - ${employe.nom}, ${employe.age} ans: ${employe.salaire}€")
      }
    } else {
      println("Aucun employé")
    }
  }
}

// ===== UTILISATION =====
val entreprise = new Entreprise("TechCorp")

// Style OOP
entreprise.ajouterEmploye(Personne("Alice", 30, 50000))
entreprise.ajouterEmploye(Personne("Bob", 25, 45000))
entreprise.ajouterEmploye(Personne("Charlie", 35, 60000))

// Style fonctionnel
val eligibles = entreprise.employesEligiblesBonus(30)
println(s"Employés éligibles au bonus: ${eligibles.map(_.nom).mkString(", ")}")

// Style impératif pour l'affichage
entreprise.afficherStatistiques()