import base64
from email.mime.text import MIMEText
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build

def send_email(to, subject, body, credentials_dict):
    creds = Credentials(**credentials_dict)
    service = build('gmail', 'v1', credentials=creds)

    message = MIMEText(body)
    message['to'] = to
    message['subject'] = subject

    raw = base64.urlsafe_b64encode(message.as_bytes()).decode()

    result = service.users().messages().send(
        userId='me',
        body={'raw': raw}
    ).execute()

    print(f"Message sent. ID: {result['id']}")
    return result

# Usage
send_email(
    to='recipient@example.com',
    subject='Hello from Gmail API',
    body='This email was sent via Gmail API send email.',
    credentials_dict={
        'token': 'YOUR_ACCESS_TOKEN',
        'refresh_token': 'YOUR_REFRESH_TOKEN',
        'client_id': 'YOUR_CLIENT_ID',
        'client_secret': 'YOUR_CLIENT_SECRET',
        'token_uri': 'https://oauth2.googleapis.com/token'
    }
)

const { google } = require('googleapis');

async function sendEmail(auth, to, subject, body) {
  const gmail = google.gmail({ version: 'v1', auth });

  const message = [
    `To: ${to}`,
    `Subject: ${subject}`,
    '',
    body
  ].join('\n');

  const encodedMessage = Buffer.from(message)
    .toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '');

  const result = await gmail.users.messages.send({
    userId: 'me',
    requestBody: { raw: encodedMessage }
  });

  console.log(`Message sent. ID: ${result.data.id}`);
  return result.data;
}

// OAuth2 setup
const oauth2Client = new google.auth.OAuth2(
  'YOUR_CLIENT_ID',
  'YOUR_CLIENT_SECRET',
  'YOUR_REDIRECT_URI'
);

oauth2Client.setCredentials({
  access_token: 'YOUR_ACCESS_TOKEN',
  refresh_token: 'YOUR_REFRESH_TOKEN'
});

sendEmail(oauth2Client, 'recipient@example.com', 'Hello', 'Sent via Gmail API send email!');

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import base64

def send_html_email(service, to, subject, html_body):
    message = MIMEMultipart('alternative')
    message['to'] = to
    message['subject'] = subject

    # Plain text fallback
    text_part = MIMEText('Please view this email in an HTML-compatible client.', 'plain')
    # HTML version
    html_part = MIMEText(html_body, 'html')

    message.attach(text_part)
    message.attach(html_part)

    raw = base64.urlsafe_b64encode(message.as_bytes()).decode()

    return service.users().messages().send(
        userId='me',
        body={'raw': raw}
    ).execute()

# Usage
html_content = """

  
    
Hello!
    
This email was sent with Gmail API send email.
 
  

"""
send_html_email(service, 'to@example.com', 'HTML Email via Gmail API', html_content)

import base64
import mimetypes
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders

def send_email_with_attachment(service, to, subject, body, file_path):
    message = MIMEMultipart()
    message['to'] = to
    message['subject'] = subject
    message.attach(MIMEText(body, 'plain'))

    # Detect MIME type and attach file
    content_type, encoding = mimetypes.guess_type(file_path)
    main_type, sub_type = content_type.split('/', 1)

    with open(file_path, 'rb') as f:
        attachment = MIMEBase(main_type, sub_type)
        attachment.set_payload(f.read())
        encoders.encode_base64(attachment)
        attachment.add_header(
            'Content-Disposition',
            f'attachment; filename="{file_path.split("/")[-1]}"'
        )
        message.attach(attachment)

    raw = base64.urlsafe_b64encode(message.as_bytes()).decode()

    return service.users().messages().send(
        userId='me',
        body={'raw': raw}
    ).execute()