main2.py

import pyautogui
import time
import subprocess
import logging
import os
import psutil
from datetime import datetime
from typing import List, Dict, Any, Optional
from dataclasses import dataclass
from abc import ABC, abstractmethod
import pyperclip
import boto3
from botocore.exceptions import NoCredentialsError, ClientError

from dotenv import load_dotenv
load_dotenv()

# Configuração do logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('automation.log'),
        logging.StreamHandler()
    ]
)

def kill_firefox_processes():
    """Mata todos os processos do Firefox"""
    try:
        for proc in psutil.process_iter(['pid', 'name']):
            if 'firefox' in proc.info['name'].lower():
                logging.info(f"Matando processo Firefox: PID {proc.info['pid']}")
                proc.kill()
        logging.info("Todos os processos Firefox foram encerrados")
        return True
    except Exception as e:
        logging.error(f"Erro ao matar processos Firefox: {e}")
        return False

@dataclass
class ActionConfig:
    """Configuração base para ações de automação"""
    tipo: str
    max_retries: int = 3
    retry_delay: float = 2.0

class Action(ABC):
    """Classe base abstrata para ações de automação"""
    def __init__(self, config: ActionConfig):
        self.config = config
        self.retry_count = 0

    @abstractmethod
    def execute(self) -> bool:
        """Executa a ação e retorna True se bem sucedida"""
        pass

    def retry(self) -> bool:
        """Tenta executar a ação novamente se falhar"""
        if self.retry_count < self.config.max_retries:
            self.retry_count += 1
            time.sleep(self.config.retry_delay)
            return self.execute()
        return False

class ClickAction(Action):
    def __init__(self, imagens: List[str], tempos_espera: List[float], config: ActionConfig, usar_ultimo: bool = False):
        super().__init__(config)
        self.imagens = imagens
        self.tempos_espera = tempos_espera
        self.IMAGENS_PASTA = 'imagens'
        self.usar_ultimo = usar_ultimo

    def execute(self) -> bool:
        try:
            for i, imagem in enumerate(self.imagens):
                imagem_path = os.path.join(self.IMAGENS_PASTA, imagem)
                if self.usar_ultimo:
                    todas_posicoes = list(pyautogui.locateAllOnScreen(imagem_path, confidence=0.9))
                    if todas_posicoes:
                        posicao = todas_posicoes[-1]
                        pyautogui.click(pyautogui.center(posicao))
                        logging.info(f"Botão '{imagem}' (último encontrado) clicado com sucesso.")
                    else:
                        logging.warning(f"Botão '{imagem}' não encontrado.")
                        return False
                else:
                    button_location = pyautogui.locateOnScreen(imagem_path, confidence=0.9)
                    if button_location:
                        pyautogui.click(pyautogui.center(button_location))
                        logging.info(f"Botão '{imagem}' clicado com sucesso.")
                    else:
                        logging.warning(f"Botão '{imagem}' não encontrado.")
                        return False
                if i < len(self.tempos_espera):
                    time.sleep(self.tempos_espera[i])
            return True
        except Exception as e:
            logging.error(f"Erro ao clicar nos botões: {e}")
            return False

class TypeAction(Action):
    def __init__(self, texto: str, config: ActionConfig):
        super().__init__(config)
        self.texto = texto

    def execute(self) -> bool:
        try:
            pyperclip.copy(self.texto)
            pyautogui.hotkey('ctrl', 'v')
            logging.info(f"Texto colado via clipboard: {self.texto}")
            return True
        except Exception as e:
            logging.error(f"Erro ao colar texto: {e}")
            return False

class KeyPressAction(Action):
    def __init__(self, tecla: str, config: ActionConfig):
        super().__init__(config)
        self.tecla = tecla

    def execute(self) -> bool:
        try:
            pyautogui.press(self.tecla)
            logging.info(f"Tecla pressionada: {self.tecla}")
            return True
        except Exception as e:
            logging.error(f"Erro ao pressionar tecla: {e}")
            return False

class WaitAction(Action):
    def __init__(self, tempo: float, config: ActionConfig):
        super().__init__(config)
        self.tempo = tempo

    def execute(self) -> bool:
        try:
            time.sleep(self.tempo)
            logging.info(f"Aguardando {self.tempo} segundos")
            return True
        except Exception as e:
            logging.error(f"Erro ao aguardar: {e}")
            return False

