SMTP Email Sender with Attachments and HTML Support

package main

import (
	"bytes"
	"crypto/tls"
	"encoding/base64"
	"fmt"
	"io/ioutil"
	"mime/multipart"
	"net/smtp"
	"path/filepath"
	"strings"
)

// EmailConfig contains SMTP server configuration and email details
type EmailConfig struct {
	SMTPHost     string
	SMTPPort     int
	Username     string
	Password     string
	From         string
	To           []string
	CC           []string
	BCC          []string
	Subject      string
	Body         string
	IsHTML       bool
	Attachments  []string
}

// SendEmail sends an email with optional attachments and HTML content
func SendEmail(config EmailConfig) error {
	// Create email headers
	headers := make(map[string]string)
	headers["From"] = config.From
	headers["To"] = strings.Join(config.To, ",")
	if len(config.CC) > 0 {
		headers["Cc"] = strings.Join(config.CC, ",")
	}
	headers["Subject"] = config.Subject
	headers["MIME-Version"] = "1.0"

	// Create multipart writer
	var body bytes.Buffer
	writer := multipart.NewWriter(&body)
	boundary := writer.Boundary()
	headers["Content-Type"] = fmt.Sprintf("multipart/mixed; boundary=\"%s\"", boundary)

	// Write email body
	contentType := "text/plain; charset=utf-8"
	if config.IsHTML {
		contentType = "text/html; charset=utf-8"
	}

	part, err := writer.CreatePart(map[string]string{
		"Content-Type": contentType,
	})
	if err != nil {
		return fmt.Errorf("failed to create body part: %w", err)
	}
	_, err = part.Write([]byte(config.Body))
	if err != nil {
		return fmt.Errorf("failed to write body: %w", err)
	}

	// Add attachments
	for _, file := range config.Attachments {
		if err := addAttachment(writer, file); err != nil {
			return fmt.Errorf("failed to add attachment %s: %w", file, err)
		}
	}

	// Close writer to finalize multipart message
	if err := writer.Close(); err != nil {
		return fmt.Errorf("failed to close writer: %w", err)
	}

	// Combine all recipients
	recipients := append(config.To, config.CC...)
	recipients = append(recipients, config.BCC...)

	// Prepare auth
	auth := smtp.PlainAuth("", config.Username, config.Password, config.SMTPHost)

	// Connect to SMTP server with TLS
	addr := fmt.Sprintf("%s:%d", config.SMTPHost, config.SMTPPort)
	tlsConfig := &tls.Config{
		ServerName: config.SMTPHost,
	}

	conn, err := tls.Dial("tcp", addr, tlsConfig)
	if err != nil {
		return fmt.Errorf("tls dial failed: %w", err)
	}

	client, err := smtp.NewClient(conn, config.SMTPHost)
	if err != nil {
		return fmt.Errorf("smtp client creation failed: %w", err)
	}
	defer client.Close()

	// Authenticate
	if err := client.Auth(auth); err != nil {
		return fmt.Errorf("authentication failed: %w", err)
	}

	// Set sender and recipients
	if err := client.Mail(config.From); err != nil {
		return fmt.Errorf("failed to set sender: %w", err)
	}

	for _, rec := range recipients {
		if err := client.Rcpt(rec); err != nil {
			return fmt.Errorf("failed to set recipient %s: %w", rec, err)
		}
	}

	// Send email body
	writer, err = client.Data()
	if err != nil {
		return fmt.Errorf("failed to get data writer: %w", err)
	}

	// Write headers
	for k, v := range headers {
		_, err := writer.Write([]byte(fmt.Sprintf("%s: %s\r\n", k, v)))
		if err != nil {
			return fmt.Errorf("failed to write header %s: %w", k, err)
		}
	}
	// Write empty line to separate headers from body
	_, err = writer.Write([]byte("\r\n"))
	if err != nil {
		return fmt.Errorf("failed to write header-body separator: %w", err)
	}

	// Write body
	_, err = writer.Write(body.Bytes())
	if err != nil {
		return fmt.Errorf("failed to write email body: %w", err)
	}

	// Close writer to send email
	if err := writer.Close(); err != nil {
		return fmt.Errorf("failed to close data writer: %w", err)
	}

	return client.Quit()
}

// addAttachment adds a file attachment to the email
func addAttachment(writer *multipart.Writer, filePath string) error {
	fileData, err := ioutil.ReadFile(filePath)
	if err != nil {
		return fmt.Errorf("failed to read file: %w", err)
	}

	fileName := filepath.Base(filePath)
	part, err := writer.CreatePart(map[string]string{
		"Content-Type":        "application/octet-stream",
		"Content-Disposition": fmt.Sprintf("attachment; filename=\"%s\"", fileName),
		"Content-Transfer-Encoding": "base64",
	})
	if err != nil {
		return fmt.Errorf("failed to create attachment part: %w", err)
	}

	encoder := base64.NewEncoder(base64.StdEncoding, part)
	defer encoder.Close()

	_, err = encoder.Write(fileData)
	if err != nil {
		return fmt.Errorf("failed to encode attachment: %w", err)
	}

	return nil
}

func main() {
	config := EmailConfig{
		SMTPHost:    "smtp.gmail.com",
		SMTPPort:    465,
		Username:    "[email protected]",
		Password:    "your-app-password",
		From:        "[email protected]",
		To:          []string{"[email protected]"},
		CC:          []string{"[email protected]"},
		Subject:     "Test Email with Attachment",
		Body:        "<h1>Hello!</h1><p>This is an HTML email with attachment.</p>",
		IsHTML:      true,
		Attachments: []string{"document.pdf"},
	}

	if err := SendEmail(config); err != nil {
		fmt.Printf("Failed to send email: %v\n", err)
	} else {
		fmt.Println("Email sent successfully!")
	}
}