#!/bin/bash


# Definindo códigos de cores
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Variaveis globais
ARIUSMONITOR_CONFIG_FILE="/ariusmonitor/conf/zabbix_agentd.conf"
ARIUSMONITOR_CONFIG_PIDFILE="/ariusmonitor/logs/zabbix_agentd.pid"
ARIUSMONITOR_CONFIG_LOGFILE="/ariusmonitor/logs/zabbix_agentd.log"
ARIUSMONITOR_CONFIG_AGENTD_PATH="/ariusmonitor/conf/zabbix_agentd.conf.d/"
ARIUSMONITOR_CONFIG_INCLUDE="$ARIUSMONITOR_CONFIG_AGENTD_PATH*"
ARIUSMONTIOR_BOT_DIR="/ariusmonitor"


#Parametros shellscript
PARAM_PDV_IP=""
PARAM_SCRIPTS_PATH=""
PARAM_PDV=""
PARAM_AGENT_STATUS=""
PARAM_UPDATE_SAT="false"
PARAM_SAT_ASSOCIAR_ASSINATURA="false"
PARAM_CNPJ_CONTRIBUINTE=""
PARAM_CHAVE_ASSINATURA=""
PARAM_UPDATE_ARIUSMONITOR="false"
PARAM_UPDATE_ARIUSMONITOR_PARAM="false"
PARAM_REMOVE_MONITORASAT="false"
PARAM_FORCE_MONITORASAT="false"
PARAM_IGNORE_CONFIG_ARIUSMONITOR="false"
PARAM_INSTALL_FPING="false"
PARAM_MOVE_LOGS="false"
PARAM_DEBBUG="false"
PARAM_BACKUP_CUPOM="false"
PARAM_SHUTDOWN="false"
PARAM_UNLOCK="false"

# Carregue as variáveis do arquivo de configuração
source $ARIUSMONTIOR_BOT_DIR/config_bot.conf


# Analisando os parâmetros
TEMP=$(getopt -o h --long help,rede:,loja:,pdv:,pdv-ip:,agent-status:,cnpj-contribuinte:,chave-assinatura:,update-ariusmonitor,update-ariusmonitor-param,update-sat,remove-monitorasat,force-monitorasat,sat-associar-assinatura,ignore-config-ariusmonitor,install-fping,move-logs,debbug,shutdown,backup-cupom,unlock -- "$@")
eval set -- "$TEMP"

while true; do
  case $1 in
    --pdv-ip)
      PARAM_PDV_IP="$2"
      shift 2
      ;;
    --rede)
      PARAM_REDE="$2"
      shift 2
      ;;
    --loja)
      PARAM_LOJA="$2"
      shift 2
      ;;    
    --agent-status)
      PARAM_AGENT_STATUS="$2"
      shift 2
      ;;
    --pdv)
      PARAM_PDV="$2"
      shift 2
      ;;
    --ignore-config-ariusmonitor)
      PARAM_IGNORE_CONFIG_ARIUSMONITOR="true"
      shift
      ;;
    --remove-monitorasat)
      PARAM_REMOVE_MONITORASAT="true"
      shift
      ;;
    --force-monitorasat)
      PARAM_FORCE_MONITORASAT="true"
      shift
      ;;   
    --update-ariusmonitor)
      PARAM_UPDATE_ARIUSMONITOR="true"
      shift
      ;;
    --update-ariusmonitor-param)
      PARAM_UPDATE_ARIUSMONITOR_PARAM="true"
      shift
      ;;
    --update-sat)
      PARAM_UPDATE_SAT="true"
      shift
      ;;
    --sat-associar-assinatura)
      PARAM_SAT_ASSOCIAR_ASSINATURA="true"
      shift
      ;;
    --cnpj-contribuinte)
      PARAM_CNPJ_CONTRIBUINTE="$2"
      shift 2
      ;;
    --chave-assinatura)
      PARAM_CHAVE_ASSINATURA="$2"
      shift 2
      ;;
    --install-fping)
      PARAM_INSTALL_FPING="true"
      shift
      ;;
    --move-logs)
      PARAM_MOVE_LOGS="true"
      shift
      ;;
    --debbug)
      PARAM_DEBBUG="true"
      shift
      ;;
    --shutdown)
      PARAM_SHUTDOWN="true"
      shift
      ;;
    --backup-cupom)
      PARAM_BACKUP_CUPOM="true"
      shift
      ;;
    --unlock)
      PARAM_UNLOCK="true"
      shift
      ;;
    --help)
      echo -e "$GREE Todos os Direitos Reservados a Flagee.Cloud $NC"
      echo ""
      echo -e "$BLUE PDV - ATUALIZAR MONITORAMENTO $NC"
      echo " Atualizar todas as Lojas:                 ./bot_ariusmonitor"
      echo " Atualizar Loja:                           ./bot_ariusmonitor --loja <LOJA001>"
      echo " Atualizar PDV por Nome:                   ./bot_ariusmonitor --loja <LOJA001> --pdv <PDV201>"
      echo " Atualizar PDV por IP:                     ./bot_ariusmonitor --pdv-ip <0.0.0.0>"
      echo " Parametros de apoio:                      --move-logs (move os logs em /posnet para /posnet/logs_old)"
      echo " Parametros de apoio:                      --update-ariusmonitor (atualiza o agente do zabbix)"
      echo " Parametros de apoio:                      --agent-status (filtra hosts por status no zabbix: 0 - interface indisponivel, 2 - ok, 2 - falha)"
      echo ""
      echo -e "$BLUE SAT - ATUALIZAR SOFTWARE $NC"
      echo " Atualizar SAT por Loja:                   ./bot_ariusmonitor --loja <LOJA001> --sat-update"
      echo " Atualizar SAT por Nome do PDV:            ./bot_ariusmonitor --loja <LOJA001> --pdv <PDV201> --sat-update"
      echo " Atualizar SAT por IP do PDV:              ./bot_ariusmonitor --pdv-ip <0.0.0.0> --sat-update"
      echo ""
      echo -e "$BLUE SAT - ASSOCIAR ASSINATURA $NC"
      echo " Associar Assinatura por Loja:             ./bot_ariusmonitor --loja <LOJA001> --sat-associar-assinatura --cnpj-contribuinte <CNPJ CONTRIBUINTE> --chave-assinatura \"<CHAVE ASSINATURA>\""
      echo " Associar Assinatura por Nome do PDV:      ./bot_ariusmonitor --loja <LOJA001> --pdv <PDV201> --sat-associar-assinatura --cnpj-contribuinte <CNPJ CONTRIBUINTE> --chave-assinatura \"<CHAVE ASSINATURA>\""
      echo " Associar Assinatura por IP do PDV:        ./bot_ariusmonitor --pdv-ip <0.0.0.0> --sat-associar-assinatura --cnpj-contribuinte <CNPJ CONTRIBUINTE> --chave-assinatura \"<CHAVE ASSINATURA>\""
      echo ""
      echo -e "$YELLOW Importante: o valor do parâmetro --chave-assinatura deve ser entre aspas $NC"
      exit 1
      ;;
    --)
      shift
      break
      ;;
  esac
