gomail.go

package gomail

import (
	"bytes"
	"context"
	"crypto/tls"
	htmlT "html/template"
	"log"
	"sync"
	textT "text/template"

	lib "gopkg.in/gomail.v2"
)

type GoMail struct {
	config        *Config
	htmlTemplate  *htmlT.Template
	plainTemplate *textT.Template
	bufferPool    sync.Pool
}

// SendCloser wraps the gomail.SendCloser for persistent connections
type SendCloser struct {
	sender lib.SendCloser
	gomail *GoMail
}

func New(config *Config) (*GoMail, error) {
	g := &GoMail{
		config: config,
		bufferPool: sync.Pool{
			New: func() interface{} {
				return new(bytes.Buffer)
			},
		},
	}

	err := g.registerTemplate()
	if err != nil {
		return nil, err
	}

	return g, nil
}

// Dial opens a persistent connection to the SMTP server
// The returned SendCloser should be closed when done to release resources
func (g *GoMail) Dial() (*SendCloser, error) {
	dialer, err := g.initializeDialer()
	if err != nil {
		return nil, err
	}

	sender, err := dialer.Dial()
	if err != nil {
		return nil, err
	}

	return &SendCloser{
		sender: sender,
		gomail: g,
	}, nil
}

// Send sends a single email through the persistent connection
func (sc *SendCloser) Send(ctx context.Context, mail *Mail) error {
	message, err := sc.gomail.createMessage(mail)
	if err != nil {
		return err
	}

	return lib.Send(sc.sender, message)
}

// Close closes the persistent connection
func (sc *SendCloser) Close() error {
	return sc.sender.Close()
}

func (g *GoMail) Send(ctx context.Context, mail *Mail) error {
	dialer, err := g.initializeDialer()
	if err != nil {
		return err
	}

	message, err := g.createMessage(mail)
	if err != nil {
		return err
	}

	return dialer.DialAndSend(message)
}

// SendBulk sends multiple emails using a single persistent connection
// This is significantly more efficient than calling Send() multiple times
func (g *GoMail) SendBulk(ctx context.Context, mails []*Mail) error {
	if len(mails) == 0 {
		return nil
	}

	// Open persistent connection
	sender, err := g.Dial()
	if err != nil {
		return err
	}
	defer sender.Close()

	// Send all emails through the same connection
	for _, mail := range mails {
		if err := sender.Send(ctx, mail); err != nil {
			return err
		}
	}

	return nil
}

func (g *GoMail) initializeDialer() (*lib.Dialer, error) {
	dialer := lib.NewDialer(g.config.SMTPHost, g.config.SMTPPort, g.config.SMTPUser, g.config.SMTPPass)
	dialer.LocalName = g.config.SMTPHost

	if g.config.UseTLS {
		dialer.TLSConfig = &tls.Config{ServerName: g.config.SMTPHost, InsecureSkipVerify: true}
	}

	if g.config.UseSSL {
		dialer.SSL = true
		dialer.TLSConfig = &tls.Config{ServerName: g.config.SMTPHost}
	}

	return dialer, nil
}

func (g *GoMail) createMessage(mail *Mail) (*lib.Message, error) {
	message := lib.NewMessage()

	recipients := make([]string, len(mail.To))
	for i, to := range mail.To {
		recipients[i] = message.FormatAddress(to.Email, to.Name)
	}

	ccRecipients := make([]string, len(mail.CC))
	for i, cc := range mail.CC {
		ccRecipients[i] = message.FormatAddress(cc.Email, cc.Name)
	}

	bccRecipients := make([]string, len(mail.BCC))
	for i, bcc := range mail.BCC {
		bccRecipients[i] = message.FormatAddress(bcc.Email, bcc.Name)
	}

	message.SetHeader("From", message.FormatAddress(mail.From.Email, mail.From.Name))
	message.SetHeader("To", recipients...)
	if mail.ReplyTo != nil {
		message.SetHeader("Reply-To", message.FormatAddress(mail.ReplyTo.Email, mail.ReplyTo.Name))
	}
	if len(ccRecipients) > 0 {
		message.SetHeader("Cc", ccRecipients...)
	}
	if len(bccRecipients) > 0 {
		message.SetHeader("Bcc", bccRecipients...)
	}

	message.SetHeader("Subject", mail.Subject)

	html, plain, err := g.resolveTemplate(mail.Template, mail.Data)
	if err != nil {
		return nil, err
	}

	if html != "" {
		message.SetBody("text/html", html)
	}
	if plain != "" {
		if html == "" {
			message.SetBody("text/plain", plain)
		}
		message.AddAlternative("text/plain", plain)
	}

	for _, attachment := range mail.Attachments {
		if attachment.Name != nil {
			message.Attach(attachment.Path, lib.Rename(*attachment.Name))
		} else {
			message.Attach(attachment.Path)
		}
	}

	return message, nil
}

func (g *GoMail) resolveTemplate(template string, data map[string]any) (string, string, error) {
	var html, plain string

	if template == "" {
		return "", "", nil
	}

	// Get buffers from pool
	htmlBuffer := g.bufferPool.Get().(*bytes.Buffer)
	plainBuffer := g.bufferPool.Get().(*bytes.Buffer)
	defer func() {
		htmlBuffer.Reset()
		plainBuffer.Reset()
		g.bufferPool.Put(htmlBuffer)
		g.bufferPool.Put(plainBuffer)
	}()

	err := g.htmlTemplate.ExecuteTemplate(htmlBuffer, template, data)
	if err != nil {
		log.Printf("error when executing html template: %v", err)
	}

	err = g.plainTemplate.ExecuteTemplate(plainBuffer, template, data)
	if err != nil {
		log.Printf("error when executing plain template: %v", err)
	}

	html = htmlBuffer.String()
	plain = plainBuffer.String()

	if html == "" && plain == "" {
		inlineTemplate, err := htmlT.New("inline").Parse(template)
		if err != nil {
			return "", "", err
		}
		plainBuffer.Reset() // Reset before reuse
		err = inlineTemplate.Execute(plainBuffer, data)
		if err != nil {
			return "", "", err
		}
		plain = plainBuffer.String()
	}

	return html, plain, nil
}

func (g *GoMail) registerTemplate() error {
	htmlTemplate, err := parseOptionalHTMLTemplates(g.config.TemplateFS, "**/*.html")
	if err != nil {
		return err
	}

	g.htmlTemplate = htmlTemplate

	plainTemplate, err := parseOptionalTextTemplates(g.config.TemplateFS, "**/*.txt")
	if err != nil {
		return err
	}

	g.plainTemplate = plainTemplate

	return nil
}