// Package email sends templated transactional email. It is a provider-shaped
// package like platform and the database engines: one Emailer interface, a Base that renders
// templates from an embedded filesystem, and concrete senders (Congo, Resend,
// Logger) behind it. It has no dependency on application — an app wires an Emailer
// into whichever controller needs it, rather than the MVC core carrying email.
package email

import (
	"bytes"
	"embed"
	"errors"
	"fmt"
	"html/template"
	"io/fs"
	"log"
	"path/filepath"
	"strings"
)

// Emailer sends a templated email.
type Emailer interface {
	Send(to, subject, templateName string, data map[string]any) error
}

// Base provides template rendering for emailer implementations. Embed it and call
// Init from the constructor.
type Base struct {
	emails *template.Template
}

// Init parses the email templates under the "emails" directory of the embedded
// filesystem, with an optional FuncMap.
func (b *Base) Init(emails embed.FS, funcs template.FuncMap) {
	b.emails = template.New("")
	if funcs != nil {
		b.emails = b.emails.Funcs(funcs)
	}
	err := fs.WalkDir(emails, "emails", func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if d.IsDir() || !strings.HasSuffix(path, ".html") {
			return nil
		}
		content, err := emails.ReadFile(path)
		if err != nil {
			return err
		}
		_, err = b.emails.New(filepath.Base(path)).Parse(string(content))
		return err
	})
	if err != nil {
		log.Printf("Warning: failed to parse email templates: %v", err)
		b.emails = template.New("")
	}
}

// Render executes a named email template to a string.
func (b *Base) Render(name string, data map[string]any) (string, error) {
	if b.emails == nil {
		return "", errors.New("email templates not initialized")
	}
	var buf bytes.Buffer
	if err := b.emails.ExecuteTemplate(&buf, name, data); err != nil {
		return "", fmt.Errorf("execute template %s: %w", name, err)
	}
	return buf.String(), nil
}