package postcard

import (
	"bytes"
	"context"
	"errors"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"testing/fstest"
	"time"

	"git.golem15.com/golem15/summercms/modules/backpack"
	"git.golem15.com/golem15/summercms/modules/compass"
)

func TestMailRenderSmoke(t *testing.T) {
	t.Parallel()

	fsys := fstest.MapFS{
		"views/mail/hello.htm": {Data: []byte(`subject = "Witaj {{ .Name }}"
description = "Hello greeting"
layout = "default"
==
Witaj **{{ .Name }}**.

[Strona]({{ .URL }})
`)},
		"views/mail/hello-en.htm": {Data: []byte(`subject = "Hello {{ .Name }}"
description = "English hello greeting"
layout = "default"
==
Hello **{{ .Name }}**.

[Site]({{ .URL }})
`)},
	}
	cat := NewCatalog()
	err := cat.Register("golem15.hello", fsys, []string{
		"golem15.hello::mail.hello",
		"golem15.hello::mail.hello-en",
	}, nil)
	if err != nil {
		t.Fatalf("Register: %v", err)
	}
	drv := NewMemoryDriver()
	mail := NewMailer(cat, drv, Options{})
	ctx := context.Background()
	vars := map[string]any{"Name": "Ada", "URL": "https://example.test"}

	if err := mail.Send(ctx, Message{
		Template: "golem15.hello::mail.hello",
		To:       []string{"ada@example.test"},
		Vars:     vars,
	}); err != nil {
		t.Fatalf("Send hello: %v", err)
	}
	if err := mail.Send(ctx, Message{
		Template: "golem15.hello::mail.hello-en",
		To:       []string{"ada@example.test"},
		Vars:     vars,
	}); err != nil {
		t.Fatalf("Send hello-en: %v", err)
	}

	got := drv.Messages()
	if len(got) != 2 {
		t.Fatalf("stored %d messages, want 2", len(got))
	}
	pl, en := got[0], got[1]
	if pl.Subject != "Witaj Ada" {
		t.Fatalf("default locale subject = %q", pl.Subject)
	}
	if en.Subject != "Hello Ada" {
		t.Fatalf("-en subject = %q", en.Subject)
	}
	if !strings.Contains(pl.Text, "Witaj **Ada**.") || strings.Contains(pl.Text, "Hello **Ada**.") {
		t.Fatalf("default locale text = %q", pl.Text)
	}
	if !strings.Contains(en.Text, "Hello **Ada**.") || strings.Contains(en.Text, "Witaj **Ada**.") {
		t.Fatalf("-en text = %q", en.Text)
	}
	if !strings.Contains(pl.HTML, "<strong>Ada</strong>") || !strings.Contains(pl.HTML, `href="https://example.test"`) {
		t.Fatalf("default locale HTML = %q", pl.HTML)
	}
	if !strings.Contains(en.HTML, "<strong>Ada</strong>") || !strings.Contains(en.HTML, `href="https://example.test"`) {
		t.Fatalf("-en HTML = %q", en.HTML)
	}
	if !strings.Contains(pl.HTML, `class="content-body"`) || !strings.Contains(en.HTML, `class="content-body"`) {
		t.Fatalf("neutral default layout missing from HTML")
	}

	t.Run("unsafe vars stay out of HTML", func(t *testing.T) {
		drv := NewMemoryDriver()
		mail := NewMailer(cat, drv, Options{})
		if err := mail.Send(ctx, Message{
			Template: "golem15.hello::mail.hello-en",
			To:       []string{"ada@example.test"},
			Vars: map[string]any{
				"Name": `<script>alert(1)</script>`,
				"URL":  "javascript:alert(1)",
			},
		}); err != nil {
			t.Fatalf("Send: %v", err)
		}
		html := drv.Messages()[0].HTML
		if strings.Contains(strings.ToLower(html), "<script") || strings.Contains(strings.ToLower(html), "javascript:") {
			t.Fatalf("unsafe HTML leaked: %s", html)
		}
	})
}

