---
# Main tasks for linode_inventory role

- name: Set API token (AWX credential injection takes precedence)
  ansible.builtin.set_fact:
    linode_api_token: "{{ linode_api_token | default(lookup('env', 'LINODE_API_TOKEN')) | default('') }}"

- name: Validate required variables
  ansible.builtin.assert:
    that:
      - linode_api_token is defined
      - linode_api_token | length > 0
    fail_msg: |
      Linode API token not found. 
      For AWX: Attach a Linode API Token credential to your job template
      For local: Set LINODE_API_TOKEN environment variable or pass linode_api_token variable
    quiet: true

- name: Ensure output directory exists
  ansible.builtin.file:
    path: "{{ linode_inventory_output_dir }}"
    state: directory
    mode: '0755'
  delegate_to: localhost

- name: Copy Linode inventory script
  ansible.builtin.copy:
    src: linode_inventory.py
    dest: "{{ linode_inventory_output_dir }}/linode_inventory.py"
    mode: '0755'
  delegate_to: localhost

- name: Execute Linode inventory script
  ansible.builtin.command:
    cmd: python3 {{ linode_inventory_output_dir }}/linode_inventory.py --list
  environment:
    LINODE_API_TOKEN: "{{ linode_api_token }}"
  register: linode_inventory_result
  delegate_to: localhost
  changed_when: true

- name: Show script execution details
  ansible.builtin.debug:
    msg: |
      Script execution results:
      Return code: {{ linode_inventory_result.rc }}
      Stdout length: {{ linode_inventory_result.stdout | length }}
      Stderr length: {{ linode_inventory_result.stderr | length }}
      
- name: Show stderr if present
  ansible.builtin.debug:
    msg: "Script stderr: {{ linode_inventory_result.stderr }}"
  when: linode_inventory_result.stderr | length > 0

- name: Show stdout if present
  ansible.builtin.debug:
    msg: "Script stdout: {{ linode_inventory_result.stdout }}"
  when: linode_inventory_result.stdout | length > 0

- name: Test API token directly
  ansible.builtin.uri:
    url: "https://api.linode.com/v4/linode/instances"
    method: GET
    headers:
      Authorization: "Bearer {{ linode_api_token }}"
      Content-Type: "application/json"
    return_content: yes
    status_code: [200, 401, 403]
  register: direct_api_test
  delegate_to: localhost

- name: Display direct API test results
  ansible.builtin.debug:
    msg: |
      Direct API test results:
      Status: {{ direct_api_test.status }}
      Response: {{ direct_api_test.json | default('No JSON response') }}
      
- name: Parse inventory JSON (only if stdout exists)
  ansible.builtin.set_fact:
    linode_inventory_data: "{{ linode_inventory_result.stdout | from_json }}"
  when: 
    - linode_inventory_result.stdout | length > 0
    - linode_inventory_result.rc == 0

- name: Set empty inventory if script failed
  ansible.builtin.set_fact:
    linode_inventory_data:
      _meta:
        hostvars: {}
      all:
        children: ['ungrouped']
      ungrouped:
        hosts: []
  when: linode_inventory_data is not defined

- name: Save inventory to file
  ansible.builtin.copy:
    content: "{{ linode_inventory_data | to_nice_json }}"
    dest: "{{ temp_inventory_path }}"
    mode: '0644'
  delegate_to: localhost

- name: Display inventory summary
  ansible.builtin.debug:
    msg: |
      Linode Dynamic Inventory Summary:
      Total hosts discovered: {{ linode_inventory_data._meta.hostvars | length }}
      Groups created: {{ linode_inventory_data.keys() | reject('equalto', '_meta') | list | length }}
      Inventory saved to: {{ temp_inventory_path }}
      API Token status: {{ 'Set (' + (linode_api_token[:8] + '...' if linode_api_token | length > 8 else linode_api_token) + ')' if linode_api_token is defined else 'NOT SET' }}

- name: Show raw script output for debugging
  ansible.builtin.debug:
    var: linode_inventory_result.stdout
  when: linode_inventory_result.stdout | length > 0

- name: Show discovered hosts
  ansible.builtin.debug:
    msg: "Host: {{ item.key }} ({{ item.value.ansible_host }}) - Region: {{ item.value.linode_region }} - Status: {{ item.value.linode_status }}"
  loop: "{{ linode_inventory_data._meta.hostvars | dict2items }}"
  loop_control:
    label: "{{ item.key }}"
  when: linode_inventory_data._meta.hostvars | length > 0

- name: Create inventory directory in project
  ansible.builtin.file:
    path: "/runner/project/inventory"
    state: directory
    mode: '0755'
  delegate_to: localhost

- name: Create JSON inventory file in project
  ansible.builtin.copy:
    content: "{{ linode_inventory_data | to_nice_json }}"
    dest: "/runner/project/inventory/linode_hosts.json"
    mode: '0644'
  delegate_to: localhost
  when: linode_inventory_data is defined

- name: Debug current directory and Git status
  ansible.builtin.shell: |
    echo "Current directory: $(pwd)" &&
    echo "Directory contents:" &&
    ls -la &&
    echo "Git status:" &&
    git status 2>&1 || echo "Not a git repository" &&
    echo "Git remote:" &&
    git remote -v 2>&1 || echo "No git remotes"
  register: debug_git_info
  delegate_to: localhost
  ignore_errors: true