done

# Define o arquivo de bloqueio
LOCKFILE="/var/run/bot_ariusmonitor.lock"

# Verifica se o arquivo de bloqueio existe
if [ -e "$LOCKFILE" ] && [ $PARAM_UNLOCK == 'false' ]; then
    # O arquivo de bloqueio existe, o que significa que outra instância pode estar em execução
    echo "Outro processo do bot_ariusmonitor está em execução."
    echo "Para matar o processo, remova o arquivo de bloqueio $LOCKFILE ou use 'pkill -f bot_ariusmonitor.sh'"
    exit 1
else
    # Cria o arquivo de bloqueio para indicar que este processo está em execução
    touch "$LOCKFILE"
    # Garante que o arquivo de bloqueio será removido ao sair do script, mesmo após uma interrupção
    trap "rm -f $LOCKFILE" EXIT
fi


echo -e "${BLUE}LOJA: ${PARAM_REDE} - PROXY: ${PARAM_PROXY_IP}${NC}"

# Definir arquivos de log
LOGFILE_GENERAL="/ariusmonitor/logfile_general.log"
LOGFILE_INVALID_CREDENTIALS="/ariusmonitor/logfile_invalid_credentials.log"
LOGFILE_MONITORASAT="/ariusmonitor/logfile_monitorasat.log"
LOGFILE_HTCONFIG_NOTINSTALLED="/ariusmonitor/logfile_htcconfig_notinstalled.log"
LOGFILE_MACHINE_UNRESPONSIVE="/ariusmonitor/logfile_machine_unresponsive.log"


# Função para registrar LOG
log() {
  MESSAGE="$1"
  COLOR="${2:-$NC}"
  LOGFILE="$3"

  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")

  # Escrever mensagem com cor no terminal
  echo -e "${COLOR}${TIMESTAMP} - ${MESSAGE}${NC}"

  # Escrever mensagem no arquivo de log geral
  echo -e "${TIMESTAMP} - ${MESSAGE}" >> "$LOGFILE_GENERAL"

  # Se um arquivo de log específico foi fornecido, escrever a mensagem nele também
  if [ -n "$LOGFILE" ]; then
    echo -e "${TIMESTAMP} - ${MESSAGE}" >> "$LOGFILE"
  fi
}

# Função para capturar o sinal SIGINT (CTRL+C)
interrupt_handler() {
  log "Interrompendo a execução do script..."
  pkill -P $$ # Encerra todos os processos filho do script (incluindo conexões SSH)
  exit 1
}

# Definir o manipulador de interrupção para o sinal SIGINT
trap interrupt_handler SIGINT

# Verifique se o arquivo config_bot.conf existe
if [ ! -f "$ARIUSMONTIOR_BOT_DIR/config_bot.conf" ]; then
  log "Arquivo de configuração '$ARIUSMONTIOR_BOT_DIR/config_bot.conf' não encontrado!" "$RED"
  exit 1
fi



# Verifica o fuso horário atual
CURRENT_TIMEZONE=$(timedatectl show --property=Timezone --value)

# Verifica se o fuso horário atual é America/Sao_Paulo
if [ "$CURRENT_TIMEZONE" != "America/Sao_Paulo" ]; then
    log "Corrigindo fuso horário para America/Sao_Paulo..."
    sudo timedatectl set-timezone America/Sao_Paulo
else
    log "Fuso horário: America/Sao_Paulo."
fi


#### CHECAGEM DE PARÂMETROS PARA FILTRO DA API ZABBIX ####

# Inicializar variáveis para filtro
filtro_host=""
filtro_host_ip=""

# Verifica e constrói o filtro com base nos parâmetros fornecidos
if [ -n "$PARAM_LOJA" ] && [ -n "$PARAM_PDV" ]; then
    # Caso --loja e --pdv sejam fornecidos
    filtro_host="${PARAM_LOJA}-${PARAM_PDV}"

elif [ -n "$PARAM_LOJA" ]; then
    # Caso apenas --loja seja fornecido
    filtro_host="${PARAM_LOJA}"

elif [ -n "$PARAM_PDV_IP" ]; then
    # Caso apenas --pdv-ip seja fornecido
    # Aqui você precisará adaptar a busca para corresponder à lógica específica do seu Zabbix
    # Este exemplo assume que você pode buscar hosts diretamente por um campo que represente o IP
    filtro_host_ip=",\"filter\": {\"ip\": \"$PARAM_PDV_IP\"}"
fi

log "###### Iniciando Bot Arius Monitor para $PARAM_REDE $PARAM_LOJA $PARAM_PDV $PARAM_PDV_IP" "$GREEN"


#### FIM DA CHECAGEM DE PARÂMETROS ####