class ScreenshotAction(Action):
    def __init__(self, nome: str, config: ActionConfig):
        super().__init__(config)
        self.nome = nome

    def execute(self) -> bool:
        try:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"{self.nome}_.png"
            path = os.path.join('screenshots', filename)
            os.makedirs('screenshots', exist_ok=True)
            screenshot = pyautogui.screenshot()
            screenshot.save(path)
            logging.info(f"Screenshot salvo como {path}")
            return True
        except Exception as e:
            logging.error(f"Erro ao tirar screenshot: {e}")
            return False

class CloseAction(Action):
    def execute(self) -> bool:
        try:
            pyautogui.hotkey('ctrl', 'w')
            time.sleep(2)
            pyautogui.hotkey('ctrl', 'q')
            logging.info("Navegador fechado com sucesso")
            return True
        except Exception as e:
            logging.error(f"Erro ao fechar navegador: {e}")
            return False

class UploadMinioAction(Action):
    def __init__(self, config: ActionConfig):
        super().__init__(config)

    def execute(self) -> bool:
        try:
            from datetime import date

            # monta data e nomes de arquivo
            day = date.today()
            data_completa = day.strftime("%Y-%m-%d")
            secoes = "DO1 DO2 DO3 DO1E DO2E DO3E".split()
            nomes_arquivos = [f"{data_completa}-{sec}.zip" for sec in secoes]
            downloads_path = os.path.expanduser("~/Downloads")

            # lê variáveis de ambiente (já carregadas pelo load_dotenv)
            bucket   = os.getenv("MINIO_BUCKET")
            access   = os.getenv("MINIO_ACCESS_KEY")
            secret   = os.getenv("MINIO_SECRET_KEY")
            endpoint = os.getenv("MINIO_ENDPOINT")

            if not all([bucket, access, secret, endpoint]):
                logging.error("L Variáveis de ambiente do MinIO faltando.")
                return False

            # cria client S3/MinIO
            s3 = boto3.client(
                's3',
                endpoint_url=endpoint,
                aws_access_key_id=access,
                aws_secret_access_key=secret
            )

            sucesso = True
            for nome in nomes_arquivos:
                caminho = os.path.join(downloads_path, nome)
                if not os.path.exists(caminho):
                    logging.warning(f"Arquivo não encontrado: {caminho}")
                    sucesso = False
                    continue

                logging.info(f"¡  Upload de {caminho} para {bucket}/{nome}...")
                try:
                    s3.upload_file(Filename=caminho, Bucket=bucket, Key=nome)
                    logging.info(f" Upload de {nome} concluído.")
                    os.remove(caminho)
                    logging.info(f"=Ñ  Arquivo local excluído: {caminho}")
                except FileNotFoundError:
                    logging.error(f"L Arquivo não encontrado durante o upload: {caminho}")
                    sucesso = False
                except NoCredentialsError:
                    logging.error("L Credenciais do MinIO não encontradas.")
                    sucesso = False
                except ClientError as e:
                    logging.error(f"L Falha no upload (ClientError): {e}")
                    sucesso = False
                except Exception as e:
                    logging.error(f"L Erro inesperado no upload: {e}")
                    sucesso = False

            return sucesso

        except Exception as e:
            logging.error(f"L Erro geral no upload para o MinIO: {e}")
            return False


class BaixarArquivosGraficoAction(Action):
    def __init__(self, config: ActionConfig):
        super().__init__(config)

    def execute(self) -> bool:
        try:
            import time
            from datetime import date
            day = date.today()
            ano = day.strftime("%Y")
            mes = day.strftime("%m")
            dia = day.strftime("%d")
            data_completa = f"{ano}-{mes}-{dia}"
            tipo_dou = "DO1 DO2 DO3 DO1E DO2E DO3E"
            url_download = "https://inlabs.in.gov.br/index.php?p="

            urls = [
                f"{url_download}{data_completa}&dl={data_completa}-{dou_secao}.zip"
                for dou_secao in tipo_dou.split()
            ]

            for i, url in enumerate(urls):
                # Seleciona a barra de endereços
                pyautogui.hotkey('ctrl', 't') if i > 0 else pyautogui.hotkey('ctrl', 'l')
                time.sleep(1)
                pyperclip.copy(url)
                pyautogui.hotkey('ctrl', 'v')
                time.sleep(1)
                pyautogui.press('enter')
                time.sleep(5)  # Ajuste conforme a velocidade do download
            logging.info("Downloads via automação gráfica finalizados.")
            return True
        except Exception as e:
            logging.error(f"Erro ao baixar arquivos via automação gráfica: {e}")
            return False

