---
# ---
# Check if local template directories exists
# ---

# default_users
- name: (users-systemfiles.yml) Check if local template directory exists for default users
  ansible.builtin.stat: path={{ inventory_dir }}/files/homedirs/{{ item.name }}
  delegate_to: localhost
  with_items: "{{ default_user }}"
  loop_control:
    label: "{{ item.name }}"
  register: local_template_dir_default_user

# root
- name: (users-systemfiles.yml) Check if local template directory exists for root
  ansible.builtin.stat: path={{ inventory_dir }}/files/homedirs/root
  delegate_to: localhost
  register: local_template_dir_root

# --
# Copy .bashrc
# ---

- name: (users-systemfiles.yml) Check if users file '.bashrc.ORIG' exists
  ansible.builtin.stat:
    path: "~{{ item.name }}/.bashrc.ORIG"
  register: bashrc_user_orig_exists
  loop: "{{ default_user }}"
  loop_control:
    label: "{{ item.name }}"
  tags:
    - bash

- name: (users-systemfiles.yml) Backup existing users .bashrc file
  ansible.builtin.command: cp -a ~{{ item.item.name }}/.bashrc ~{{ item.item.name }}/.bashrc.ORIG
  loop: "{{ bashrc_user_orig_exists.results }}"
  loop_control:
    label: "{{ item.item.name }}"
  when: item.stat.exists == False
  tags:
    - bash

# 1. Prüfen, ob für jeden User ein lokales _bashrc existiert
- name: (users-systemfiles.yml) stat user _bashrc
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/{{ item.name }}/_bashrc"
  delegate_to: localhost
  become: false
  loop: "{{ default_user }}"
  register: bashrc_stats
  loop_control:
    label: "{{ item.name }}"

# 2. Falls vorhanden, Datei kopieren
- name: (users-systemfiles.yml) copy .bashrc if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/{{ user.name }}/_bashrc"
    dest: "~{{ user.name }}/.bashrc"
    owner: "{{ user.name }}"
    group: "{{ user.name }}"
    mode: "0644"
  loop: "{{ default_user | zip(bashrc_stats.results) | list }}"
  loop_control:
    label: "{{ user.name }}"
  when:
    - stat_result.stat.exists
  vars:
    user: "{{ item.0 }}"
    stat_result: "{{ item.1 }}"
  tags:
    - bash

# --
# -- root user
# --

- name: (users-systemfiles.yml) Check if file '/root/.bashrc.ORIG' exists
  ansible.builtin.stat:
    path: /root/.bashrc.ORIG
  register: bashrc_root_orig_exists
  tags:
    - bash

- name: (users-systemfiles.yml) Backup /root/.bashrc file
  ansible.builtin.command: cp /root/.bashrc /root/.bashrc.ORIG
  when: bashrc_root_orig_exists.stat.exists == False
  tags:
    - bash

# 1) Prüfen ob die _bashrc für root auf dem Control-Node existiert
- name: Stat root _bashrc on control node
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/root/_bashrc"
  delegate_to: localhost
  become: false
  register: bashrc_root_stat

# 2) Wenn vorhanden, kopieren wir sie nach /root/.bashrc auf dem Zielhost
- name: Copy root .bashrc if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/root/_bashrc"
    dest: /root/.bashrc
    owner: root
    group: root
    mode: "0644"
  become: true
  when: bashrc_root_stat.stat.exists
  tags:
    - bash

# --
# Copy .profile (Debian System)
# ---

- name: (users-systemfiles.yml) Check if users file '.profile.ORIG' exists
  ansible.builtin.stat:
    path: "~{{ item.name }}/.profile.ORIG"
  register: profile_user_orig_exists
  loop: "{{ default_user }}"
  loop_control:
    label: "{{ item.name }}"
  when:
    - ansible_facts['distribution'] == "Debian"
  tags:
    - profile

- name: (users-systemfiles.yml) Backup existing users .profile file
  ansible.builtin.command: cp -a ~{{ item.item.name }}/.profile ~{{ item.item.name }}/.profile.ORIG
  loop: "{{ profile_user_orig_exists.results }}"
  loop_control:
    label: "{{ item.item.name }}"
  when:
    - ansible_facts['distribution'] == "Debian"
    - item.stat.exists == False
  tags:
    - profile

# 1. Prüfen, ob für jeden User ein lokales _profile existiert
- name: (users-systemfiles.yml) stat user _profile
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/{{ item.name }}/_profile"
  delegate_to: localhost
  become: false
  loop: "{{ default_user }}"
  register: profile_stats
  loop_control:
    label: "{{ item.name }}"

