---
# Tâches principales pour le déploiement de Forgejo

- name: Installer les dépendances système
  apt:
    name:
      - git
      - wget
      - curl
      - sqlite3
      - build-essential
      - tar
      - acl
      - ca-certificates
      - gnupg
      - rsync
    state: present
    update_cache: yes
  tags: [install, dependencies]

- name: Créer le répertoire pour les clés APT
  file:
    path: /usr/share/keyrings
    state: directory
    mode: '0755'
  tags: [install, dependencies]

- name: Télécharger la clé GPG NodeSource
  get_url:
    url: https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key
    dest: /tmp/nodesource.gpg.key
    mode: '0644'
  tags: [install, dependencies]

- name: Déarmer la clé GPG et l'installer
  shell: |
    cat /tmp/nodesource.gpg.key | gpg --dearmor -o /usr/share/keyrings/nodesource.gpg
    chmod 644 /usr/share/keyrings/nodesource.gpg
  args:
    creates: /usr/share/keyrings/nodesource.gpg
  tags: [install, dependencies]

- name: Ajouter le dépôt NodeSource pour Node.js 20.x
  apt_repository:
    repo: "deb [signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main"
    state: present
    filename: nodesource
  tags: [install, dependencies]

- name: Installer Node.js
  apt:
    name: nodejs
    state: present
    update_cache: yes
  tags: [install, dependencies]

- name: Vérifier l'installation de Node.js et npm
  shell: |
    echo "Node: $(node --version)"
    echo "npm: $(npm --version)"
  register: node_npm_version
  changed_when: false
  tags: [install, dependencies]

- name: Afficher les versions Node.js et npm
  debug:
    msg: "{{ node_npm_version.stdout_lines }}"
  tags: [install, dependencies]

- name: Vérifier si Go est installé et sa version
  shell: |
    if command -v go &> /dev/null; then
      version=$(go version | awk '{print $3}' | sed 's/go//')
      if [ ! -z "$version" ]; then
        # Extraire la version majeure.mineure
        major_minor=$(echo $version | cut -d. -f1,2)
        # Vérifier si >= 1.21
        if awk "BEGIN {exit !($major_minor >= 1.21)}"; then
          echo "ok"
        else
          echo "old"
        fi
      else
        echo "none"
      fi
    else
      echo "none"
    fi
  register: go_status
  changed_when: false
  tags: [install, build]

- name: Définir la version de Go requise
  set_fact:
    go_required_version: "1.22.2"
  tags: [install, build]

- name: Afficher le statut de Go
  debug:
    msg: "Statut Go : {{ go_status.stdout }}"
  tags: [install, build]

- name: Installer ou mettre à jour Go
  block:
    - name: Supprimer l'ancienne installation de Go
      file:
        path: /usr/local/go
        state: absent
      
    - name: Télécharger Go {{ go_required_version }}
      get_url:
        url: "https://go.dev/dl/go{{ go_required_version }}.linux-amd64.tar.gz"
        dest: "/tmp/go{{ go_required_version }}.linux-amd64.tar.gz"
        mode: '0644'
    
    - name: Extraire Go
      unarchive:
        src: "/tmp/go{{ go_required_version }}.linux-amd64.tar.gz"
        dest: /usr/local
        remote_src: yes
    
    - name: Nettoyer le tarball
      file:
        path: "/tmp/go{{ go_required_version }}.linux-amd64.tar.gz"
        state: absent
    
    - name: Configurer le PATH pour Go
      copy:
        content: |
          export PATH=$PATH:/usr/local/go/bin
          export GOPATH=$HOME/go
          export PATH=$PATH:$GOPATH/bin
        dest: /etc/profile.d/go.sh
        mode: '0755'
  
  when: go_status.stdout != "ok"
  tags: [install, build]

- name: Vérifier l'installation de Go
  command: /usr/local/go/bin/go version
  register: go_final_version
  changed_when: false
  tags: [install, build]

- name: Afficher la version de Go installée
  debug:
    msg: "✓ Go installé: {{ go_final_version.stdout }}"
  tags: [install, build]

- name: Créer le groupe système pour Forgejo
  group:
    name: "{{ forgejo_group }}"
    system: yes
    state: present
  tags: [install]

- name: Créer l'utilisateur système pour Forgejo
  user:
    name: "{{ forgejo_user }}"
    group: "{{ forgejo_group }}"
    system: yes
    home: "{{ forgejo_home }}"
    shell: /bin/bash
    create_home: yes
    state: present
  tags: [install]

