---
# L'ETAT D'UNE INCARNATION PRECEDENTE ATTEND-IL CE JEU ?
#
# Inclus par le role PROPRIETAIRE de l'etat, au moment precis ou il le creerait neuf :
# l'AC avant `step ca init`, les bases juste creees, l'annuaire une fois son schema pose...
# C'est lui qui sait quand son etat est « vierge » ; ce fichier sait ou est le depot.
#
#   entree : client_backup_restaurer_jeu    — groupe du catalogue (ex. serveur_step_ca)
#            client_backup_restaurer_vierge — le role n'a encore RIEN de cet etat
#   sortie : client_backup_restauration     — {jeu, etat, instantane, chemins}
#
# etat : `a_restaurer` (au role de le remettre, puis d'inclure `acter.yml`), `acte`
# (deja tranche a une passe precedente), `en_place` (un etat existe : on ne l'ecrase
# jamais d'office), `neuf` (rien d'anterieur), `sans_objet`, `simulation`.
- name: Restauration — le jeu et ce qu'il emporte
  ansible.builtin.set_fact:
    client_backup_restauration:
      jeu: "{{ client_backup_catalogue[client_backup_restaurer_jeu].nom }}"
      chemins: "{{ client_backup_catalogue[client_backup_restaurer_jeu].chemins }}"
      etat: >-
        {{ 'simulation' if ansible_check_mode
           else ('sans_objet' if ('client_backup' not in group_names)
           else ('desactive' if not (client_backup_restauration_active | bool)
           else 'a_decider')) }}
      instantane: ""

- name: Restauration — trancher pour ce jeu
  when: client_backup_restauration.etat != 'sans_objet' and client_backup_restauration.etat != 'simulation'
  block:
    - name: Restauration — ce jeu a-t-il deja ete tranche ?
      ansible.builtin.slurp:
        src: "{{ client_backup_restauration_marques }}/{{ client_backup_restauration.jeu }}"
      register: client_backup_marque_lue
      failed_when: false

    - name: Restauration — deja tranche a une passe precedente
      ansible.builtin.set_fact:
        client_backup_restauration: >-
          {{ client_backup_restauration | combine({'etat': 'acte',
             'instantane': ((client_backup_marque_lue.content | b64decode).splitlines()
                            | select('match', '^instantane=') | first
                            | default('instantane=')).split('=', 1)[1]}) }}
      when: client_backup_marque_lue.content is defined

    - name: "Restauration — desactivee, ou un etat existe deja, l'acter tel quel"
      ansible.builtin.include_tasks: acter.yml
      vars:
        client_backup_acter_etat: "{{ 'desactive' if client_backup_restauration.etat == 'desactive' else 'en_place' }}"
      when:
        - client_backup_marque_lue.content is not defined
        - client_backup_restauration.etat == 'desactive' or not (client_backup_restaurer_vierge | bool)

    # LA CONDITION D'UN BLOC SE REEVALUE A CHAQUE TACHE. Ecrite sur `etat`, elle se
    # fermerait des que le choix le change — et « rien d'anterieur » ne serait jamais acte.
    # On la fige donc avant d'entrer.
    - name: Restauration — faut-il interroger le depot ?
      ansible.builtin.set_fact:
        client_backup_interroger: >-
          {{ client_backup_marque_lue.content is not defined
             and client_backup_restauration.etat == 'a_decider'
             and (client_backup_restaurer_vierge | bool) }}

    - name: Restauration — interroger le depot
      when: client_backup_interroger | bool
      block:
        - name: Restauration — acces au depot (le role client_backup n'a peut-etre pas encore tourne)
          ansible.builtin.include_tasks: acces.yml

        # Code 2 = depot ILLISIBLE : on echoue. Conclure « rien a restaurer » faute de
        # joindre le depot ferait naitre neuf ce qui attend chez l'hebergeur.
        - name: Restauration — l'instantane de l'incarnation precedente
          ansible.builtin.command:
            argv: >-
              {{ ['/usr/local/sbin/setops-restaurer', 'choisir']
                 + (['--instantane', client_backup_restauration_instantane]
                    if client_backup_restauration_instantane | length > 0 else []) }}
          register: client_backup_choix
          changed_when: false

        - name: Restauration — retenir le choix
          ansible.builtin.set_fact:
            client_backup_restauration: >-
              {{ client_backup_restauration | combine({
                   'etat': ('a_restaurer' if (client_backup_choix.stdout | from_json).instantane else 'neuf'),
                   'instantane': (client_backup_choix.stdout | from_json).instantane}) }}

        - name: "Restauration — rien d'anterieur, naissance"
          ansible.builtin.include_tasks: acter.yml
          vars:
            client_backup_acter_etat: neuf
          when: client_backup_restauration.etat == 'neuf'

- name: Restauration — verdict
  ansible.builtin.debug:
    msg: >-
      {{ client_backup_restauration.jeu }} : {{ client_backup_restauration.etat }}{{
         (' — instantane ' + client_backup_restauration.instantane)
         if client_backup_restauration.instantane | length > 0 else '' }}