func TestMailLayoutSmoke(t *testing.T) {
	t.Parallel()

	fsys := fstest.MapFS{
		"views/mail/note.htm": {Data: []byte(`subject = "Hi {{ .Name }}"
layout = "hello"
==
Body **{{ .Name }}**.
`)},
		"views/mail/layouts/hello.htm": {Data: []byte(`name = "Hello"
==
-- {{ .Content }} --
==
<div class="layout-hello">{{ .Content }}</div>
<style>{{ .brandCss }}{{ .css }}</style>
`)},
	}
	cat := NewCatalog()
	if err := cat.Register("golem15.hello", fsys, []string{"golem15.hello::mail.note"}, map[string]string{
		"hello": "golem15.hello::mail.layouts.hello",
	}); err != nil {
		t.Fatalf("Register: %v", err)
	}
	drv := NewMemoryDriver()
	mail := NewMailer(cat, drv, Options{CSS: "p{color:red}", BrandCSS: ".brand{color:blue}"})
	if err := mail.Send(context.Background(), Message{
		Template: "golem15.hello::mail.note",
		To:       []string{"ada@example.test"},
		Vars:     map[string]any{"Name": "Ada"},
	}); err != nil {
		t.Fatalf("Send: %v", err)
	}
	got := drv.Messages()
	if len(got) != 1 {
		t.Fatalf("stored %d messages", len(got))
	}
	if !strings.Contains(got[0].Text, "-- Body **Ada**. --") {
		t.Fatalf("text wrapper = %q", got[0].Text)
	}
	if !strings.Contains(got[0].HTML, `class="layout-hello"`) || !strings.Contains(got[0].HTML, "<strong>Ada</strong>") {
		t.Fatalf("HTML wrapper = %q", got[0].HTML)
	}
	if !strings.Contains(got[0].HTML, "p{color:red}") || !strings.Contains(got[0].HTML, ".brand{color:blue}") {
		t.Fatalf("shared css missing: %q", got[0].HTML)
	}

	t.Run("missing template fails with name", func(t *testing.T) {
		err := NewCatalog().Register("golem15.hello", fsys, []string{"golem15.hello::mail.missing"}, nil)
		if err == nil || !strings.Contains(err.Error(), "golem15.hello::mail.missing") {
			t.Fatalf("missing template error = %v", err)
		}
	})
	t.Run("unknown layout fails with name", func(t *testing.T) {
		bad := fstest.MapFS{
			"views/mail/note.htm": {Data: []byte("subject = \"Hi\"\nlayout = \"plytarium\"\n==\nHi.\n")},
		}
		err := NewCatalog().Register("golem15.hello", bad, []string{"golem15.hello::mail.note"}, nil)
		if err == nil || !strings.Contains(err.Error(), "plytarium") {
			t.Fatalf("unknown layout error = %v", err)
		}
	})
	t.Run("missing layout file fails with full name", func(t *testing.T) {
		err := NewCatalog().Register("golem15.hello", fsys, nil, map[string]string{
			"hello": "golem15.hello::mail.layouts.missing",
		})
		if err == nil || !strings.Contains(err.Error(), "golem15.hello::mail.layouts.missing") {
			t.Fatalf("missing layout error = %v", err)
		}
	})
}

