Javaquarium

use "collections"
use "promises"
use "random"
use "term"
use "time"

// Une primitive est similaire à une classe, mais ne peut pas contenir
// de variables membres.
// De plus, toutes les instances d'une primitive ont la même identité
// (toutes les références référencent le même objet)

// Les variables et fonctions globales sont interdites en Pony.
// On utilise des primitives pour représenter des constantes
primitive HPAtBirth fun apply(): U64 => 10
primitive MaxAge fun apply(): U64 => 20
primitive MassPerSeaweed fun apply(): U64 => 10

primitive SeaweedGrowth fun apply(): U64 => 1

primitive HungerDamage fun apply(): U64 => 1
primitive HungerThreshold fun apply(): U64 => 5

primitive HerbHeal fun apply(): U64 => 3
primitive CarnHeal fun apply(): U64 => 5

primitive HerbDamage fun apply(): U64 => 2
primitive CarnDamage fun apply(): U64 => 4

primitive MaxSeaweedMass fun apply(): U64 => 50000
primitive MaxFish fun apply(): U64 => 100

// Définition des espèces de poissons

primitive Flounder
primitive Bass
primitive Carp

// Union de types. Un herbivore est une sole ou un bar ou une carpe
type Herbivorous is (Flounder | Bass | Carp)

primitive Grouper
primitive Tuna
primitive ClownFish

type Carnivorous is (Grouper | Tuna | ClownFish)

type Species is (Herbivorous | Carnivorous)

type Mono is (Carp | Tuna)
type Sequential is (Bass | Grouper)
type Opportunistic is (Flounder | ClownFish)

// Une classe
class Fish
  // Variables membres, ou champs.
  // Un champ est déclaré sous la forme
  // var/let nom: Type (= initialiseur)
  // var désigne une référence réassignable, let une référence fixe
  var _name: String
  var _is_male: Bool
  let _specie: Species
  // Sucre syntaxique : Type() <=> Type.create().apply()
  var _health: U64 = HPAtBirth()
  var _age: U64 = 0
  let _aquarium: Aquarium
  
  // Constructeur
  // On doit obligatoirement initialiser tous les champs qui n'ont pas d'initialiseur par défaut
  new create(nm: String, sp: Species, aq: Aquarium, ml: Bool) =>
    _name = nm
    _specie = sp
    _aquarium = aq
    // Pattern matching. On peut matcher sur des valeurs, des types ou les deux.
    match _specie
    | let l: Sequential => _is_male = true
    else
      _is_male = ml
    end
    
  // ref est une des 6 "reference capabilities"
  // Pour simplifier, une méthode déclarée ref ne peut être appelée que sur des objets mutables
  fun ref update() =>
    _health = _health - _health.min(1)
    _age = _age + 1
    // x == y <=> identité structurale (les champs des objets ont la même valeur)
    if _age == (MaxAge() / 2) then
      match _specie
      | let l: Sequential => _is_male = false
      end
    end
    if dead() then
      return
    end
    if _health <= HungerThreshold() then
      let hp =
        match _specie
        // En Pony, tout est expression, et toute expression retourne une valeur
        // Un if retourne la dernière expression dans son corps
        | let l: Herbivorous => if _aquarium.eat_seaweeds() then HerbHeal() else 0 end
        | let l: Carnivorous => if _aquarium.eat_fish(_specie) then CarnHeal() else 0 end
        else
          0
        end
      _health = _health + hp
    else
      // Bloc pouvant lever une exception
      // Les exceptions de Pony n'ont pas de type dynamique.
      // Elles doivent obligatoirement être attrapées
      try
        let partner = _aquarium.search_partner()
        // x is y <=> égalité identitaire (les références désignent le même objet)
        if (this is partner) or not (_specie is partner.specie()) then
          return
        end
        match _specie
        | let l: Opportunistic => if male() == partner.male() then _is_male = not _is_male end
        else
          if male() == partner.male() then
            return
          end
        end
          _aquarium.birth(_specie)
      end
    end
  
  fun ref damage() =>
    _health = if _health <= CarnDamage() then 0 else _health - CarnDamage() end

  // Une fonction qui retourne une valeur retourne également la dernière expression dans son corps
  fun name(): String => _name
  fun ref rename(new_name: String) => _name = new_name

  fun male(): Bool => _is_male

  fun specie(): Species => _specie
  
  fun dead(): Bool => (_health == 0) or (_age >= MaxAge())
  
  fun print(out: StdStream) =>
    out.print(_name + ", " + if _is_male then "male " else "female " end +
      match _specie
      | Flounder => "flounder"
      | Bass => "bass"
      | Carp => "carp"
      | Grouper => "grouper"
      | Tuna => "tuna"
      | ClownFish => "clown fish"
      else
        "unknown"
      end +
      ", " + _health.string() + " hp, age " + _age.string()
    )