# Função para verificar a conectividade com a máquina de destino
check_connection() {
  local IP="$1"
  local USER="$2"
  local PASS="$3"

  timeout 5 bash -c "echo >/dev/tcp/$IP/22" >/dev/null 2>&1
  if [ $? -ne 0 ]; then
    return 1 # Máquina não responde
  fi

  # Remove a entrada antiga da chave do host no arquivo known_hosts
  ssh-keygen -R "$IP" >/dev/null 2>&1

  OUTPUT=$(timeout 30 sshpass -p "$PASS" ssh -o ConnectTimeout=5 -o HostKeyAlgorithms=+ssh-dss -o CheckHostIP=no -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR "$USER@$IP" exit >/dev/null 2>&1)
  CONNECTION_STATUS=$?

  if [ $CONNECTION_STATUS -ne 0 ]; then
    return 2 # Credenciais inválidas
  fi

  return 0 # Conexão bem-sucedida
}

# Função para detectar a distribuição e a versão do Linux na máquina de destino
detect_distro_and_version() {
  local IP="$1"
  local USER="$2"
  local PASS="$3"

  # Verifica se o comando lsb_release está disponível
  LSB_RELEASE_EXISTS=$(timeout 30 sshpass -p "$PASS" ssh -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss "$USER@$IP" "which lsb_release 2>&1 | grep -v 'no lsb_release' | wc -l")

  if [ "$LSB_RELEASE_EXISTS" = "1" ]; then
    # Utilize o lsb_release para identificar a distribuição e versão
    DISTRO_INFO=$(timeout 30 sshpass -p "$PASS" ssh -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss "$USER@$IP" "lsb_release -a 2>/dev/null")
  else
    # Tratamento alternativo para Slackware
    DISTRO_INFO=$(timeout 30 sshpass -p "$PASS" ssh -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss "$USER@$IP" "cat /etc/slackware-version 2>/dev/null")
  fi

  DISTRO=""
  VERSION=""

  if echo "$DISTRO_INFO" | grep -qi "Distributor ID:\s*Ubuntu"; then
    DISTRO="Ubuntu"
    VERSION=$(echo "$DISTRO_INFO" | grep -oP 'Release:\s*\K\d+')
  elif echo "$DISTRO_INFO" | grep -qi "Distributor ID:\s*LinuxMint"; then
    DISTRO="Mint"
    VERSION=$(echo "$DISTRO_INFO" | grep -oP 'Release:\s*\K\d+')
  elif echo "$DISTRO_INFO" | grep -qi "Slackware"; then
    DISTRO="Slackware"
    VERSION=$(echo "$DISTRO_INFO" | grep -oP 'Slackware \K\d+')
  else
    echo "unknown"
    return
  fi

  echo "$DISTRO $VERSION"
}



detect_architecture() {
  local IP="$1"
  local USER="$2"
  local PASS="$3"

  ARCHITECTURE=$(timeout 30 sshpass -p "$PASS" ssh -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss "$USER@$IP" "uname -m" 2>/dev/null)

  if [ -n "$ARCHITECTURE" ]; then
    case "$ARCHITECTURE" in
      i?86) ARCHITECTURE="i386" ;;
      x86_64) ARCHITECTURE="amd64" ;;
      *) ARCHITECTURE="unknown" ;;
    esac
  else
    ARCHITECTURE="unknown"
  fi

  echo "$ARCHITECTURE"
}

get_ariusmonitor_geral_config(){
  log "Atualizando arquivo geral.conf"
  wget -N -P "$ARIUSMONTIOR_BOT_DIR" "https://repo.ariusmonitor.flagee.cloud/geral.conf" --no-check-certificate >/dev/null 2>&1
  log "Atualizando arquivo ariusmonitor.tar.gz"
  wget -N -P "$ARIUSMONTIOR_BOT_DIR" "https://repo.ariusmonitor.flagee.cloud/ariusmonitor.tar.gz" --no-check-certificate >/dev/null 2>&1
  log "Atualizando arquivo MonitoraSATc"
  wget -N -P "$ARIUSMONTIOR_BOT_DIR" "https://repo.ariusmonitor.flagee.cloud/MonitoraSATc" --no-check-certificate >/dev/null 2>&1
  log "Atualizando arquivo MonitoraSATc64"
  wget -N -P "$ARIUSMONTIOR_BOT_DIR" "https://repo.ariusmonitor.flagee.cloud/MonitoraSATc64" --no-check-certificate >/dev/null 2>&1
  log "Atualizando arquivo MonitoraSAT.sh"
  wget -N -P "$ARIUSMONTIOR_BOT_DIR" "https://repo.ariusmonitor.flagee.cloud/MonitoraSAT.sh" --no-check-certificate >/dev/null 2>&1
  log "Atualizando arquivo libs.tar.gz"
  wget -N -P "$ARIUSMONTIOR_BOT_DIR" "https://repo.ariusmonitor.flagee.cloud/libs.tar.gz" --no-check-certificate >/dev/null 2>&1
  
  if [ "$PARAM_SCRIPTS_PATH" != "" ]; then
    log "Atualizando scripts $PARAM_SCRIPTS_PATH/scripts.tar.gz"
    wget -N -P "$ARIUSMONTIOR_BOT_DIR/$PARAM_SCRIPTS_PATH" "https://repo.ariusmonitor.flagee.cloud/$PARAM_SCRIPTS_PATH/scripts.tar.gz" --no-check-certificate >/dev/null 2>&1
  fi

  # Ajustando permissões dos arquivos MonitoraSATC e MonitoraSAT.sh
  log "Ajustando permissões dos arquivos MonitoraSATC e MonitoraSAT.sh"
  chmod 777 $ARIUSMONTIOR_BOT_DIR/MonitoraSATc $ARIUSMONTIOR_BOT_DIR/MonitoraSATc64 $ARIUSMONTIOR_BOT_DIR/MonitoraSAT.sh
}

