package mailx_test

import (
	"context"
	"errors"
	"fmt"
	"strings"
	"sync"
	"testing"

	mailx "code.yun.ink/pkg/mailx"
)

func TestNewManagerEmpty(t *testing.T) {
	m := mailx.NewManager()
	if _, err := m.Sender(""); err == nil {
		t.Fatal("Sender() on empty manager should error")
	}
	if err := m.Send(context.Background(), mailx.NewMessage().To("a@b.com").Subject("s").Build()); err == nil {
		t.Fatal("Send() on empty manager should error")
	}
}

func TestRegisterSetsDefault(t *testing.T) {
	m := mailx.NewManager()
	if err := m.Register(newMockSender("a")); err != nil {
		t.Fatal(err)
	}
	if err := m.Register(newMockSender("b")); err != nil {
		t.Fatal(err)
	}
	s, err := m.Sender("")
	if err != nil {
		t.Fatal(err)
	}
	if s.Name() != "a" {
		t.Errorf("default sender = %q, want a", s.Name())
	}
}

func TestRegisterDuplicate(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("a"))
	err := m.Register(newMockSender("a"))
	if err == nil || !strings.Contains(err.Error(), "already registered") {
		t.Fatalf("err = %v, want already registered", err)
	}
}

func TestRegisterNil(t *testing.T) {
	m := mailx.NewManager()
	if err := m.Register(nil); err == nil {
		t.Fatal("Register(nil) should error")
	}
}

func TestRegisterEmptyName(t *testing.T) {
	m := mailx.NewManager()
	if err := m.Register(newMockSender("")); err == nil {
		t.Fatal("Register(empty name) should error")
	}
}

func TestUnregister(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("a"))
	_ = m.Register(newMockSender("b"))

	m.Unregister("a")
	s, err := m.Sender("")
	if err != nil {
		t.Fatal(err)
	}
	if s.Name() != "b" {
		t.Errorf("fallback default = %q, want b", s.Name())
	}

	// 注销最后一个后不再有默认通道
	m.Unregister("b")
	if _, err := m.Sender(""); err == nil {
		t.Fatal("expected error after unregistering all senders")
	}
}

func TestSetDefault(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("a"))
	_ = m.Register(newMockSender("b"))

	if err := m.SetDefault("b"); err != nil {
		t.Fatal(err)
	}
	s, _ := m.Sender("")
	if s.Name() != "b" {
		t.Errorf("default = %q, want b", s.Name())
	}

	if err := m.SetDefault("nope"); err == nil {
		t.Fatal("SetDefault(unknown) should error")
	}
}

func TestSenderLookup(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("a"))

	if _, err := m.Sender("a"); err != nil {
		t.Fatalf("Sender(a) = %v", err)
	}
	if _, err := m.Sender("nope"); err == nil {
		t.Fatal("Sender(unknown) should error")
	}
}

func TestSend(t *testing.T) {
	m := mailx.NewManager()
	mock := newMockSender("mock")
	_ = m.Register(mock)

	msg := mailx.NewMessage().To("a@b.com").Subject("s").Body("b").Build()
	if err := m.Send(context.Background(), msg); err != nil {
		t.Fatal(err)
	}
	if mock.count() != 1 {
		t.Fatalf("send count = %d, want 1", mock.count())
	}
}

func TestSendWithRoutesByName(t *testing.T) {
	m := mailx.NewManager()
	a := newMockSender("a")
	b := newMockSender("b")
	_ = m.Register(a)
	_ = m.Register(b)

	msg := mailx.NewMessage().To("x@y.com").Subject("s").Build()
	if err := m.SendWith(context.Background(), "b", msg); err != nil {
		t.Fatal(err)
	}
	if a.count() != 0 || b.count() != 1 {
		t.Fatalf("a=%d b=%d, want a=0 b=1", a.count(), b.count())
	}

	if err := m.SendWith(context.Background(), "nope", msg); err == nil {
		t.Fatal("SendWith(unknown) should error")
	}
}

