import os
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
import base64
import re

# Configurar OAuth 2.0 (scope: https://www.googleapis.com/auth/gmail.modify)
SCOPES = ['https://www.googleapis.com/auth/gmail.modify']

def get_gmail_service():
    creds = None
    if os.path.exists('token.json'):
        creds = Credentials.from_authorized_user_file('token.json', SCOPES)
    if not creds or not creds.valid:
        flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)
        creds = flow.run_local_server(port=0)
        with open('token.json', 'w') as token:
            token.write(creds.to_json())
    return build('gmail', 'v1', credentials=creds)

def categorize_and_auto_reply():
    service = get_gmail_service()
    results = service.users().messages().list(userId='me', labelIds=['INBOX'], maxResults=20).execute()
    messages = results.get('messages', [])
    for msg in messages:
        msg_data = service.users().messages().get(userId='me', id=msg['id']).execute()
        payload = msg_data['payload']
        headers = payload['headers']
        subject = next(h['value'] for h in headers if h['name'] == 'Subject')
        # IA simple basada en palabras clave (en producción usarías GPT-4)
        if 'urgente' in subject.lower():
            reply = "Gracias por su mensaje urgente. Lo revisaré en las próximas 2 horas."
            send_reply(service, msg['id'], reply)
            service.users().messages().modify(userId='me', id=msg['id'], body={'addLabelIds': ['IMPORTANT']}).execute()
        elif 'newsletter' in subject.lower():
            service.users().messages().modify(userId='me', id=msg['id'], body={'removeLabelIds': ['INBOX']}).execute()

# Tiempo ahorrado: ~30 minutos diarios

import json
import requests
import pandas as pd

# Integración con API de OpenAI para generación de recetas
def generate_meal_plan(ingredients, diet='balanced'):
    prompt = f"""
    Dado estos ingredientes: {', '.join(ingredients)}.
    Genera un plan de comidas para 7 días (desayuno, almuerzo, cena) que sea {diet}.
    Incluye:
    1. Nombre del plato
    2. Ingredientes adicionales necesarios
    3. Tiempo de preparación
    4. Valor nutricional aproximado
    """
    # Llamada a OpenAI GPT-4 (simplificada)
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7
    )
    return response.choices[0].message.content

# Automatización de lista de compras con Make (ex-Integromat)
def create_shopping_list(meal_plan):
    # Conectar con Google Sheets vía API
    items = extract_items_from_meal_plan(meal_plan)
    df = pd.DataFrame(items, columns=['Item', 'Cantidad', 'Prioridad'])
    df.to_csv('shopping_list.csv', index=False)
    # Subir a Google Drive y compartir con familia
    upload_to_google_drive('shopping_list.csv', 'meal_planning')
    
# Tiempo ahorrado: 2.5 horas semanales

import plaid
from plaid.api import plaid_api
from datetime import datetime, timedelta
import plotly.graph_objects as go

# Configurar cliente Plaid (conexión a bancos)
configuration = plaid.Configuration(
    host=plaid.Environment.Development,
    api_key={'clientId': 'CLIENT_ID', 'secret': 'SECRET'}
)
api_client = plaid.ApiClient(configuration)
client = plaid_api.PlaidApi(api_client)

# Obtener transacciones de los últimos 30 días
response = client.transactions_get(
    access_token='ACCESS_TOKEN',
    start_date=(datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d'),
    end_date=datetime.now().strftime('%Y-%m-%d'),
    options={'count': 500}
)

# Categorizar usando IA (scikit-learn o similar)
transactions = pd.DataFrame([t.to_dict() for t in response.transactions])
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans

vectorizer = TfidfVectorizer(stop_words='english')
X = vectorizer.fit_transform(transactions['name'])
kmeans = KMeans(n_clusters=8, random_state=42)
transactions['category'] = kmeans.fit_predict(X)

# Generar dashboard interactivo
fig = go.Figure(data=[go.Pie(labels=transactions['category'].unique(), 
                             values=transactions.groupby('category')['amount'].sum())])
fig.write_html('financial_dashboard.html')

# Tiempo ahorrado: 5 horas mensuales

# Makefile para proyecto Python/Data Science
.PHONY: help test clean deploy

help:
	@echo "Comandos disponibles:"
	@echo "  make setup      - Instala dependencias y configura entorno"
	@echo "  make test       - Ejecuta tests unitarios e integración"
	@echo "  make lint       - Análisis estático con ruff y mypy"
	@echo "  make deploy     - Despliega a producción (con confirmación)"
	@echo "  make monitor    - Monitorea rendimiento y logs"

setup:
	python -m venv venv
	./venv/bin/pip install -r requirements.txt
	./venv/bin/pre-commit install

test:
	./venv/bin/pytest -v --cov=src --cov-report=html
	# IA: Analiza cobertura y sugiere tests faltantes
	python scripts/suggest_tests.py --coverage-file=htmlcov/index.html

lint:
	./venv/bin/ruff check src/
	./venv/bin/mypy src/
	# IA: Corrige automáticamente errores simples
	./venv/bin/ruff check --fix src/

deploy:
	@read -p "¿Desplegar a producción? (yes/no): " confirm; \
	if [ "$$confirm" = "yes" ]; then \
		./venv/bin/python deploy.py --env=prod; \
	else \
		echo "Despliegue cancelado"; \
	fi

# Tiempo ahorrado: 8 horas semanales

from sumy.parsers.plaintext import PlaintextParser
from sumy.nlp.tokenizers import Tokenizer
from sumy.summarizers.lsa import LsaSummarizer
import feedparser
import smtplib
from email.mime.text import MIMEText

def fetch_and_summarize(feed_urls, max_items=10):
    summaries = []
    for url in feed_urls:
        feed = feedparser.parse(url)
        for entry in feed.entries[:max_items]:
            parser = PlaintextParser.from_string(entry.description, Tokenizer("spanish"))
            summarizer = LsaSummarizer()
            summary = summarizer(parser.document, 3)  # 3 oraciones
            summaries.append({
                'title': entry.title,
                'summary': ' '.join(str(s) for s in summary),
                'link': entry.link
            })
    return summaries

# Integración con ChatGPT para análisis de sentimiento
def analyze_sentiment(summaries):
    import openai
    prompt = f"Clasifica el sentimiento de estas noticias: {summaries}"
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )
    return response.choices[0].message.content

# Enviar resumen diario por email
def send_daily_brief(summaries):
    # Implementar envío SMTP o via API de SendGrid
    pass

# Tiempo ahorrado: 45 minutos diarios