# Define uma função auxiliar para executar comandos sshpass
run_sshpass() {
    local cmd=$1
    local USER="$2"
    local PASS="$3"
    local IP="$4"
    local DEBBUG_INDIVIDUAL="$5"

    # Execute o comando e capture a saída e a saída de erro
    local output=$(timeout 30 sshpass -p "$PASS" ssh -T -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss "$USER@$IP" "$cmd" 2>&1)

    # Verifique o status de saída do sshpass
    local exit_status=$?

    # Faça o log da saída e do status de saída
    if [ "$PARAM_DEBBUG" == "true" ]; then
      log "Comando: $cmd"
      log "Saída:$YELLOW $output $NC"
      log "Status de saída: $exit_status"
    fi

    if [ "$DEBBUG_INDIVIDUAL" == "true" ]; then
      log "Comando: $cmd"
      log "**** Retorno:$YELLOW $output $NC" "" "$LOGFILE_MONITORASAT"
    fi

    if [ $exit_status -ne 0 ]; then
        log "Falha ao executar o comando: $cmd"
        exit 1
    fi
}



# Define uma função auxiliar para executar comandos scp
run_sshpass_scp() {
    local ORIGEM="$1"
    local DESTINO="$2"
    local USER="$3"
    local PASS="$4"
    local IP="$5"

    if [ -n $DESTINO ]; then
      local BASE_DESTINO="~/"
    fi

    #local cmd="sshpass -p $PASS scp -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss $ORIGEM $USER@$IP:$BASE_DESTINO$DESTINO"
    local cmd="timeout 30 sshpass -p $PASS scp -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss $ORIGEM $USER@$IP:$BASE_DESTINO$DESTINO"
    local output=$( eval "$cmd" 2>&1 )
    
    # Verifique o status de saída do sshpass
    local exit_status=$?

    # Faça o log da saída e do status de saída
    if [ $PARAM_DEBBUG == "true" ]; then
      log "Comando: $cmd"
      log "Saída:$YELLOW $output $NC"
      log "Status de saída: $exit_status"
    fi

    if [ $exit_status -ne 0 ]; then
        log "Falha ao executar o comando: $cmd"
        exit 1
    fi
}



# update_zabbix_geral_config(){}

# Função para verificar a instalação do monitoramento
check_installation() {
  log 'Iniciando função check_installation' "$YELLOW"
  local USER="$1"
  local PASS="$2"
  local IP="$3"
  local DISTRO="$4"
  local VERSION="$5"
  local ARCH="$6"
  local HOST="$7"
  local IP_PROXY="$8"
  local PORT="$9"

  # Define o comando SUDO_COMMAND de acordo com a distribuição
  if [ $USER != "root" ]; then 
    if [ "$DISTRO" = "Ubuntu" ] || [ "$DISTRO" = "Mint" ]; then
      SUDO_COMMAND="echo '$PASS' | sudo -S"
    else
      SUDO_COMMAND="echo '$PASS' | su -c"
    fi
  else
    SUDO_COMMAND=""
  fi


  # Verifica se o pacote 'ariusmonitor' está instalado
  ARIUSMONITOR_AGENT_INSTALLED=$(sshpass -p "$PASS" ssh -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss "$USER@$IP" "ls /ariusmonitor/conf/zabbix_agentd.conf 2>/dev/null" 2>/dev/null)


  # Instala ou atualiza o ariusmonitor-agent
  if [ -z "$ARIUSMONITOR_AGENT_INSTALLED" ] || [ $PARAM_UPDATE_ARIUSMONITOR == 'true' ]; then
    # Instalando novo ariusmonitor-agent
    log "** Instalando novo ariusmonitor-agent" "$GREEN"
    install_package_ariusmonitor "$USER" "$PASS" "$IP" "$SUDO_COMMAND" "$DISTRO" "$VERSION" "$ARCH" "$HOST" "$IP_PROXY" "$PORT"
  else
    if [ $PARAM_IGNORE_CONFIG_ARIUSMONITOR == 'false' ]; then
      log "** ariusmonitor-agent encontrado" "$BLUE"
      # Atualizando ariusmonitor-agent
      log "** Atualizando configurações do ariusmonitor-agent"
      update_ariusmonitor_agent_config "$USER" "$PASS" "$IP" "$SUDO_COMMAND" "$IP_PROXY" "$HOST" "$DISTRO" "$VERSION" "$PORT"
    else 
      log "** ariusmonitor-agent encontrado" "$BLUE"
      log "** Ignorando atualização do ariusmonitor"
    fi
  fi


}


update_proxy_config(){
  log 'Iniciando função update_proxy_config' "$YELLOW"
  # Atualizando Configurações do Proxy antes de atualizar os PDVs
  log "** Atualizando Configurações do Proxy antes de atualizar os PDVs" "$BLUE"
  sudo zabbix_proxy -R config_cache_reload
  sudo zabbix_proxy -R housekeeper_execute
}



