#!/usr/bin/env python3
"""
Gmail API Backend for NewsletterMaker
Handles OAuth2 authentication and email sending
"""

from flask import Flask, request, jsonify, redirect, session
from flask_cors import CORS
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import Flow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import base64
import os
import json
from datetime import datetime

app = Flask(__name__)
app.secret_key = os.urandom(24)  # Random secret key
CORS(app)  # Enable CORS for iOS app

# Gmail API scopes
SCOPES = ['https://www.googleapis.com/auth/gmail.send']

# OAuth2 configuration
CLIENT_CONFIG = {
    "web": {
        "client_id": "YOUR_CLIENT_ID.apps.googleusercontent.com",
        "client_secret": "YOUR_CLIENT_SECRET",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "redirect_uris": ["http://localhost:5060/auth/callback"]
    }
}

# In-memory token storage (replace with database in production)
user_credentials = {}


@app.route('/health', methods=['GET'])
def health():
    """Health check endpoint"""
    return jsonify({
        "status": "ok",
        "service": "NewsletterMaker Gmail Backend",
        "version": "1.0.0",
        "timestamp": datetime.now().isoformat()
    })


@app.route('/auth/start', methods=['POST'])
def auth_start():
    """
    Start OAuth2 flow
    Expected: {"user_id": "unique_user_id"}
    Returns: {"auth_url": "https://accounts.google.com/..."}
    """
    try:
        data = request.get_json()
        user_id = data.get('user_id', 'default_user')

        # Create OAuth2 flow
        flow = Flow.from_client_config(
            CLIENT_CONFIG,
            scopes=SCOPES,
            redirect_uri='http://localhost:5060/auth/callback'
        )

        authorization_url, state = flow.authorization_url(
            access_type='offline',
            include_granted_scopes='true',
            prompt='consent'
        )

        # Store state for verification
        session['oauth_state'] = state
        session['user_id'] = user_id

        return jsonify({
            "success": True,
            "auth_url": authorization_url,
            "state": state
        })

    except Exception as e:
        return jsonify({
            "success": False,
            "error": str(e)
        }), 400


@app.route('/auth/callback', methods=['GET'])
def auth_callback():
    """OAuth2 callback endpoint"""
    try:
        state = session.get('oauth_state')
        user_id = session.get('user_id', 'default_user')

        flow = Flow.from_client_config(
            CLIENT_CONFIG,
            scopes=SCOPES,
            state=state,
            redirect_uri='http://localhost:5060/auth/callback'
        )

        # Exchange authorization code for credentials
        flow.fetch_token(authorization_response=request.url)

        credentials = flow.credentials

        # Store credentials
        user_credentials[user_id] = {
            'token': credentials.token,
            'refresh_token': credentials.refresh_token,
            'token_uri': credentials.token_uri,
            'client_id': credentials.client_id,
            'client_secret': credentials.client_secret,
            'scopes': credentials.scopes
        }

        return """
        <html>
            <body>
                <h1>✅ Gmail autenticado com sucesso!</h1>
                <p>Você pode fechar esta janela e voltar ao app.</p>
                <script>
                    // Notify iOS app via custom URL scheme
                    window.location.href = "newslettermaker://auth/success";
                </script>
            </body>
        </html>
        """

    except Exception as e:
        return f"""
        <html>
            <body>
                <h1>❌ Erro na autenticação</h1>
                <p>{str(e)}</p>
            </body>
        </html>
        """, 400


@app.route('/auth/status', methods=['POST'])
def auth_status():
    """
    Check authentication status
    Expected: {"user_id": "unique_user_id"}
    """
    try:
        data = request.get_json()
        user_id = data.get('user_id', 'default_user')

        is_authenticated = user_id in user_credentials

        return jsonify({
            "success": True,
            "authenticated": is_authenticated,
            "user_id": user_id
        })

    except Exception as e:
        return jsonify({
            "success": False,
            "error": str(e)
        }), 400


@app.route('/send-email', methods=['POST'])
def send_email():
    """
    Send email via Gmail API
    Expected JSON:
    {
        "user_id": "unique_user_id",
        "to": ["email1@example.com", "email2@example.com"],
        "subject": "Newsletter Subject",
        "html_body": "<html>...</html>",
        "from_name": "Neog"
    }
    """
    try:
        data = request.get_json()
        user_id = data.get('user_id', 'default_user')

        # Check if user is authenticated
        if user_id not in user_credentials:
            return jsonify({
                "success": False,
                "error": "User not authenticated. Please authenticate first."
            }), 401

        # Get credentials
        creds_data = user_credentials[user_id]
        credentials = Credentials(
            token=creds_data['token'],
            refresh_token=creds_data['refresh_token'],
            token_uri=creds_data['token_uri'],
            client_id=creds_data['client_id'],
            client_secret=creds_data['client_secret'],
            scopes=creds_data['scopes']
        )

        # Build Gmail service
        service = build('gmail', 'v1', credentials=credentials)

        # Extract email data
        recipients = data.get('to', [])
        subject = data.get('subject', 'Newsletter')
        html_body = data.get('html_body', '')
        from_name = data.get('from_name', 'NewsletterMaker')

        results = []
        errors = []

        # Send to each recipient
        for recipient in recipients:
            try:
                # Create message
                message = MIMEMultipart('alternative')
                message['To'] = recipient
                message['Subject'] = subject
                message['From'] = from_name

                # Add HTML body
                html_part = MIMEText(html_body, 'html')
                message.attach(html_part)

                # Encode message
                encoded_message = base64.urlsafe_b64encode(message.as_bytes()).decode()

                # Send message
                send_result = service.users().messages().send(
                    userId='me',
                    body={'raw': encoded_message}
                ).execute()

                results.append({
                    "recipient": recipient,
                    "status": "sent",
                    "message_id": send_result['id']
                })

            except HttpError as error:
                errors.append({
                    "recipient": recipient,
                    "status": "failed",
                    "error": str(error)
                })

        return jsonify({
            "success": len(errors) == 0,
            "sent_count": len(results),
            "failed_count": len(errors),
            "results": results,
            "errors": errors
        })

    except Exception as e:
        return jsonify({
            "success": False,
            "error": str(e)
        }), 500


@app.route('/test', methods=['GET'])
def test():
    """Test endpoint"""
    return jsonify({
        "message": "Gmail API Backend is running!",
        "endpoints": {
            "health": "/health",
            "auth_start": "/auth/start (POST)",
            "auth_callback": "/auth/callback (GET)",
            "auth_status": "/auth/status (POST)",
            "send_email": "/send-email (POST)"
        }
    })


if __name__ == '__main__':
    print("🚀 Gmail API Backend starting...")
    print("📧 Endpoints:")
    print("   - Health: http://localhost:5060/health")
    print("   - Auth Start: http://localhost:5060/auth/start")
    print("   - Send Email: http://localhost:5060/send-email")
    print("")
    print("⚠️  IMPORTANTE: Configure CLIENT_ID e CLIENT_SECRET no código!")
    print("")

    app.run(
        host='0.0.0.0',  # Listen on all interfaces (Tailscale)
        port=5060,
        debug=True
    )