# 2. Falls vorhanden, Datei kopieren
- name: (users-systemfiles.yml) copy .profile if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/{{ user.name }}/_profile"
    dest: "~{{ user.name }}/.profile"
    owner: "{{ user.name }}"
    group: "{{ user.name }}"
    mode: "0644"
  loop: "{{ default_user | zip(profile_stats.results) | list }}"
  loop_control:
    label: "{{ user.name }}"
  when:
    - stat_result.stat.exists
  vars:
    user: "{{ item.0 }}"
    stat_result: "{{ item.1 }}"
  tags:
    - bash

# --
# -- root user
# --

- name: (users-systemfiles.yml) Check if file '/root/.profile.ORIG' exists
  ansible.builtin.stat:
    path: /root/.profile.ORIG
  register: profile_root_orig_exists
  when:
    - ansible_facts['distribution'] == "Debian"
  tags:
    - profile

- name: (users-systemfiles.yml) Backup existing users .profile file
  ansible.builtin.command: cp -a /root/.profile /root/.profile.ORIG
  when:
    - ansible_facts['distribution'] == "Debian"
    - profile_root_orig_exists.stat.exists == False
  tags:
    - profile

# 1) Prüfen ob die _profile für root auf dem Control-Node existiert
- name: Stat root _profile on control node
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/root/_profile"
  delegate_to: localhost
  become: false
  register: profile_root_stat

# 2) Wenn vorhanden, kopieren wir sie nach /root/.profile auf dem Zielhost
- name: Copy root .profile if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/root/_profile"
    dest: /root/.profile
    owner: root
    group: root
    mode: "0644"
  become: true
  when: profile_root_stat.stat.exists
  tags:
    - bash

# --
# Copy .bash_profile (CentOS/Fedora?/RedHat? System)
# ---

- name: (users-systemfiles.yml) Check if users file '.bash_profile.ORIG' exists
  ansible.builtin.stat:
    path: "~{{ item.name }}/.bash_profile.ORIG"
  register: bash_profile_user_orig_exists
  loop: "{{ default_user }}"
  loop_control:
    label: "{{ item.name }}"
  when:
    - ansible_facts['distribution'] == "CentOS"
  tags:
    - profile

- name: (users-systemfiles.yml) Backup existing users .bash_profile file
  ansible.builtin.command: cp -a ~{{ item.item.name }}/.bash_profile ~{{ item.item.name }}/.bash_profile.ORIG
  loop: "{{ bash_profile_user_orig_exists.results }}"
  loop_control:
    label: "{{ item.item.name }}"
  when:
    - ansible_facts['distribution'] == "CentOS"
    - item.stat.exists == False
  tags:
    - profile

# 1. Prüfen, ob für jeden User ein lokales _bash_profile existiert
- name: (users-systemfiles.yml) stat user _bash_profile
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/{{ item.name }}/_bash_profile"
  delegate_to: localhost
  become: false
  loop: "{{ default_user }}"
  register: bash_profile_stats
  loop_control:
    label: "{{ item.name }}"
  when:
    - ansible_facts['distribution'] == "CentOS"

# 2. Falls vorhanden, Datei kopieren
- name: (users-systemfiles.yml) copy .bash_profile if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/{{ user.name }}/_bash_profile"
    dest: "~{{ user.name }}/.bash_profile"
    owner: "{{ user.name }}"
    group: "{{ user.name }}"
    mode: "0644"
  loop: "{{ default_user | zip(bash_profile_stats.results) | list }}"
  loop_control:
    label: "{{ user.name }}"
  when:
    - ansible_facts['distribution'] == "CentOS"
    - stat_result.stat.exists
  vars:
    user: "{{ item.0 }}"
    stat_result: "{{ item.1 }}"
  tags:
    - bash

# --
# -- root user
# --

- name: (users-systemfiles.yml) Check if file '/root/.bash_profile.ORIG' exists
  ansible.builtin.stat:
    path: /root/.bash_profile.ORIG
  register: profile_root_orig_exists
  when:
    - ansible_facts['distribution'] == "CentOS"
  tags:
    - profile

- name: (users-systemfiles.yml) Backup existing users .bash_profile file
  ansible.builtin.command: cp -a /root/.bash_profile /root/.bash_profile.ORIG
  when:
    - ansible_facts['distribution'] == "CentOS"
    - profile_root_orig_exists.stat.exists == False
  tags:
    - profile

# 1) Prüfen ob die _bash_profile für root auf dem Control-Node existiert
- name: Stat root _bash_profile on control node
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/root/_bash_profile"
  delegate_to: localhost
  become: false
  register: bash_profile_root_stat
  when:
    - ansible_facts['distribution'] == "CentOS"