# Função para atualizar a configuração do 'ariusmonitor-agent'
update_ariusmonitor_agent_config() {
  log 'Iniciando função update_ariusmonitor_agent_config' "$YELLOW"
    local USER="$1"
    local PASS="$2"
    local IP="$3"
    local SUDO_COMMAND="$4"
    local IP_PROXY="$5"
    local HOST="$6"
    local DISTRO="$7"
    local VERSION="$8"
    local PORT="$9"
    local ALLOWROOT=1
    local MAXLINEPERSECOND=100

    local BASE_DESTINO="~"

    # Enviando arquivo MonitoraSATc
    log "** Enviando arquivo $ARIUSMONTIOR_BOT_DIR/MonitoraSATc"
    run_sshpass_scp "$ARIUSMONTIOR_BOT_DIR/MonitoraSATc" "" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND mv ~$USER/MonitoraSATc /ariusmonitor" "$USER" "$PASS" "$IP"

    # Enviando arquivo MonitoraSATc64
    log "** Enviando arquivo $ARIUSMONTIOR_BOT_DIR/MonitoraSATc64"
    run_sshpass_scp "$ARIUSMONTIOR_BOT_DIR/MonitoraSATc64" "" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND mv ~$USER/MonitoraSATc64 /ariusmonitor" "$USER" "$PASS" "$IP"

    # Criando arquivo de error log do MonitoraSATc
    log "** Criando arquivo  $ARIUSMONTIOR_BOT_DIR/monitora_error.log"
    run_sshpass "$SUDO_COMMAND touch $ARIUSMONTIOR_BOT_DIR/monitora_error.log && chmod 777 $ARIUSMONTIOR_BOT_DIR/monitora_error.log" "$USER" "$PASS" "$IP"

    # Enviando arquivo MonitoraSAT.sh
    log "** Enviando arquivo $ARIUSMONTIOR_BOT_DIR/MonitoraSAT.sh"
    run_sshpass_scp "$ARIUSMONTIOR_BOT_DIR/MonitoraSAT.sh" "" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND mv ~$USER/MonitoraSAT.sh /ariusmonitor" "$USER" "$PASS" "$IP"

    # Enviando arquivo libs.tar.gz
    log "** Enviando arquivo $ARIUSMONTIOR_BOT_DIR/libs.tar.gz"
    run_sshpass_scp "$ARIUSMONTIOR_BOT_DIR/libs.tar.gz" "" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND mv ~$USER/libs.tar.gz /ariusmonitor" "$USER" "$PASS" "$IP"

    log "** Descompactando /ariusmonitor/libs.tar.gz"
    run_sshpass "$SUDO_COMMAND tar zxvf /ariusmonitor/libs.tar.gz -C /ariusmonitor" "$USER" "$PASS" "$IP"

    if [ "$PARAM_SCRIPTS_PATH" != "" ]; then
      # Enviando arquivo scripts.tar.gz
      log "** Enviando arquivo $ARIUSMONTIOR_BOT_DIR/$PARAM_SCRIPTS_PATH/scripts.tar.gz"
      run_sshpass_scp "$ARIUSMONTIOR_BOT_DIR/$PARAM_SCRIPTS_PATH/scripts.tar.gz" "" "$USER" "$PASS" "$IP"
      run_sshpass "$SUDO_COMMAND mv ~$USER/scripts.tar.gz /ariusmonitor/scripts.tar.gz" "$USER" "$PASS" "$IP"
    
      log "** Descompactando /ariusmonitor/scripts.tar.gz"
      run_sshpass "$SUDO_COMMAND tar zxvf /ariusmonitor/scripts.tar.gz -C /ariusmonitor/" "$USER" "$PASS" "$IP"
    fi

    # log "** Removendo arquivo /ariusmonitor/sat.conf"
    # run_sshpass "$SUDO_COMMAND rm /ariusmonitor/sat.conf" "$USER" "$PASS" "$IP"

    # Enviando arquivo geral.conf
    log "** Enviando arquivo $ARIUSMONTIOR_BOT_DIR/geral.conf"
    run_sshpass_scp "$ARIUSMONTIOR_BOT_DIR/geral.conf" "" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND mv ~$USER/geral.conf $ARIUSMONITOR_CONFIG_AGENTD_PATH" "$USER" "$PASS" "$IP"

    log "** Executando /ariusmonitor/utilities/update.sh"
    run_sshpass "$SUDO_COMMAND /ariusmonitor/utilities/update.sh" "$USER" "$PASS" "$IP"

    # Recriando arquivo $ARIUSMONITOR_CONFIG_FILE.. DEIXAR SEM IDENTAR A PARTE DO CAT
    log "** Recriando arquivo $ARIUSMONITOR_CONFIG_FILE"
    run_sshpass "$SUDO_COMMAND bash -c 'cat << EOF > $ARIUSMONITOR_CONFIG_FILE
Server=$IP_PROXY
ServerActive=$IP_PROXY
ListenPort=$PORT
LogFile=$ARIUSMONITOR_CONFIG_LOGFILE
PidFile=$ARIUSMONITOR_CONFIG_PIDFILE
Hostname=$HOST
BufferSize=300
AllowRoot=1
Include=$ARIUSMONITOR_CONFIG_INCLUDE
MaxLinesPerSecond=100
AllowKey=system.run[*]
UnsafeUserParameters=1
Timeout=20
EOF'" $USER $PASS $IP


    if [ "$DISTRO" = "Ubuntu" ] || [ "$DISTRO" = "Mint" ]; then
      # Configurando SUDOER para executar MonitoraSAT
      log "** Configurando SUDOER para executar MonitoraSAT"
      run_sshpass "$SUDO_COMMAND bash -c 'cat << EOF > /etc/sudoers.d/ariusmonitor
ariusmonitor ALL = NOPASSWD: /ariusmonitor/MonitoraSAT.sh
ariusmonitor ALL = NOPASSWD: /ariusmonitor/MonitoraSATc
ariusmonitor ALL = NOPASSWD: /usr/bin/pkill MonitoraSATc
ariusmonitor ALL = NOPASSWD: /bin/bash -c /ariusmonitor/MonitoraSATc
ariusmonitor ALL = NOPASSWD: /usr/bin/pkill -f MonitoraSATc
ariusmonitor ALL = NOPASSWD: /usr/bin/pgrep -x MonitoraSATc
ariusmonitor ALL = NOPASSWD: /ariusmonitor/MonitoraSATc64
ariusmonitor ALL = NOPASSWD: /usr/bin/pkill MonitoraSATc64
ariusmonitor ALL = NOPASSWD: /bin/bash -c /ariusmonitor/MonitoraSATc64
ariusmonitor ALL = NOPASSWD: /usr/bin/pkill -f MonitoraSATc64
ariusmonitor ALL = NOPASSWD: /usr/bin/pgrep -x MonitoraSATc64

# Permitir acesso às bibliotecas específicas
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /posnet/libsatprotocol.so
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /posnet/libSAT.so
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /posnet/libsattanca.so
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /posnet/libSatGer.so
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /posnet/libbemasat.so
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /posnet/libsatelgin.so
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /posnet/libsatelgin-linker2.so
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /posnet/libsatid.so
ariusmonitor ALL = NOPASSWD: /usr/bin/readelf -h /home/arius/AriusIntegrador/libsat.so
EOF'" $USER $PASS $IP
    fi

    if [[ "$PARAM_SAT_ASSOCIAR_ASSINATURA" == 'true' && ( "$PARAM_LOJA" != '' || "$PARAM_PDV_IP" != '' ) ]]; then
      
      if [[ "$PARAM_CNPJ_CONTRIBUINTE" == '' || "$PARAM_CHAVE_ASSINATURA" == '' ]]; then
        log "** Para associar uma assinatura ao SAT, informe os valores dos parâmetros --cnpj-contribuinte e --chave-assinatura" "$RED" "$LOGFILE_MONITORASAT"
      else
        log "** Iniciando Associação de Assinatura do SAT no PDV $HOST" "$GREEN" "$LOGFILE_MONITORASAT"
        run_sshpass "$SUDO_COMMAND /ariusmonitor/MonitoraSAT.sh --func AssociarAssinatura --cnpj-contribuinte $PARAM_CNPJ_CONTRIBUINTE --chave \"$PARAM_CHAVE_ASSINATURA\"" "$USER" "$PASS" "$IP" "true"
      fi
    elif [[ "$PARAM_SAT_ASSOCIAR_ASSINATURA" == 'true' && ( "$PARAM_LOJA" == '' && "$PARAM_PDV_IP" == '' ) ]]; then
      log "** Para associar uma assinatura ao SAT, informe um valor para --loja ou --pdv-ip" "$RED" "$LOGFILE_MONITORASAT"
    fi


    if [ "$PARAM_UPDATE_SAT" == 'true' ]; then
      log "** Iniciando Atualização do SAT no PDV $HOST" "$GREEN" "$LOGFILE_MONITORASAT"
      run_sshpass "$SUDO_COMMAND /ariusmonitor/MonitoraSAT.sh --func AtualizarSoftwareSAT" "$USER" "$PASS" "$IP" "true"
    fi

    log "** Reiniciando o serviço do ariusmonitor-agent"
    run_sshpass "$SUDO_COMMAND /ariusmonitor/utilities/start.sh" "$USER" "$PASS" "$IP"

    log "** Enviando trapper ligado=1"
    run_sshpass "$SUDO_COMMAND /ariusmonitor/zabbix/bin/zabbix_sender -c $ARIUSMONITOR_CONFIG_FILE -k ligado -o 1" "$USER" "$PASS" "$IP"

}

    
# Função para instalar o pacote no Ubuntu
install_package_ariusmonitor() {
    log 'Iniciando função install_package_ariusmonitor' "$YELLOW"
    local USER="$1"
    local PASS="$2"
    local IP="$3"
    local SUDO_COMMAND="$4"
    local DISTRO="$5"
    local VERSION="$6"
    local ARCH="$7"
    local HOST="$8"
    local IP_PROXY="$9"
    local PORT="${10}"

    PACKAGE_FILE="ariusmonitor.tar.gz"
    PACKAGE_PATH="/ariusmonitor/ariusmonitor.tar.gz"

    # Verifica se o arquivo do pacote existe
    if [ ! -e "$PACKAGE_PATH" ]; then
        log "** Pacote não encontrado $PACKAGE_PATH"
        return
    fi

    if [ $PARAM_MOVE_LOGS == 'true' ]; then
      log "** Movendo logs antigos do Arius PDV para a pasta /posnet/logs_old/"
      run_sshpass "$SUDO_COMMAND mkdir /posnet/logs_old/" "$USER" "$PASS" "$IP"
      run_sshpass "$SUDO_COMMAND find /posnet -maxdepth 1 -name 'log*.txt' -type f -mtime +1 -exec mv {} /posnet/logs_old/ \;" "$USER" "$PASS" "$IP"
      run_sshpass "$SUDO_COMMAND find /posnet -maxdepth 1 -name 'nfiscal*.txt' -type f -mtime +1 -exec mv {} /posnet/logs_old/ \;" "$USER" "$PASS" "$IP"
    fi

    local BASE_DESTINO="~"

    # Inicia o envio do pacote
    log "** Enviando pacote $PACKAGE_FILE para $IP" "$NC" "$LOGFILE_HTCONFIG_NOTINSTALLED"
    run_sshpass_scp "$PACKAGE_PATH" "" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND rm -f /ariusmonitor.tar.gz >/dev/null 2>&1" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND mv $BASE_DESTINO/$PACKAGE_FILE /" "$USER" "$PASS" "$IP"

    # Verifica se o envio do pacote foi bem sucedido
    if [ $? -eq 0 ]; then
        log "** Descompactando $PACKAGE_FILE no $DISTRO $VERSION"
        run_sshpass "$SUDO_COMMAND tar zxvf /$PACKAGE_FILE -C /" "$USER" "$PASS" "$IP"

        log "** Parando serviço $PACKAGE_FILE no $DISTRO $VERSION"
        run_sshpass "$SUDO_COMMAND /ariusmonitor/utilities/stop.sh" "$USER" "$PASS" "$IP"

        log "** Instalando pacote ariusmonitor no $DISTRO $VERSION"
        run_sshpass "$SUDO_COMMAND /ariusmonitor/utilities/setup.sh" "$USER" "$PASS" "$IP"

        if [ $? -eq 0 ]; then
        log "** ariusmonitor instalado com sucesso" "$GREEN"
        else
        log "** Falha ao instalar ariusmonitor" "$RED"
        fi
        
        # Atualiza as configurações do ariusmonitor-agent
        log "** Atualizando configurações do ariusmonitor-agent"
        update_ariusmonitor_agent_config "$USER" "$PASS" "$IP" "$SUDO_COMMAND" "$IP_PROXY" "$HOST" "$DISTRO" "$VERSION" "$PORT"
    fi
    
}