class VerificarDownloadsAction(Action):
    """Verifica se pelo menos um arquivo foi baixado com sucesso"""
    def __init__(self, config: ActionConfig):
        super().__init__(config)

    def execute(self) -> bool:
        try:
            from datetime import date
            day = date.today()
            data_completa = day.strftime("%Y-%m-%d")
            secoes = "DO1 DO2 DO3 DO1E DO2E DO3E".split()
            nomes_arquivos = [f"{data_completa}-{sec}.zip" for sec in secoes]
            downloads_path = os.path.expanduser("~/Downloads")
            
            arquivos_encontrados = []
            for nome in nomes_arquivos:
                caminho = os.path.join(downloads_path, nome)
                if os.path.exists(caminho):
                    tamanho = os.path.getsize(caminho)
                    arquivos_encontrados.append((nome, tamanho))
                    logging.info(f"Arquivo encontrado: {nome} ({tamanho} bytes)")
            
            if arquivos_encontrados:
                logging.info(f"Download bem-sucedido! {len(arquivos_encontrados)} arquivo(s) baixado(s)")
                return True
            else:
                logging.error("Nenhum arquivo foi baixado!")
                return False
                
        except Exception as e:
            logging.error(f"Erro ao verificar downloads: {e}")
            return False

class KillFirefoxAction(Action):
    """Mata todos os processos do Firefox"""
    def __init__(self, config: ActionConfig):
        super().__init__(config)

    def execute(self) -> bool:
        return kill_firefox_processes()

class AutomationManager:
    """Gerenciador principal de automação"""
    def __init__(self, config: Dict[str, Any]):
        self.config = config
        self.screenshot_dir = 'screenshots'
        os.makedirs(self.screenshot_dir, exist_ok=True)

    def take_screenshot(self, name: str = 'screenshot') -> str:
        """Tira um screenshot e retorna o caminho do arquivo"""
        try:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"{name}_{timestamp}.png"
            path = os.path.join(self.screenshot_dir, filename)
            screenshot = pyautogui.screenshot()
            screenshot.save(path)
            logging.info(f"Screenshot salvo como {path}")
            return path
        except Exception as e:
            logging.error(f"Erro ao tirar screenshot: {e}")
            return ""

    def execute_action(self, action: Action) -> bool:
        """Executa uma ação com sistema de retry"""
        success = action.execute()
        if not success:
            success = action.retry()
        return success

    def run_sequence(self, sequence: List[Dict[str, Any]]) -> None:
        """Executa uma sequência de ações"""
        try:
            for action_config in sequence:
                # Cria a configuração base com o tipo da ação
                base_config = {'tipo': action_config['tipo']}
                # Atualiza com configurações específicas se existirem
                if 'config' in action_config:
                    base_config.update(action_config['config'])
                
                config = ActionConfig(**base_config)
                
                if action_config['tipo'] == 'clicar':
                    usar_ultimo = action_config.get('usar_ultimo', False)
                    action = ClickAction(
                        action_config['imagens'],
                        action_config.get('tempos_espera', []),
                        config,
                        usar_ultimo=usar_ultimo
                    )
                elif action_config['tipo'] == 'digitar':
                    action = TypeAction(action_config['texto'], config)
                elif action_config['tipo'] == 'pressionar_tecla':
                    action = KeyPressAction(action_config['tecla'], config)
                elif action_config['tipo'] == 'esperar':
                    action = WaitAction(action_config['tempo'], config)
                elif action_config['tipo'] == 'tirar_screenshot':
                    action = ScreenshotAction(action_config['nome'], config)
                elif action_config['tipo'] == 'fechar':
                    action = CloseAction(config)
                elif action_config['tipo'] == 'upload_minio':
                    action = UploadMinioAction(config)
                elif action_config['tipo'] == 'baixar_arquivos_grafico':
                    action = BaixarArquivosGraficoAction(config)
                elif action_config['tipo'] == 'verificar_downloads':
                    action = VerificarDownloadsAction(config)
                elif action_config['tipo'] == 'matar_firefox':
                    action = KillFirefoxAction(config)
                else:
                    logging.error(f"Tipo de ação desconhecido: {action_config['tipo']}")
                    continue
                
                if not self.execute_action(action):
                    logging.error(f"Falha na execução da ação: {action_config}")
                    # Se a ação falhou, mata o Firefox antes de sair
                    logging.info("Matando Firefox devido a falha na execução...")
                    kill_firefox_processes()
                    break
                    
        except Exception as e:
            logging.error(f"Erro inesperado durante a execução: {e}")
            # Em caso de erro inesperado, também mata o Firefox
            logging.info("Matando Firefox devido a erro inesperado...")
            kill_firefox_processes()