- name: Créer les répertoires nécessaires
  file:
    path: "{{ item }}"
    state: directory
    owner: "{{ forgejo_user }}"
    group: "{{ forgejo_group }}"
    mode: '0755'
  loop:
    - "{{ forgejo_home }}"
    - "{{ forgejo_data_dir }}"
    - "{{ forgejo_custom_dir }}"
    - "{{ forgejo_custom_dir }}/conf"
    - "{{ forgejo_log_dir }}"
    - "{{ forgejo_data_dir }}/repositories"
    - "{{ forgejo_data_dir }}/actions"
  tags: [install]

- name: Supprimer le répertoire source existant (si présent)
  file:
    path: "{{ forgejo_home }}/src"
    state: absent
  when: ansible_check_mode == false
  tags: [install, build]

- name: Cloner le dépôt Forgejo depuis les sources
  git:
    repo: 'https://codeberg.org/forgejo/forgejo.git'
    dest: "{{ forgejo_home }}/src"
    version: "v{{ forgejo_version }}"
    force: yes
  tags: [install, build]

- name: Changer le propriétaire du code source
  file:
    path: "{{ forgejo_home }}/src"
    owner: "{{ forgejo_user }}"
    group: "{{ forgejo_group }}"
    recurse: yes
  tags: [install, build]

- name: Configurer Git safe.directory pour l'utilisateur git
  become_user: "{{ forgejo_user }}"
  command: git config --global --add safe.directory {{ forgejo_home }}/src
  args:
    creates: /home/{{ forgejo_user }}/.gitconfig
  tags: [install, build]

- name: Vérifier que Node.js est accessible
  command: which node
  register: node_path
  failed_when: node_path.rc != 0
  changed_when: false
  tags: [install, build]

- name: Vérifier que npm est accessible
  command: which npm
  register: npm_path
  failed_when: npm_path.rc != 0
  changed_when: false
  tags: [install, build]

- name: Afficher les chemins Node.js et npm
  debug:
    msg: 
      - "Node.js: {{ node_path.stdout }}"
      - "npm: {{ npm_path.stdout }}"
  tags: [install, build]

- name: Compiler Forgejo depuis les sources
  shell: |
    cd {{ forgejo_home }}/src
    export PATH=/usr/local/go/bin:/usr/bin:$PATH
    export NODE_PATH=/usr/lib/node_modules
    TAGS="bindata sqlite sqlite_unlock_notify" make build
  become_user: "{{ forgejo_user }}"
  environment:
    GOPATH: "{{ forgejo_home }}/go"
    PATH: "/usr/local/go/bin:/usr/bin:{{ ansible_env.PATH }}"
    NODE_PATH: "/usr/lib/node_modules"
  tags: [install, build]

- name: Vérifier quel binaire a été créé
  find:
    paths: "{{ forgejo_home }}/src"
    patterns: 
      - "forgejo"
      - "gitea"
    file_type: file
  register: binary_files
  tags: [install, build]

- name: Afficher les binaires trouvés
  debug:
    msg: "Binaires trouvés: {{ binary_files.files | map(attribute='path') | list }}"
  tags: [install, build]

- name: Déterminer le nom du binaire
  set_fact:
    source_binary: "{{ binary_files.files[0].path if binary_files.files | length > 0 else '' }}"
  tags: [install, build]

- name: Échouer si aucun binaire trouvé
  fail:
    msg: "Aucun binaire Forgejo/Gitea trouvé dans {{ forgejo_home }}/src"
  when: source_binary == ""
  tags: [install, build]

- name: Copier le binaire Forgejo
  copy:
    src: "{{ source_binary }}"
    dest: "{{ forgejo_home }}/forgejo"
    remote_src: yes
    owner: "{{ forgejo_user }}"
    group: "{{ forgejo_group }}"
    mode: '0755'
  tags: [install, build]

- name: Créer le fichier de configuration app.ini
  template:
    src: app.ini.j2
    dest: "{{ forgejo_custom_dir }}/conf/app.ini"
    owner: "{{ forgejo_user }}"
    group: "{{ forgejo_group }}"
    mode: '0640'
  notify: restart forgejo
  tags: [config]

- name: Créer le service systemd
  template:
    src: forgejo.service.j2
    dest: /etc/systemd/system/forgejo.service
    mode: '0644'
  notify: 
    - reload systemd
    - restart forgejo
  tags: [install, service]

- name: Activer et démarrer le service Forgejo
  systemd:
    name: forgejo
    enabled: yes
    state: started
    daemon_reload: yes
  tags: [install, service]

- name: Attendre que Forgejo soit prêt
  wait_for:
    port: "{{ forgejo_port }}"
    timeout: 60
  tags: [install]

- name: Configurer Forgejo Actions (CI/CD)
  include_tasks: actions.yml
  when: forgejo_enable_actions | bool
  tags: [ci, actions]

- name: Créer un runner Forgejo pour CI/CD
  include_tasks: runner.yml
  when: forgejo_enable_actions | bool
  tags: [ci, runner]