func TestSendBy(t *testing.T) {
	m := mailx.NewManager()
	mock := newMockSender("temp")

	msg := mailx.NewMessage().To("x@y.com").Subject("s").Build()
	if err := m.SendBy(context.Background(), mock, msg); err != nil {
		t.Fatal(err)
	}
	if mock.count() != 1 {
		t.Fatalf("count = %d, want 1", mock.count())
	}

	if err := m.SendBy(context.Background(), nil, msg); err == nil {
		t.Fatal("SendBy(nil) should error")
	}
}

func TestSendValidation(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("mock"))

	if err := m.Send(context.Background(), nil); err == nil {
		t.Fatal("Send(nil) should error")
	}
	if err := m.Send(context.Background(), &mailx.Message{Subject: "s"}); err == nil {
		t.Fatal("message without recipients should error")
	}
}

func TestSendErrorPropagated(t *testing.T) {
	m := mailx.NewManager()
	mock := newMockSender("mock")
	mock.err = errors.New("boom")
	_ = m.Register(mock)

	msg := mailx.NewMessage().To("a@b.com").Subject("s").Build()
	err := m.Send(context.Background(), msg)
	if err == nil || !strings.Contains(err.Error(), "boom") {
		t.Fatalf("err = %v, want containing boom", err)
	}
}

func TestSendInjectsLogger(t *testing.T) {
	m := mailx.NewManager()
	mock := newMockSender("mock")
	_ = m.Register(mock)
	m.SetLogger(recordingLogger{})

	msg := mailx.NewMessage().To("a@b.com").Subject("s").Build()
	ctx := context.Background()
	if err := m.Send(ctx, msg); err != nil {
		t.Fatal(err)
	}

	// 发送时 context 应带有管理器注入的 logger（通道可通过 LoggerFromContext 取到）
	if _, ok := mock.lastLogger().(recordingLogger); !ok {
		t.Fatalf("injected logger type = %T, want recordingLogger", mock.lastLogger())
	}
}

func TestQueryMethods(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("a"))
	_ = m.Register(newMockSender("b"))

	if !m.Registered("a") || !m.Registered("b") {
		t.Error("Registered() should be true for registered senders")
	}
	if m.Registered("nope") {
		t.Error("Registered() should be false for unknown sender")
	}

	names := m.Names()
	if len(names) != 2 {
		t.Fatalf("Names() = %v, want 2", names)
	}
	seen := map[string]bool{}
	for _, n := range names {
		seen[n] = true
	}
	if !seen["a"] || !seen["b"] {
		t.Errorf("Names() missing a/b: %v", names)
	}

	if m.Default() != "a" {
		t.Errorf("Default() = %q, want a", m.Default())
	}
	_ = m.SetDefault("b")
	if m.Default() != "b" {
		t.Errorf("Default() = %q, want b", m.Default())
	}
}

func TestErrSentinel(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("mock"))

	// 空 manager 且未注册任何通道时，查默认通道返回 ErrSenderNotFound
	if _, err := mailx.NewManager().Sender(""); !errors.Is(err, mailx.ErrSenderNotFound) {
		t.Errorf("Sender() on empty manager = %v, want ErrSenderNotFound", err)
	}
	// 未注册的名称返回 ErrSenderNotFound
	if _, err := m.Sender("nope"); !errors.Is(err, mailx.ErrSenderNotFound) {
		t.Errorf("Sender(unknown) = %v, want ErrSenderNotFound", err)
	}
	// 消息校验失败返回 ErrInvalidMessage
	if err := m.Send(context.Background(), &mailx.Message{Subject: "s"}); !errors.Is(err, mailx.ErrInvalidMessage) {
		t.Errorf("Send(no recipients) = %v, want ErrInvalidMessage", err)
	}
	// 非法配置返回 ErrInvalidConfig
	if err := m.Register(nil); !errors.Is(err, mailx.ErrInvalidConfig) {
		t.Errorf("Register(nil) = %v, want ErrInvalidConfig", err)
	}
}