- name: Display debug information
  ansible.builtin.debug:
    msg: |
      Debug Git Information:
      {{ debug_git_info.stdout }}
      
      Git Config Result:
      {{ git_config_result.stdout if git_config_result is defined else 'Not available' }}
      
      Git Commit Result:
      {{ git_commit_result.stdout if git_commit_result is defined else 'Not available' }}

- name: Check if inventory file was created
  ansible.builtin.stat:
    path: "inventory/linode_hosts.json"
  register: inventory_file_check
  delegate_to: localhost

- name: Display inventory file status
  ansible.builtin.debug:
    msg: |
      Inventory file status:
      - Path: inventory/linode_hosts.json
      - Exists: {{ inventory_file_check.stat.exists }}
      - Size: {{ inventory_file_check.stat.size | default(0) }} bytes
      - Location: {{ ansible_env.PWD | default('unknown') }}/inventory/linode_hosts.json

- name: Show current Git status and try manual push
  ansible.builtin.shell: |
    echo "=== Current working directory ==="
    pwd
    echo "=== Git status ==="
    git status
    echo "=== Git log (last commit) ==="
    git log --oneline -1
    echo "=== Attempting to push ==="
    git push origin HEAD 2>&1 || echo "Push failed - check SSH access"
  register: manual_git_push
  delegate_to: localhost
  ignore_errors: true
  when: inventory_file_check.stat.exists

- name: Display Git push results
  ansible.builtin.debug:
    msg: |
      Manual Git Push Results:
      {{ manual_git_push.stdout }}
      
      Error (if any):
      {{ manual_git_push.stderr | default('No errors') }}
  when: manual_git_push is defined

- name: Initialize Git if needed and configure
  ansible.builtin.shell: |
    if [ ! -d ".git" ]; then
      echo "Not in a git repository, checking for git in parent directories"
      git_root=$(git rev-parse --show-toplevel 2>/dev/null || echo "")
      if [ -n "$git_root" ]; then
        cd "$git_root"
        echo "Found git repository at: $git_root"
      else
        echo "No git repository found"
        exit 0
      fi
    fi &&
    git config user.email "awx@ewnix.net" &&
    git config user.name "AWX Automation" &&
    git remote set-url origin git@git.ewnix.net:phlux/ewnix-automation.git &&
    echo "Git configured successfully"
  register: git_config_result
  delegate_to: localhost
  ignore_errors: true

- name: Skip SSH test for now and proceed
  ansible.builtin.debug:
    msg: "Skipping SSH test to avoid hanging - will attempt Git operations directly"

- name: Create inventory directory
  ansible.builtin.file:
    path: "inventory"
    state: directory
    mode: '0755'
  delegate_to: localhost

- name: Create JSON inventory file
  ansible.builtin.copy:
    content: "{{ linode_inventory_data | to_nice_json }}"
    dest: "inventory/linode_hosts.json"
    mode: '0644'
  delegate_to: localhost
  when: linode_inventory_data is defined

- name: Attempt to commit inventory (simplified)
  ansible.builtin.shell: |
    git_root=$(git rev-parse --show-toplevel 2>/dev/null || echo "")
    if [ -n "$git_root" ]; then
      cd "$git_root" &&
      git add inventory/linode_hosts.json &&
      if git diff --staged --quiet; then
        echo "No changes to commit"
      else
        git commit -m "Update Linode inventory - $(date '+%Y-%m-%d %H:%M:%S') [AWX]" &&
        echo "Inventory committed locally (push skipped for now)"
      fi
    else
      echo "No git repository found - inventory file created but not committed"
    fi
  register: git_commit_result
  delegate_to: localhost
  ignore_errors: true
  when: 
    - linode_inventory_data is defined
    - push_to_git | default(true)

- name: Display Git operation result
  ansible.builtin.debug:
    msg: |
      Git operation result:
      Return code: {{ git_commit_result.rc }}
      Output: {{ git_commit_result.stdout }}
      Error: {{ git_commit_result.stderr | default('None') }}
  when: git_commit_result is defined

- name: Trigger AWX project sync (if AWX API available)
  ansible.builtin.uri:
    url: "{{ awx_host | default('https://localhost') }}/api/v2/projects/{{ awx_project_id }}/update/"
    method: POST
    headers:
      Authorization: "Bearer {{ awx_token }}"
      Content-Type: "application/json"
    body_format: json
    body: {}
    status_code: [200, 201, 202]
    validate_certs: false
  register: project_sync_result
  delegate_to: localhost
  ignore_errors: true
  when: 
    - awx_api_integration | default(false)
    - awx_token is defined
    - awx_project_id is defined

- name: Display project sync result
  ansible.builtin.debug:
    msg: |
      AWX Project sync triggered:
      Status: {{ project_sync_result.status | default('Not attempted') }}
      Response: {{ project_sync_result.json | default('No response') }}
  when: project_sync_result is defined

- name: Clean up temporary script
  ansible.builtin.file:
    path: "{{ linode_inventory_output_dir }}/linode_inventory.py"
    state: absent
  delegate_to: localhost
  when: cleanup_temp_files | default(true)