class Aquarium
  var _seaweed_mass: U64 = 0
  let _fishs: Array[Fish] = Array[Fish]
  let _births: Array[Fish] = Array[Fish]
  let _deads: Array[String] = Array[String]
  var _turn: U64 = 0
  var _i: U64 = 0
  var _should_advance: Bool = true
  let _rand: Dice
  var _anon_count: U64 = 0
  
  new create() =>
    let tm = Time.now()
    let seed: U64 = (tm._1 xor tm._2).u64()
    _rand = Dice(MT(seed))
  
  fun ref add_seaweeds(count: U64) =>
    _seaweed_mass = (_seaweed_mass + (MassPerSeaweed() * count)).min(MaxSeaweedMass())
  
  fun ref remove_seaweeds(count: U64) =>
    _seaweed_mass = if _seaweed_mass <= (MassPerSeaweed() * count) then
      0
    else
      _seaweed_mass - (MassPerSeaweed() * count)
    end
 
  fun ref add_fish(name: String, sp: Species, male: Bool = false) =>
    _fishs.push(Fish(name, sp, this, male))
  
  // Le "?" indique une fonction partielle. Une exception peut sortir de la fonction
  fun ref remove_fish(idx: U64) ? =>
    _fishs.delete(idx)
  
  fun ref rename_fish(idx : U64, new_name: String) ? =>
    // Sucre syntaxique : objet(foo) <=> objet.apply(foo)
    _fishs(idx).rename(new_name)
  
  fun ref birth(sp: Species) =>
    if (_fishs.size() + _births.size()) < MaxFish() then
      _anon_count = _anon_count + 1
      _births.push(Fish("Anonymous" + _anon_count.string(), sp, this, (_rand(1, 2) - 1) == 0))
    end
  
  fun ref update() =>
    _deads.clear()
    _births.clear()
    _seaweed_mass = (_seaweed_mass + (SeaweedGrowth() * (_seaweed_mass / MassPerSeaweed()))).min(MaxSeaweedMass())
    _i = 0
    while _i < _fishs.size() do
      try
        _fishs(_i).update()
        if _fishs(_i).dead() then
          _update_on_death(_i)
        end
      end
      // Un assignement retourne l'ancienne valeur de la variable
      if _should_advance = true then
        _i = _i + 1
      end
    end
    for bir in _births.values() do
      _fishs.push(bir)
    end
    _turn = _turn + 1
  
  fun ref eat_seaweeds(): Bool =>
    if _seaweed_mass >= HerbDamage() then
      _seaweed_mass = _seaweed_mass - HerbDamage()
      true
    else
      false
    end
  
  fun ref eat_fish(specie: Species): Bool =>
    let i = _rand(1, _fishs.size()) - 1
    try
      if _fishs(i).specie() is specie then
        false
      else
        _fishs(i).damage()
        if _fishs(i).dead() then
          _update_on_death(i)
        end
        true
      end
    else
      false
    end
  
  fun ref search_partner(): Fish ? =>
    let i = _rand(1, _fishs.size()) - 1
    _fishs(i)
  
  fun ref _update_on_death(i: U64) =>
    try
      _deads.push(_fishs(i).name())
      _fishs.delete(i)
    end
    _should_advance = i > _i
  
  fun print(out: StdStream) =>
    out.print("Turn " + _turn.string())
    out.print("Seaweeds : " + (_seaweed_mass / MassPerSeaweed()).string() + " (Total mass : " + _seaweed_mass.string() + ")")
    out.print("Fishs :")
    var i = U32(0)
    for fish in _fishs.values() do
      out.write("#" + i.string() + " ")
      fish.print(out)
      i = i + 1
    end
    if _births.size() > 0 then
      out.print("")
      for bir in _births.values() do
        out.print(bir.name() + " is born!")
      end
    end
    if _deads.size() > 0 then
      out.print("")
      for dead in _deads.values() do
        out.print(dead + " is dead!")
      end
    end
    out.print("")