# Função para instalar o pacote no Ubuntu
remove_monitorasat() {
    log 'Iniciando função remove_monitorasat' "$YELLOW"
    local USER="$1"
    local PASS="$2"
    local IP="$3"
    local DISTRO="$4"
    local VERSION="$5"
    local ARCH="$6"
    local HOST="$7"
    local IP_PROXY="$8"
    local PORT="$9"

    # Define o comando SUDO_COMMAND de acordo com a distribuição
    if [ $USER != "root" ]; then 
      if [ "$DISTRO" = "Ubuntu" ] || [ "$DISTRO" = "Mint" ]; then
        SUDO_COMMAND="echo '$PASS' | sudo -S"
      else
        SUDO_COMMAND="echo '$PASS' | su -c"
      fi
    else
      SUDO_COMMAND=""
    fi

    # Inicia o envio do pacote
    log "** Removendo MonitoraSAT para $IP" "$NC" "$LOGFILE_HTCONFIG_NOTINSTALLED"
    run_sshpass "$SUDO_COMMAND rm -f /ariusmonitor/MonitoraSATc" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND rm -f /ariusmonitor/MonitoraSATc64" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND rm -f /ariusmonitor/MonitoraSAT" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND rm -f /ariusmonitor/MonitoraSAT.sh" "$USER" "$PASS" "$IP"
}