// TestConcurrentRegisterUnregister 验证并发注册/注销不 panic 且不丢数据
func TestConcurrentRegisterUnregister(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("base"))

	ctx := context.Background()
	const n = 30
	var wg sync.WaitGroup
	for i := 0; i < n; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			name := fmt.Sprintf("sender-%d", i)
			_ = m.RegisterNamed(name, newMockSender("mock"))
			msg := mailx.NewMessage().To("a@b.com").Subject("s").Build()
			_ = m.SendWith(ctx, name, msg)
			m.Unregister(name)
		}(i)
	}
	wg.Wait()
	if !m.Registered("base") {
		t.Error("base sender should still be registered")
	}
}

func TestConcurrentSetLogger(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("mock"))

	msg := mailx.NewMessage().To("a@b.com").Subject("s").Build()
	ctx := context.Background()

	const n = 100
	var wg sync.WaitGroup
	for i := 0; i < n; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			if i%2 == 0 {
				m.SetLogger(recordingLogger{})
			} else {
				_ = m.Send(ctx, msg) // 内部读取 Logger，验证并发读写不 panic/不竞态
			}
		}(i)
	}
	wg.Wait()
	// Logger() 应始终返回非 nil 且类型正确
	if _, ok := m.Logger().(recordingLogger); !ok {
		t.Fatalf("Logger() type = %T, want recordingLogger", m.Logger())
	}
}

func TestConcurrentSend(t *testing.T) {
	m := mailx.NewManager()
	mock := newMockSender("mock")
	_ = m.Register(mock)

	msg := mailx.NewMessage().To("a@b.com").Subject("s").Build()
	ctx := context.Background()

	const n = 50
	var wg sync.WaitGroup
	for i := 0; i < n; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			if err := m.Send(ctx, msg); err != nil {
				t.Errorf("Send: %v", err)
			}
		}()
	}
	wg.Wait()

	if mock.count() != n {
		t.Fatalf("count = %d, want %d", mock.count(), n)
	}
}

// TestRegisterNamedSameType 验证同一通道类型可注册多份不同配置的实例
func TestRegisterNamedSameType(t *testing.T) {
	m := mailx.NewManager()

	main := newMockSender("smtp")
	backup := newMockSender("smtp")

	if err := m.RegisterNamed("smtp-main", main); err != nil {
		t.Fatal(err)
	}
	if err := m.RegisterNamed("smtp-backup", backup); err != nil {
		t.Fatal(err)
	}

	// 两个实例都注册成功
	if len(m.Names()) != 2 {
		t.Fatalf("Names() = %v, want 2 instances", m.Names())
	}
	// 类型相同但实例不同
	infos := m.Senders()
	if len(infos) != 2 {
		t.Fatalf("Senders() = %v, want 2", infos)
	}
	for _, info := range infos {
		if info.Type != "smtp" {
			t.Errorf("SenderInfo.Type = %q, want smtp", info.Type)
		}
	}

	// 按实例名路由发送到具体配置
	msg := mailx.NewMessage().To("a@b.com").Subject("s").Build()
	if err := m.SendWith(context.Background(), "smtp-backup", msg); err != nil {
		t.Fatal(err)
	}
	if main.count() != 0 || backup.count() != 1 {
		t.Errorf("main=%d backup=%d, want main=0 backup=1", main.count(), backup.count())
	}
}

// TestRegisterNamedDuplicateInstance 验证实例名冲突时报错
func TestRegisterNamedDuplicateInstance(t *testing.T) {
	m := mailx.NewManager()
	_ = m.RegisterNamed("smtp-main", newMockSender("smtp"))
	err := m.RegisterNamed("smtp-main", newMockSender("smtp"))
	if err == nil || !strings.Contains(err.Error(), "already registered") {
		t.Fatalf("err = %v, want already registered", err)
	}
}

