# Installer Jason pour JSON si besoin
Mix.install([
  {:jason, "~> 1.4"}
])

defmodule ZombieApocalypse do
  @state_file "states.json"
  @final_file "states_final.json"

  # Démarrage de la simulation
  def start(humans \\ 10, zombies \\ 3, max_hours \\ 200) do
    # Vider le fichier temporaire
    File.write!(@state_file, "")

    IO.puts("🧟 Lancement de la simulation Zombie Apocalypse !")

    # Ouvrir le fichier en continu pour append rapide
    {:ok, file} = File.open(@state_file, [:write, :utf8])

    # Boucle principale
    loop(0, humans, zombies, max_hours, file)

    # Fermer le fichier
    File.close(file)

    # Générer JSON final
    finalize_json()
  end

  # Boucle principale
  defp loop(hour, humans, zombies, max_hours, file) when hour < max_hours do
    state = %{
      hour: hour,
      humans: humans,
      zombies: zombies,
      timestamp: DateTime.utc_now()
    }

    # Append rapide
    IO.write(file, Jason.encode!(state) <> "\n")

    # Afficher seulement toutes les 10 heures
    if rem(hour, 10) == 0 do
      IO.puts("Heure #{hour} | Humains: #{humans} | Zombies: #{zombies}")
    end

    cond do
      humans <= 0 ->
        IO.puts("💀 Tous les humains ont été infectés.")

      zombies <= 0 ->
        IO.puts("🎉 Tous les zombies ont été éliminés.")

      true ->
        {new_humans, new_zombies} = simulate_hour(humans, zombies)
        loop(hour + 1, new_humans, new_zombies, max_hours, file)
    end
  end

  defp loop(_hour, _humans, _zombies, _max_hours, _file), do: :ok

  # Simulation d'une heure (calcul probabiliste)
  defp simulate_hour(humans, zombies) do
    attacks = zombies
    # Humains infectés : chaque attaque a 40% de chance
    humans_lost = Enum.count(1..attacks, fn _ -> :rand.uniform(100) <= 40 end)
    # Zombies tués : chaque attaque a 15% de chance
    zombies_lost = Enum.count(1..attacks, fn _ -> :rand.uniform(100) <= 15 end)

    humans = max(humans - humans_lost, 0)
    zombies = max(zombies - zombies_lost + humans_lost, 0) # infections
    {humans, zombies}
  end

  # Générer le JSON final complet
  defp finalize_json do
    states =
      File.stream!(@state_file)
      |> Stream.map(&Jason.decode!/1)
      |> Enum.to_list()

    File.write!(@final_file, Jason.encode!(states, pretty: true))
    IO.puts("✅ JSON final créé : #{@final_file}")
  end
end

# Lancer la simulation
ZombieApocalypse.start(7000000000, 3, 200)