# 2) Wenn vorhanden, kopieren wir sie nach /root/.bash_profile auf dem Zielhost
- name: Copy root .bash_profile if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/root/_bash_profile"
    dest: /root/.bash_profile
    owner: root
    group: root
    mode: "0644"
  become: true
  when:
    - ansible_facts['distribution'] == "CentOS"
    - bash_profile_root_stat.stat.exists
  tags:
    - bash

# --
# Copy .vimrc
# ---

# 1. Prüfen, ob für jeden User ein lokales _vimrc existiert
- name: (users-systemfiles.yml) stat user _vimrc
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/{{ item.name }}/_vimrc"
  delegate_to: localhost
  become: false
  loop: "{{ default_user }}"
  register: vimrc_stats
  loop_control:
    label: "{{ item.name }}"

# 2. Falls vorhanden, Datei kopieren
- name: (users-systemfiles.yml) copy .vimrc if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/{{ user.name }}/_vimrc"
    dest: "~{{ user.name }}/.vimrc"
    owner: "{{ user.name }}"
    group: "{{ user.name }}"
    mode: "0644"
  loop: "{{ default_user | zip(vimrc_stats.results) | list }}"
  loop_control:
    label: "{{ user.name }}"
  when:
    - stat_result.stat.exists
  vars:
    user: "{{ item.0 }}"
    stat_result: "{{ item.1 }}"
  tags:
    - bash

# 1) Lokal prüfen, ob ~/.vim existiert
- name: (users-systemfiles.yml) stat local .vim for each user
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/{{ item.name }}/.vim"
  delegate_to: localhost
  become: false
  loop: "{{ default_user }}"
  register: dotvim_stats
  loop_control:
    label: "{{ item.name }}"

# 2) Wenn vorhanden, .vim-Verzeichnis ins Home des Users kopieren
- name: (users-systemfiles.yml) copy .vim directory if it exists
  ansible.builtin.copy:
    # Wichtig: KEINE verschachtelten {{ ... }} im String
    src: "{{ inventory_dir }}/files/homedirs/{{ user.name }}/.vim"
    dest: "~{{ user.name }}/"
    mode: preserve # oder weglassen; 0644 wäre für Verzeichnisse falsch
  become: true
  loop: "{{ default_user | zip(dotvim_stats.results) | list }}"
  loop_control:
    label: "{{ user.name }}"
  when:
    - stat_result.stat.exists | bool
  vars:
    user: "{{ item.0 }}"
    stat_result: "{{ item.1 }}"
  tags: [vim]


# 3) Ownership/Gruppe rekursiv korrigieren (falls gewünscht/erforderlich)
- name: (users-systemfiles.yml) ensure ownership on ~/.vim recursively
  ansible.builtin.file:
    path: "~{{ user.name }}/.vim"
    owner: "{{ user.name }}"
    group: "{{ user.name }}"
    recurse: true
    state: directory
  become: true
  loop: "{{ default_user | zip(dotvim_stats.results) | list }}"
  loop_control:
    label: "{{ user.name }}"
  when:
    - stat_result.stat.exists | bool
  vars:
    user: "{{ item.0 }}"
    stat_result: "{{ item.1 }}"
  tags: [vim]

# --
# -- root user
# --

# 1) Prüfen ob die _vimrc für root auf dem Control-Node existiert
- name: Stat root _vimrc on control node
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/root/_vimrc"
  delegate_to: localhost
  become: false
  register: vimrc_root_stat

# 2) Wenn vorhanden, kopieren wir sie nach /root/.vimrc auf dem Zielhost
- name: Copy root .vimrc if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/root/_vimrc"
    dest: /root/.vimrc
    owner: root
    group: root
    mode: "0644"
  become: true
  when:
    - vimrc_root_stat.stat.exists
  tags:
    - bash

# 1) Lokal prüfen, ob ./files/homedirs/root/.vim existiert
- name: (users-systemfiles.yml) stat local .vim for root
  ansible.builtin.stat:
    path: "{{ inventory_dir }}/files/homedirs/root/.vim"
  delegate_to: localhost
  become: false
  register: root_dotvim_stat
  tags: [vim]

# 2) Wenn vorhanden, nach /root/ kopieren
- name: (users-systemfiles.yml) copy root .vim directory if it exists
  ansible.builtin.copy:
    src: "{{ inventory_dir }}/files/homedirs/root/.vim"
    dest: "/root/"
    mode: preserve # oder weglassen; nicht 0644 bei Verzeichnissen
  become: true
  when:
    - root_dotvim_stat.stat.exists | bool
  tags: [vim]

# 3) Ownership sicherstellen (rekursiv)
- name: (users-systemfiles.yml) ensure ownership on /root/.vim recursively
  ansible.builtin.file:
    path: "/root/.vim"
    owner: "root"
    group: "root"
    recurse: true
    state: directory
  become: true
  when:
    - root_dotvim_stat.stat.exists | bool
  tags: [vim]
