Automação Inteligente - Sistemas que Trabalham Sozinhos

import schedule
import time
import pandas as pd
import smtplib
from email.mime.text import MimeText
from email.mime.multipart import MimeMultipart
import requests
from datetime import datetime, timedelta
import json
import os
from transformers import pipeline
import sqlite3

class IntelligentAutomationSystem:
    def __init__(self):
        """Sistema completo de automação inteligente"""
        print("🤖 Inicializando Sistema de Automação Inteligente...")
        
        # Configurar banco de dados
        self.setup_database()
        
        # Carregar modelos de IA
        self.load_ai_models()
        
        # Configurações de email
        self.email_config = {
            'smtp_server': 'smtp.gmail.com',
            'smtp_port': 587,
            'email': 'seu_email@gmail.com',
            'password': 'sua_senha_app'  # Use senha de aplicativo
        }
        
        print("✅ Sistema inicializado!")
    
    def setup_database(self):
        """Configura banco de dados SQLite"""
        self.conn = sqlite3.connect('automation_data.db', check_same_thread=False)
        cursor = self.conn.cursor()
        
        # Tabela para logs de automação
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS automation_logs (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                task_name TEXT,
                status TEXT,
                details TEXT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        # Tabela para dados processados
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS processed_data (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                source TEXT,
                data TEXT,
                analysis TEXT,
                processed_at DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        self.conn.commit()
        print("📊 Banco de dados configurado")
    
    def load_ai_models(self):
        """Carrega modelos de IA para processamento"""
        try:
            self.sentiment_analyzer = pipeline("sentiment-analysis")
            self.summarizer = pipeline("summarization")
            print("🧠 Modelos de IA carregados")
        except Exception as e:
            print(f"⚠️ Erro ao carregar modelos: {e}")
            self.sentiment_analyzer = None
            self.summarizer = None
    
    def log_automation_task(self, task_name, status, details=""):
        """Registra tarefa de automação no log"""
        cursor = self.conn.cursor()
        cursor.execute(
            "INSERT INTO automation_logs (task_name, status, details) VALUES (?, ?, ?)",
            (task_name, status, details)
        )
        self.conn.commit()
    
    def automated_data_collection(self):
        """Coleta dados automaticamente de várias fontes"""
        print("📥 Iniciando coleta automática de dados...")
        self.log_automation_task("data_collection", "started")
        
        try:
            # Exemplo: Coletar dados de API pública (substitua por suas fontes)
            api_data = self.collect_api_data()
            file_data = self.process_files_automatically()
            web_data = self.scrape_web_content()
            
            collected_data = {
                'api_data': api_data,
                'file_data': file_data,
                'web_data': web_data,
                'collection_time': datetime.now().isoformat()
            }
            
            # Salvar dados coletados
            self.save_collected_data(collected_data)
            
            self.log_automation_task("data_collection", "completed", 
                                   f"Coletados {len(collected_data)} fontes")
            print("✅ Coleta de dados concluída")
            
            return collected_data
            
        except Exception as e:
            self.log_automation_task("data_collection", "failed", str(e))
            print(f"❌ Erro na coleta: {e}")
            return None
    
    def collect_api_data(self):
        """Coleta dados de APIs externas"""
        try:
            # Exemplo com API de notícias (substitua pela sua API)
            # response = requests.get("https://api.exemplo.com/data")
            # return response.json()
            
            # Dados simulados para demonstração
            return {
                'news': [
                    {'title': 'IA revoluciona mercado', 'sentiment': 'positive'},
                    {'title': 'Empresa lança novo produto', 'sentiment': 'neutral'}
                ],
                'collected_at': datetime.now().isoformat()
            }
        except Exception as e:
            print(f"⚠️ Erro na API: {e}")
            return {}
    
    def process_files_automatically(self):
        """Processa novos arquivos automaticamente"""
        try:
            # Verificar pasta de entrada
            input_folder = "./input_files"
            if not os.path.exists(input_folder):
                os.makedirs(input_folder)
                return {}
            
            processed_files = []
            
            for filename in os.listdir(input_folder):
                if filename.endswith(('.txt', '.csv', '.json')):
                    file_path = os.path.join(input_folder, filename)
                    
                    # Processar baseado no tipo de arquivo
                    if filename.endswith('.csv'):
                        data = pd.read_csv(file_path)
                        analysis = self.analyze_csv_data(data)
                    elif filename.endswith('.txt'):
                        with open(file_path, 'r', encoding='utf-8') as f:
                            content = f.read()
                        analysis = self.analyze_text_content(content)
                    else:
                        analysis = {'status': 'processed'}
                    
                    processed_files.append({
                        'filename': filename,
                        'analysis': analysis
                    })
                    
                    # Mover arquivo para pasta processada
                    processed_folder = "./processed_files"
                    os.makedirs(processed_folder, exist_ok=True)
                    os.rename(file_path, os.path.join(processed_folder, filename))
            
            return {'processed_files': processed_files}
            
        except Exception as e:
            print(f"⚠️ Erro no processamento de arquivos: {e}")
            return {}
    
    def analyze_csv_data(self, data):
        """Analisa dados de CSV automaticamente"""
        analysis = {
            'rows': len(data),
            'columns': len(data.columns),
            'column_names': list(data.columns),
            'summary_stats': data.describe().to_dict() if len(data) > 0 else {},
            'insights': []
        }
        
        # Insights automáticos básicos
        if 'price' in data.columns or 'valor' in data.columns:
            analysis['insights'].append("Dados financeiros detectados")
        
        if 'date' in data.columns or 'data' in data.columns:
            analysis['insights'].append("Série temporal detectada")
        
        return analysis
    
    def analyze_text_content(self, text):
        """Analisa conteúdo de texto com IA"""
        analysis = {
            'word_count': len(text.split()),
            'character_count': len(text)
        }
        
        try:
            if self.sentiment_analyzer:
                sentiment = self.sentiment_analyzer(text[:512])  # Limitar tamanho
                analysis['sentiment'] = sentiment[0]
            
            if self.summarizer and len(text) > 100:
                summary = self.summarizer(text[:1024], max_length=50, min_length=10)
                analysis['summary'] = summary[0]['summary_text']
        
        except Exception as e:
            print(f"⚠️ Erro na análise de texto: {e}")
        
        return analysis
    
    def scrape_web_content(self):
        """Coleta conteúdo da web (exemplo básico)"""
        # Em produção, use bibliotecas como Scrapy ou Selenium
        # Aqui é apenas um exemplo conceitual
        return {
            'scraped_pages': 0,
            'status': 'simulated',
            'note': 'Implemente com Scrapy para uso real'
        }
    
    def intelligent_decision_making(self, data):
        """Toma decisões inteligentes baseadas nos dados"""
        print("🧠 Processando decisões inteligentes...")
        
        decisions = {
            'timestamp': datetime.now().isoformat(),
            'actions_to_take': [],
            'alerts': [],
            'recommendations': []
        }
        
        # Regras de negócio automatizadas
        if data and 'api_data' in data:
            news_data = data['api_data'].get('news', [])
            positive_news = sum(1 for news in news_data if news.get('sentiment') == 'positive')
            
            if positive_news > len(news_data) / 2:
                decisions['actions_to_take'].append("Aumentar investimento em marketing")
                decisions['recommendations'].append("Tendência positiva no mercado detectada")
        
        # Análise de arquivos processados
        if data and 'file_data' in data:
            processed_files = data['file_data'].get('processed_files', [])
            if len(processed_files) > 5:
                decisions['alerts'].append("Volume alto de arquivos para processamento")
        
        # Decisões baseadas em horário
        current_hour = datetime.now().hour
        if current_hour >= 18:  # Após 18h
            decisions['actions_to_take'].append("Gerar relatório diário")
        
        self.log_automation_task("decision_making", "completed", 
                               f"{len(decisions['actions_to_take'])} ações identificadas")
        
        return decisions
    
    def execute_automated_actions(self, decisions):
        """Executa ações automaticamente baseadas nas decisões"""
        print("⚡ Executando ações automatizadas...")
        
        executed_actions = []
        
        for action in decisions.get('actions_to_take', []):
            try:
                if "relatório" in action.lower():
                    report = self.generate_automated_report()
                    executed_actions.append({
                        'action': action,
                        'status': 'success',
                        'result': 'Relatório gerado'
                    })
                
                elif "email" in action.lower() or "alert" in action.lower():
                    email_sent = self.send_automated_email(
                        subject="Alerta do Sistema de Automação",
                        body=f"Ação executada: {action}"
                    )
                    executed_actions.append({
                        'action': action,
                        'status': 'success' if email_sent else 'failed',
                        'result': 'Email enviado' if email_sent else 'Erro no email'
                    })
                
                else:
                    # Ação genérica
                    executed_actions.append({
                        'action': action,
                        'status': 'logged',
                        'result': 'Ação registrada para execução manual'
                    })
                
            except Exception as e:
                executed_actions.append({
                    'action': action,
                    'status': 'failed',
                    'error': str(e)
                })
        
        self.log_automation_task("action_execution", "completed",
                               f"{len(executed_actions)} ações processadas")
        
        return executed_actions
    
    def generate_automated_report(self):
        """Gera relatório automatizado"""
        print("📊 Gerando relatório automático...")
        
        # Buscar dados dos logs
        cursor = self.conn.cursor()
        cursor.execute("""
            SELECT task_name, COUNT(*) as count, status
            FROM automation_logs 
            WHERE DATE(timestamp) = DATE('now')
            GROUP BY task_name, status
        """)
        
        task_summary = cursor.fetchall()
        
        report = {
            'report_date': datetime.now().date().isoformat(),
            'generation_time': datetime.now().isoformat(),
            'task_summary': [
                {'task': task[0], 'count': task[1], 'status': task[2]} 
                for task in task_summary
            ],
            'total_tasks': sum(task[1] for task in task_summary),
            'successful_tasks': sum(task[1] for task in task_summary if task[2] == 'completed')
        }
        
        # Salvar relatório
        report_filename = f"daily_report_{datetime.now().strftime('%Y%m%d')}.json"
        with open(report_filename, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        
        print(f"📄 Relatório salvo: {report_filename}")
        return report
    
    def send_automated_email(self, subject, body, recipients=None):
        """Envia emails automaticamente"""
        if not recipients:
            recipients = ['admin@empresa.com']  # Configure destinatários
        
        try:
            msg = MimeMultipart()
            msg['From'] = self.email_config['email']
            msg['To'] = ', '.join(recipients)
            msg['Subject'] = subject
            
            msg.attach(MimeText(body, 'plain'))
            
            server = smtplib.SMTP(self.email_config['smtp_server'], self.email_config['smtp_port'])
            server.starttls()
            server.login(self.email_config['email'], self.email_config['password'])
            
            text = msg.as_string()
            server.sendmail(self.email_config['email'], recipients, text)
            server.quit()
            
            print(f"📧 Email enviado para {recipients}")
            return True
            
        except Exception as e:
            print(f"❌ Erro ao enviar email: {e}")
            return False
    
    def full_automation_cycle(self):
        """Executa ciclo completo de automação"""
        print(f"\n{'='*60}")
        print(f"🔄 INICIANDO CICLO DE AUTOMAÇÃO - {datetime.now()}")
        print(f"{'='*60}")
        
        try:
            # 1. Coleta de dados
            collected_data = self.automated_data_collection()
            
            # 2. Tomada de decisões
            if collected_data:
                decisions = self.intelligent_decision_making(collected_data)
                
                # 3. Execução de ações
                executed_actions = self.execute_automated_actions(decisions)
                
                # 4. Log do ciclo completo
                cycle_result = {
                    'cycle_time': datetime.now().isoformat(),
                    'data_sources': len(collected_data) if collected_data else 0,
                    'decisions_made': len(decisions.get('actions_to_take', [])),
                    'actions_executed': len(executed_actions)
                }
                
                self.log_automation_task("full_cycle", "completed", json.dumps(cycle_result))
                
                print("✅ Ciclo de automação concluído com sucesso!")
                return cycle_result
            
            else:
                print("⚠️ Nenhum dado coletado, ciclo interrompido")
                return None
                
        except Exception as e:
            self.log_automation_task("full_cycle", "failed", str(e))
            print(f"❌ Erro no ciclo de automação: {e}")
            return None
    
    def schedule_automation_tasks(self):
        """Agenda tarefas de automação"""
        print("📅 Configurando agendamento de tarefas...")
        
        # Ciclo completo a cada hora
        schedule.every().hour.do(self.full_automation_cycle)
        
        # Relatório diário às 18h
        schedule.every().day.at("18:00").do(self.generate_automated_report)
        
        # Backup do banco de dados à meia-noite
        schedule.every().day.at("00:00").do(self.backup_database)
        
        print("✅ Tarefas agendadas:")
        print("- Automação completa: A cada hora")
        print("- Relatório diário: 18:00")
        print("- Backup: 00:00")
    
    def backup_database(self):
        """Faz backup do banco de dados"""
        try:
            backup_filename = f"backup_automation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db"
            
            # Cópia simples do arquivo SQLite
            import shutil
            shutil.copy2('automation_data.db', backup_filename)
            
            print(f"💾 Backup criado: {backup_filename}")
            self.log_automation_task("database_backup", "completed", backup_filename)
            
        except Exception as e:
            print(f"❌ Erro no backup: {e}")
            self.log_automation_task("database_backup", "failed", str(e))
    
    def start_automation_system(self):
        """Inicia sistema de automação"""
        print("🚀 INICIANDO SISTEMA DE AUTOMAÇÃO INTELIGENTE")
        print("="*60)
        
        # Configurar agendamentos
        self.schedule_automation_tasks()
        
        # Executar primeiro ciclo imediatamente
        print("⚡ Executando primeiro ciclo...")
        self.full_automation_cycle()
        
        # Loop principal
        print("\n🔄 Sistema em execução. Pressione Ctrl+C para parar.")
        try:
            while True:
                schedule.run_pending()
                time.sleep(60)  # Verificar a cada minuto
                
        except KeyboardInterrupt:
            print("\n🛑 Sistema de automação interrompido pelo usuário")
            self.conn.close()
    
    def get_automation_dashboard(self):
        """Retorna dados para dashboard de monitoramento"""
        cursor = self.conn.cursor()
        
        # Estatísticas gerais
        cursor.execute("SELECT COUNT(*) FROM automation_logs")
        total_tasks = cursor.fetchone()[0]
        
        cursor.execute("SELECT COUNT(*) FROM automation_logs WHERE status = 'completed'")
        successful_tasks = cursor.fetchone()[0]
        
        cursor.execute("SELECT COUNT(*) FROM automation_logs WHERE DATE(timestamp) = DATE('now')")
        today_tasks = cursor.fetchone()[0]
        
        # Últimas 10 execuções
        cursor.execute("""
            SELECT task_name, status, timestamp, details 
            FROM automation_logs 
            ORDER BY timestamp DESC 
            LIMIT 10
        """)
        recent_tasks = cursor.fetchall()
        
        dashboard_data = {
            'total_tasks': total_tasks,
            'successful_tasks': successful_tasks,
            'success_rate': f"{(successful_tasks/total_tasks*100):.1f}%" if total_tasks > 0 else "0%",
            'today_tasks': today_tasks,
            'recent_executions': [
                {
                    'task': task[0],
                    'status': task[1],
                    'time': task[2],
                    'details': task[3]
                } for task in recent_tasks
            ]
        }
        
        return dashboard_data

# Exemplo de uso
if __name__ == "__main__":
    # Criar sistema de automação
    automation_system = IntelligentAutomationSystem()
    
    # Para executar um ciclo único (teste)
    print("🧪 MODO TESTE - Executando um ciclo único")
    result = automation_system.full_automation_cycle()
    
    if result:
        print(f"\n📊 RESULTADO DO TESTE:")
        print(f"- Fontes de dados: {result['data_sources']}")
        print(f"- Decisões tomadas: {result['decisions_made']}")
        print(f"- Ações executadas: {result['actions_executed']}")
    
    # Ver dashboard
    dashboard = automation_system.get_automation_dashboard()
    print(f"\n📈 DASHBOARD:")
    print(f"- Total de tarefas: {dashboard['total_tasks']}")
    print(f"- Taxa de sucesso: {dashboard['success_rate']}")
    print(f"- Tarefas hoje: {dashboard['today_tasks']}")
    
    # Para iniciar sistema completo (descomente):
    # automation_system.start_automation_system()
    
    print("\n🎉 Sistema de Automação Inteligente configurado!")
    print("💡 Para produção: Configure APIs, emails e execute start_automation_system()")