# Função para instalar o pacote no Ubuntu
force_monitorasat() {
    log 'Iniciando função force_monitorasat' "$YELLOW"
    local USER="$1"
    local PASS="$2"
    local IP="$3"
    local DISTRO="$4"
    local VERSION="$5"
    local ARCH="$6"
    local HOST="$7"
    local IP_PROXY="$8"
    local PORT="$9"

    # Define o comando SUDO_COMMAND de acordo com a distribuição
    if [ $USER != "root" ]; then 
      if [ "$DISTRO" = "Ubuntu" ] || [ "$DISTRO" = "Mint" ]; then
        SUDO_COMMAND="echo '$PASS' | sudo -S"
      else
        SUDO_COMMAND="echo '$PASS' | su -c"
      fi
    else
      SUDO_COMMAND=""
    fi
    # Enviando arquivo libs.tar.gz
    log "** Enviando arquivo $ARIUSMONTIOR_BOT_DIR/libs.tar.gz"
    run_sshpass_scp "$ARIUSMONTIOR_BOT_DIR/libs.tar.gz" "" "$USER" "$PASS" "$IP"
    run_sshpass "$SUDO_COMMAND mv ~$USER/libs.tar.gz /ariusmonitor" "$USER" "$PASS" "$IP"

    log "** Descompactando /ariusmonitor/libs.tar.gz"
    run_sshpass "$SUDO_COMMAND tar zxvf /ariusmonitor/libs.tar.gz -C /ariusmonitor" "$USER" "$PASS" "$IP"

    # Inicia o envio do pacote
    log "** Forçando MonitoraSAT para $IP" "$NC" "$LOGFILE_HTCONFIG_NOTINSTALLED"
    run_sshpass "$SUDO_COMMAND /ariusmonitor/MonitoraSAT.sh" "$USER" "$PASS" "$IP"
}


# Função para realizar backup dos cupons XML dos últimos 10 dias
backup_cupom() {
    log 'Iniciando função backup_cupom' "$YELLOW"
    local USER="$1"
    local PASS="$2"
    local IP="$3"
    local HOST="$4"
    local BASE_DIR="/posnet/NFCEBKP/"  # Diretório base no host de origem
    local DEST_DIR="/NFCEBKP/$HOST/"  # Diretório de destino no host intermediário

    # Exportar senha para sshpass
    export SSHPASS=$PASS

    # Comando SSH para listar subdiretórios dentro de NFCEBKP (representando CNPJs)
    local SSH_CMD="sshpass -e ssh -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss -l $USER $IP"
    local CNPJs=$(eval "$SSH_CMD ls $BASE_DIR")

    # Iterar sobre cada CNPJ e verificar diretórios de datas
    for CNPJ in $CNPJs; do
        local DATES=()
        for i in {0..9}; do
            DATES+=($(date --date="$i days ago" +%Y-%m-%d))
        done
        
        for DATE in "${DATES[@]}"; do
            local CURRENT_DIR="${BASE_DIR}${CNPJ}/${DATE}/"
            local EXISTS_CMD="$SSH_CMD test -d \"$CURRENT_DIR\" && echo exists"
            if [ "$(eval $EXISTS_CMD)" == "exists" ]; then
                local FULL_DEST_DIR="$DEST_DIR$CNPJ/$DATE/"
                mkdir -p "$FULL_DEST_DIR"
                # Ajustar o comando para copiar o conteúdo do diretório, não o diretório
                local SCP_CMD="sshpass -p '$PASS' scp -r -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss $USER@$IP:\"$CURRENT_DIR*\" \"$FULL_DEST_DIR\""
                log "Executando backup de arquivos XML de $DATE para $HOST no CNPJ $CNPJ"
                eval $SCP_CMD
                if [ $? -eq 0 ]; then
                    log "Backup de $DATE no CNPJ $CNPJ bem-sucedido para $HOST" "$GREEN"
                else
                    log "Erro ao realizar backup de $DATE no CNPJ $CNPJ para $HOST" "$RED"
                fi
            else
                log "Diretório $DATE não existe para CNPJ $CNPJ em $HOST, pulando..." "$YELLOW"
            fi
        done
    done

    # Limpar variável de ambiente
    unset SSHPASS
}

# Função para realizar o desligamento de máquinas com condicionamento de horário
shutdown() {
    log 'Iniciando função shutdown' "$YELLOW"
    local USER="$1"
    local PASS="$2"
    local IP="$3"
    local DISTRO="$4"
    local VERSION="$5"
    local ARCH="$6"
    local HOST="$7"

    # Define o comando SUDO_COMMAND de acordo com a distribuição
    if [ $USER != "root" ]; then 
      if [ "$DISTRO" = "Ubuntu" ] || [ "$DISTRO" = "Mint" ]; then
        SUDO_COMMAND="echo '$PASS' | sudo -S"
      else
        SUDO_COMMAND="echo '$PASS' | su -c"
      fi
    else
      SUDO_COMMAND=""
    fi

    # Obtém a hora atual no formato de 24 horas (HH)
    local hour=$(date +%H)  # Obtem a hora atual do sistema no formato de 24 horas.
    
    # Converte a hora para número inteiro para comparação
    local HOUR=$(echo $CURRENT_HOUR | sed 's/^0*//')

    # Verifica se a hora atual está entre 23 e 7 (inclui 23, mas não 7)
    if [ "$hour" -ge 23 ] || [ "$hour" -le 7 ]; then
        log "Desligando $HOST" "$YELLOW"
        run_sshpass "$SUDO_COMMAND shutdown -h now" "$USER" "$PASS" "$IP"
    else
        log "Fora do horário de desligamento automático para $HOST" "$YELLOW"
    fi
}