def main():
    # Configuração inicial
    config = {
        'browser': {
            'command': ['firefox', '--no-sandbox'],
            'url': 'http://ip-api.com/json'
        }
    }

    # Variáveis de ambiente para login e senha
    INLABS_LOGIN = os.getenv("INLABS_LOGIN", "")
    INLABS_PASSWORD = os.getenv("INLABS_PASSWORD", "")

    # Inicializa o gerenciador
    manager = AutomationManager(config)

    try:
        # Abre o navegador
        try:
            subprocess.Popen(config['browser']['command'] + [config['browser']['url']])
            logging.info("Navegador iniciado.")
        except Exception as e:
            logging.error(f"Erro ao iniciar o navegador: {e}")
            return

        time.sleep(5)
        pyautogui.hotkey('ctrl', 'shift', 'a')
        time.sleep(2)

        # Sequência de ações para login no INLABS
        sequence = [
            {
                'tipo': 'clicar',
                'imagens': ['bt.png'],
                'tempos_espera': [5],
                'config': {'max_retries': 3, 'retry_delay': 2.0}
            },
            {
                'tipo': 'clicar',
                'imagens': ['bt1.png'],
                'tempos_espera': [5],
                'config': {'max_retries': 3, 'retry_delay': 2.0}
            },
            {
                'tipo': 'clicar',
                'imagens': ['bt2.png'],
                'tempos_espera': [3],
                'config': {'max_retries': 3, 'retry_delay': 2.0}
            },
            {
                'tipo': 'digitar',
                'texto': 'https://inlabs.in.gov.br/acessar.php',
                'config': {'max_retries': 2, 'retry_delay': 1.0}
            },
            {
                'tipo': 'pressionar_tecla',
                'tecla': 'enter',
                'config': {'max_retries': 2, 'retry_delay': 1.0}
            },
            {
                'tipo': 'esperar',
                'tempo': 25,
                'config': {'max_retries': 1, 'retry_delay': 0.0}
            },
            {
                'tipo': 'clicar',
                'imagens': ['bt_login.png'],
                'tempos_espera': [1],
                'usar_ultimo': True,
                'config': {'max_retries': 3, 'retry_delay': 1.0}
            },
            {
                'tipo': 'digitar',
                'texto': INLABS_LOGIN,
                'config': {'max_retries': 2, 'retry_delay': 0.5}
            },
            {
                'tipo': 'clicar',
                'imagens': ['bt_senha.png'],
                'tempos_espera': [1],
                'usar_ultimo': True,
                'config': {'max_retries': 3, 'retry_delay': 1.0}
            },
            {
                'tipo': 'digitar',
                'texto': INLABS_PASSWORD,
                'config': {'max_retries': 2, 'retry_delay': 0.5}
            },
            {
                'tipo': 'clicar',
                'imagens': ['bt_logar.png'],
                'tempos_espera': [2],
                'config': {'max_retries': 3, 'retry_delay': 1.0}
            },
            {
                'tipo': 'tirar_screenshot',
                'nome': 'screenshot_final',
                'config': {'max_retries': 2, 'retry_delay': 1.0}
            },
            {
                'tipo': 'esperar',
                'tempo': 10,
                'config': {'max_retries': 1, 'retry_delay': 0.0}
            },
            {
                'tipo': 'baixar_arquivos_grafico',
                'config': {'max_retries': 1, 'retry_delay': 0.0}
            },
            {
                'tipo': 'verificar_downloads',
                'config': {'max_retries': 1, 'retry_delay': 0.0}
            },
            {
                'tipo': 'esperar',
                'tempo': 20,
                'config': {'max_retries': 1, 'retry_delay': 0.0}
            },
            {
                'tipo': 'fechar',
                'config': {'max_retries': 2, 'retry_delay': 1.0}
            },
            {
                'tipo': 'upload_minio',
                'config': {'max_retries': 1, 'retry_delay': 0.0}
            },
            {
                'tipo': 'matar_firefox',
                'config': {'max_retries': 1, 'retry_delay': 0.0}
            }
        ]

        # Executa a sequência completa
        manager.run_sequence(sequence)
        
    except KeyboardInterrupt:
        logging.info("Processo interrompido pelo usuário")
        kill_firefox_processes()
    except Exception as e:
        logging.error(f"Erro crítico no programa principal: {e}")
        kill_firefox_processes()
    finally:
        # Garante que o Firefox seja fechado mesmo se houver erro
        logging.info("Finalizando programa...")
        kill_firefox_processes()

if __name__ == "__main__":
    main()