func TestMailDriverSmoke(t *testing.T) {
	cat := smokeCatalog(t)
	ctx := context.Background()
	msg := Message{
		Template: "golem15.hello::mail.hello",
		To:       []string{"ada@example.test"},
		Cc:       []string{"cc@example.test"},
		Bcc:      []string{"bcc@example.test"},
		ReplyTo:  "reply@example.test",
		Vars:     map[string]any{"Name": "Ada", "URL": "https://example.test"},
	}

	t.Run("config selects memory log smtp and env override", func(t *testing.T) {
		dir := t.TempDir()
		writeFile(t, filepath.Join(dir, "mail.yaml"), "driver: memory\nfrom: from@example.test\n")
		d, opts, err := driverFromApp(backpack.New(loadMailCfg(t, dir, nil)))
		if err != nil {
			t.Fatal(err)
		}
		if _, ok := d.(*MemoryDriver); !ok || opts.From != "from@example.test" {
			t.Fatalf("memory: %T from=%q", d, opts.From)
		}

		writeFile(t, filepath.Join(dir, "mail.yaml"), "driver: log\nfrom: from@example.test\n")
		d, _, err = driverFromApp(backpack.New(loadMailCfg(t, dir, nil)))
		if err != nil {
			t.Fatal(err)
		}
		if _, ok := d.(*LogDriver); !ok {
			t.Fatalf("log: %T", d)
		}

		writeFile(t, filepath.Join(dir, "mail.yaml"), "driver: smtp\nfrom: from@example.test\nsmtp:\n  host: 127.0.0.1\n  port: 1025\n  tls: none\n")
		d, _, err = driverFromApp(backpack.New(loadMailCfg(t, dir, nil)))
		if err != nil {
			t.Fatal(err)
		}
		if _, ok := d.(*SMTPDriver); !ok {
			t.Fatalf("smtp: %T", d)
		}

		d, _, err = driverFromApp(backpack.New(loadMailCfg(t, dir, []string{"SUMMER_MAIL__DRIVER=log"})))
		if err != nil {
			t.Fatal(err)
		}
		if _, ok := d.(*LogDriver); !ok {
			t.Fatalf("SUMMER_MAIL__DRIVER override: %T", d)
		}

		writeFile(t, filepath.Join(dir, "mail.yaml"), "driver: fax\n")
		_, _, err = driverFromApp(backpack.New(loadMailCfg(t, dir, nil)))
		if err == nil || !strings.Contains(err.Error(), "fax") {
			t.Fatalf("unknown driver error = %v", err)
		}
	})

	t.Run("log driver writes headers and text without credentials", func(t *testing.T) {
		var buf bytes.Buffer
		mail := NewMailer(cat, NewLogDriver(slog.New(slog.NewTextHandler(&buf, nil))), Options{From: "from@example.test"})
		if err := mail.Send(ctx, msg); err != nil {
			t.Fatal(err)
		}
		out := buf.String()
		for _, want := range []string{"from@example.test", "ada@example.test", "Witaj Ada", "Witaj **Ada**."} {
			if !strings.Contains(out, want) {
				t.Fatalf("log missing %q:\n%s", want, out)
			}
		}
		if strings.Contains(out, "password") || strings.Contains(out, "secret") {
			t.Fatalf("log leaked credentials:\n%s", out)
		}
	})

	t.Run("failing driver surfaces error without retry", func(t *testing.T) {
		want := errors.New("driver down")
		fail := &FailDriver{Err: want}
		mail := NewMailer(cat, fail, Options{From: "from@example.test"})
		err := mail.Send(ctx, msg)
		if !errors.Is(err, want) {
			t.Fatalf("Send error = %v", err)
		}
		if fail.sendCount() != 1 {
			t.Fatalf("sends = %d, want 1 (no retry)", fail.sendCount())
		}
	})

	t.Run("unsafe headers and addresses are rejected", func(t *testing.T) {
		drv := NewMemoryDriver()
		mail := NewMailer(cat, drv, Options{From: "from@example.test"})
		err := mail.Send(ctx, Message{
			Template: "golem15.hello::mail.hello",
			To:       []string{"ada@example.test"},
			Subject:  "Hi\r\nBcc: evil@example.test",
			Vars:     map[string]any{"Name": "Ada", "URL": "https://example.test"},
		})
		if err == nil || !strings.Contains(err.Error(), "CR/LF") {
			t.Fatalf("CR/LF error = %v", err)
		}
		err = mail.Send(ctx, Message{
			Template: "golem15.hello::mail.hello",
			To:       []string{"not-an-email"},
			Vars:     map[string]any{"Name": "Ada", "URL": "https://example.test"},
		})
		if err == nil || !strings.Contains(err.Error(), "invalid to address") {
			t.Fatalf("invalid address error = %v", err)
		}
		if len(drv.Messages()) != 0 {
			t.Fatal("rejected messages must not be stored")
		}
	})

	t.Run("smtp constructs a message and propagates errors", func(t *testing.T) {
		gm, err := buildSMTPMessage(RenderedMessage{
			From:    "from@example.test",
			To:      []string{"ada@example.test"},
			Cc:      []string{"cc@example.test"},
			Bcc:     []string{"bcc@example.test"},
			ReplyTo: "reply@example.test",
			Subject: "Hi Ada",
			Text:    "text body",
			HTML:    "<p>html body</p>",
		})
		if err != nil || gm == nil {
			t.Fatalf("buildSMTPMessage: %v", err)
		}
		d, err := NewSMTPDriver(SMTPConfig{
			Host:     "127.0.0.1",
			Port:     1,
			Username: "user",
			Password: "secretpass",
			TLS:      "none",
			Timeout:  80 * time.Millisecond,
		})
		if err != nil {
			t.Fatal(err)
		}
		mail := NewMailer(cat, d, Options{From: "from@example.test"})
		err = mail.Send(ctx, msg)
		if err == nil {
			t.Fatal("expected smtp failure")
		}
		if !strings.Contains(err.Error(), "smtp") {
			t.Fatalf("error %q should mention smtp", err)
		}
		if strings.Contains(err.Error(), "secretpass") || strings.Contains(err.Error(), "text body") {
			t.Fatalf("smtp error leaked secrets or body: %v", err)
		}
		_, err = NewSMTPDriver(SMTPConfig{Host: "127.0.0.1", TLS: "maybe"})
		if err == nil || !strings.Contains(err.Error(), "mail.smtp.tls") {
			t.Fatalf("unknown tls error = %v", err)
		}
		_, err = NewSMTPDriver(SMTPConfig{TLS: "none"})
		if err == nil || !strings.Contains(err.Error(), "mail.smtp.host") {
			t.Fatalf("empty host error = %v", err)
		}
	})
}

func smokeCatalog(t *testing.T) *Catalog {
	t.Helper()
	cat := NewCatalog()
	err := cat.Register("golem15.hello", fstest.MapFS{
		"views/mail/hello.htm": {Data: []byte(`subject = "Witaj {{ .Name }}"
layout = "default"
==
Witaj **{{ .Name }}**.
`)},
	}, []string{"golem15.hello::mail.hello"}, nil)
	if err != nil {
		t.Fatal(err)
	}
	return cat
}

func writeFile(t *testing.T, path, body string) {
	t.Helper()
	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
		t.Fatal(err)
	}
}

func loadMailCfg(t *testing.T, dir string, environ []string) *compass.Config {
	t.Helper()
	if environ == nil {
		environ = []string{}
	}
	cfg, err := compass.Open(compass.Options{Dir: dir, Env: "development", Environ: environ})
	if err != nil {
		t.Fatal(err)
	}
	return cfg
}