// Les entrées/sorties sont asynchrones en Pony.
// Cette classe gère les entrées console
class CommandHandler is ReadlineNotify
  let _commands: Array[String] = Array[String]
  let _aq: Aquarium
  let _out: StdStream
  
  new create(aq: Aquarium, out: StdStream) =>
    _commands.push("quit")
    _commands.push("print")
    _commands.push("update")
    _commands.push("add")
    _commands.push("kill")
    _commands.push("rename")
    _aq = aq
    _out = out
    
  fun ref apply(line: String, prompt: Promise[String]) =>
    // recover permet de changer la capability d'une expression.
    // Il y a bien sûr des restrictions sur les possibilités.
    // Ici, on transforme un iso (référence unique) en ref (référence pouvant avoir des alias)
    let args = recover ref line.split() end
    var i = U64(0)
    while i < args.size() do
      try
        if args(i) == "" then
          args.delete(i)
        else
          i = i + 1
        end
      end
    end
    try
      match args(0)
      | "quit" => prompt.reject()
      | "print" => _aq.print(_out)
      | "update" => _aq.update(); _aq.print(_out)
      | "add" => _handle_add(args)
      | "kill" => _aq.remove_fish(args(1).u64())
      | "rename" => _aq.rename_fish(args(1).u64(), args(2))
      else
        error
      end
    else
      _out.print("Invalid command")
    end
    prompt("> ")
  
  fun ref tab(line: String): Seq[String] box =>
    let r = Array[String]
    for command in _commands.values() do
      if command.at(line, 0) then
        r.push(command)
      end
    end
    r
  
  fun ref _handle_add(args: Array[String]) ? =>
    match args(1)
    | "fish" =>
      let name = args(2)
      let specie = match args(3)
      | "flounder" => Flounder
      | "bass" => Bass
      | "carp" => Carp
      | "grouper" => Grouper
      | "tuna" => Tuna
      | "clownfish" => ClownFish
      else
        error
      end
      let sex = match args(4)
      | "male" => true
      | "female" => false
      else
        error
      end
      _aq.add_fish(name, specie, sex)
    | "seaweeds" =>
      let count = args(2).i64()
      if count >= 0 then _aq.add_seaweeds(count.abs()) else _aq.remove_seaweeds(count.abs()) end
    else
      error
    end

// Le programme commence dans le constructeur de l'acteur Main
actor Main
  // env contient des éléments comme les arguments du programme, les flux d'entrée/sortie standard, etc
  new create(env: Env) =>
    env.out.print("Use 'quit' to quit")
    // On va transmettre ces objets à un autre acteur, on doit donc créer des références uniques.
    let aq = recover Aquarium end
    let term = recover ANSITerm(Readline(recover CommandHandler(consume aq, env.out) end, env.out), env.input) end
    term.prompt("> ")
    
    let notif = recover
      // Déclaration d'objet anonyme
      object is StdinNotify
        let term: ANSITerm = consume term
        
        fun ref apply(data: Array[U8] iso) =>
          term(consume data)
        
        fun ref dispose() =>
          term.dispose()
      end
    end
    
    env.input(consume notif)