# Função para verificar se o ariusmonitor-agent foi instalado
check_ariusmonitor_agent_installed() {
    log 'Iniciando função check_ariusmonitor_agent_installed' "$YELLOW"
    local USER="$1"
    local PASS="$2"
    local IP="$3"
    
    ZABBIX_AGENT_INSTALLED=$(timeout 30 sshpass -p "$PASS" ssh -o StrictHostKeyChecking=no -o HostKeyAlgorithms=+ssh-dss "$USER@$IP" "which ariusmonitor" 2>/dev/null)
    if [ -n "$ZABBIX_AGENT_INSTALLED" ]; then
        log "** ariusmonitor-agent instalado com sucesso" "$GREEN"
    else
        log "** Falha ao instalar ariusmonitor-agent" "$RED"
    fi
}

update_proxy_config
get_ariusmonitor_geral_config


# Ajuste a requisição JSON para incluir o filtro construído
JSON_REQ=$(cat <<EOF
{
  "jsonrpc": "2.0",
  "method": "host.get",
  "params": {
    "search": {
      "host": ["$PARAM_REDE-$filtro_host"]
    },
    "output": ["host"],
    "selectInventory": ["notes"],
    "selectInterfaces": ["ip", "port", "available"]
  },
  "auth": "$PARAM_TOKEN",
  "id": 1
}
EOF
)

log "Conectando no Zabbix-Server"
RESPONSE=$(curl -k -s -X POST -H 'Content-Type: application/json-rpc' -d "$JSON_REQ" 'https://monitor.flagee.cloud/api_jsonrpc.php')

# Loop principal para processar os IPs e credenciais de acesso
IFS=$'\n'
for line in $(echo "$RESPONSE" | jq -c '.result[]'); do
  # Manter AVAILABLE em primeiro no FOR para suportar a condição de filtro do AGENT_STATUS
  AVAILABLE=$(echo "$line" | jq -r '.interfaces[0].available')
  
  if [[ $PARAM_AGENT_STATUS -ne '' ]]; then
    if [[ $AVAILABLE -ne $PARAM_AGENT_STATUS ]]; then
      # echo "HOST: $HOST, AVAILABLE: $AVAILABLE"
      continue
    fi
  fi
  
  HOST=$(echo "$line" | jq -r '.host')
  IP=$(echo "$line" | jq -r '.interfaces[0].ip')
  PORT=$(echo "$line" | jq -r '.interfaces[0].port')
  USER_PASS=$(echo "$line" | jq -r '.inventory.notes')
  USER=$(echo "$USER_PASS" | cut -d',' -f1)
  PASS=$(echo "$USER_PASS" | cut -d',' -f2)

  log "Processando HOST: $HOST (IP $IP)"
  log "Status: $PARAM_AGENT_STATUS, AVAILABLE: $AVAILABLE"

  if [ -z $USER ] || [ -z $PASS ];then
    log "Usuario ou Senha vazios" "$RED"
    continue 
  fi

  check_connection "$IP" "$USER" "$PASS"
  CONNECTION_STATUS=$?

  case $CONNECTION_STATUS in
    0)
      zabbix_sender -c /etc/zabbix/zabbix_agentd.conf -s $HOST -k pdv.credenciais_invalidas -o 0
      DISTRO_VERSION=$(detect_distro_and_version "$IP" "$USER" "$PASS")
      DISTRO=$(echo "$DISTRO_VERSION" | cut -d' ' -f1)
      VERSION=$(echo "$DISTRO_VERSION" | cut -d' ' -f2)
      
      ARCH=$(detect_architecture "$IP" "$USER" "$PASS")
      log "Conexão bem-sucedida com $IP"
      log "Distribuição: $DISTRO, Versão: $VERSION, Arquitetura: $ARCH" "$NC"
      
      if [ $PARAM_REMOVE_MONITORASAT == 'true' ]; then
        remove_monitorasat "$USER" "$PASS" "$IP" "$DISTRO" "$VERSION" "$ARCH" "$HOST" "$PARAM_PROXY_IP" "$PORT"
      elif [ $PARAM_SHUTDOWN == 'true' ]; then
        if [[ $HOST == *"PAGUEMENOS-LOJA032"* || $HOST == *"CONCENTRADOR"* ]]; then
          log "Shutdown ignorado para $HOST" "$YELLOW"
        else
          shutdown "$USER" "$PASS" "$IP" "$DISTRO" "$VERSION" "$ARCH" "$HOST"
        fi
      elif [ $PARAM_BACKUP_CUPOM == 'true' ]; then
        backup_cupom "$USER" "$PASS" "$IP" "$HOST"
      else
        check_installation "$USER" "$PASS" "$IP" "$DISTRO" "$VERSION" "$ARCH" "$HOST" "$PARAM_PROXY_IP" "$PORT"
      fi
      ;;
    1)
      log "Máquina não responde: $IP" "$RED" "$LOGFILE_MACHINE_UNRESPONSIVE"
      ;;
    2)
      log "Credenciais inválidas: $IP" "$RED" "$LOGFILE_INVALID_CREDENTIALS"
      zabbix_sender -c /etc/zabbix/zabbix_agentd.conf -s $HOST -k pdv.credenciais_invalidas -o 1
      ;;
  esac
  log "----------------------------"
done