// TestRegisterNamedEmptyName 验证空实例名时报错
func TestRegisterNamedEmptyName(t *testing.T) {
	m := mailx.NewManager()
	if err := m.RegisterNamed("", newMockSender("smtp")); !errors.Is(err, mailx.ErrInvalidConfig) {
		t.Fatalf("err = %v, want ErrInvalidConfig", err)
	}
}

// TestRegisterSameTypeDirect 验证 Register 用通道类型名注册时，同类型只允许一个（默认实例）
func TestRegisterSameTypeDirect(t *testing.T) {
	m := mailx.NewManager()
	_ = m.Register(newMockSender("smtp"))
	if err := m.Register(newMockSender("smtp")); err == nil {
		t.Fatal("Register(same type) should error")
	}
}

// TestSendersInfo 验证 Senders() 返回实例名与类型
func TestSendersInfo(t *testing.T) {
	m := mailx.NewManager()
	_ = m.RegisterNamed("smtp-main", newMockSender("smtp"))
	_ = m.RegisterNamed("aliyun-prod", newMockSender("aliyun"))

	infos := m.Senders()
	want := map[string]string{"smtp-main": "smtp", "aliyun-prod": "aliyun"}
	got := map[string]string{}
	for _, i := range infos {
		got[i.Name] = i.Type
	}
	for k, v := range want {
		if got[k] != v {
			t.Errorf("Senders()[%s] = %q, want %q (all: %+v)", k, got[k], v, infos)
		}
	}
	if len(got) != len(want) {
		t.Errorf("Senders() count = %d, want %d", len(got), len(want))
	}
}

// TestUnregisterNamedInstance 验证按实例名注销后不再路由
func TestUnregisterNamedInstance(t *testing.T) {
	m := mailx.NewManager()
	main := newMockSender("smtp")
	backup := newMockSender("smtp")
	_ = m.RegisterNamed("smtp-main", main)
	_ = m.RegisterNamed("smtp-backup", backup)

	m.Unregister("smtp-main")
	if m.Registered("smtp-main") {
		t.Error("smtp-main should be unregistered")
	}
	if !m.Registered("smtp-backup") {
		t.Error("smtp-backup should remain registered")
	}

	// 注销的实例不可再路由
	msg := mailx.NewMessage().To("a@b.com").Subject("s").Build()
	if err := m.SendWith(context.Background(), "smtp-main", msg); !errors.Is(err, mailx.ErrSenderNotFound) {
		t.Errorf("SendWith(unregistered) = %v, want ErrSenderNotFound", err)
	}
}

// TestUnregisterLastFallback 验证注销默认实例后自动回退到其他实例
func TestUnregisterLastFallback(t *testing.T) {
	m := mailx.NewManager()
	_ = m.RegisterNamed("a", newMockSender("smtp"))
	_ = m.RegisterNamed("b", newMockSender("aliyun"))

	if m.Default() != "a" {
		t.Fatalf("Default() = %q, want a", m.Default())
	}
	m.Unregister("a")
	if m.Default() != "b" {
		t.Errorf("Default() after unregister = %q, want b", m.Default())
	}
}

// TestSetDefaultNamedInstance 验证 SetDefault 支持实例名
func TestSetDefaultNamedInstance(t *testing.T) {
	m := mailx.NewManager()
	_ = m.RegisterNamed("smtp-main", newMockSender("smtp"))
	_ = m.RegisterNamed("smtp-backup", newMockSender("smtp"))

	if err := m.SetDefault("smtp-backup"); err != nil {
		t.Fatal(err)
	}
	s, _ := m.Sender("")
	if s.Name() != "smtp" {
		t.Errorf("default sender type = %q, want smtp", s.Name())
	}
	// 确认默认实例是 backup（发送到 backup）
	backup, _ := m.Sender("smtp-backup")
	if _, ok := backup.(*mockSender); !ok || m.Default() != "smtp-backup" {
		t.Errorf("Default() = %q, want smtp-backup", m.Default())
	}
}