package dnsrec

import (
	"context"
	"errors"
	"testing"
)

// A record is identified by (name, type), not by value. That is what makes
// EnsureRecord an UPSERT rather than a create, and an upsert is what makes
// every walk in internal/mail re-runnable after a half-failure.
func TestKeyIsNameAndTypeOnly(t *testing.T) {
	a := Record{Name: "mail-eu-west-1.example.com", Type: TypeTXT, Values: []string{"v=spf1 -all"}}
	b := Record{Name: "mail-eu-west-1.example.com", Type: TypeTXT, Values: []string{"different"}}
	if a.Key() != b.Key() {
		t.Fatal("Key must not depend on Values — an upsert has to find the record it replaces")
	}
	c := Record{Name: "mail-eu-west-1.example.com", Type: TypeMX, Values: []string{"10 x"}}
	if a.Key() == c.Key() {
		t.Fatal("Key must depend on Type — MX and TXT coexist at one name")
	}
}

func TestMemWriterUpsertsAndDeletes(t *testing.T) {
	ctx, w := context.Background(), NewMemWriter()
	r := Record{Name: "x._domainkey.example.com", Type: TypeCNAME,
		Values: []string{"x.dkim.amazonses.com"}, TTL: 300}
	if err := w.EnsureRecord(ctx, r); err != nil {
		t.Fatalf("EnsureRecord: %v", err)
	}
	if got := w.Records[r.Key()]; got.Values[0] != "x.dkim.amazonses.com" {
		t.Fatalf("record not stored: %+v", got)
	}
	// Re-ensuring with a new value overwrites rather than duplicating.
	r.Values = []string{"y.dkim.amazonses.com"}
	if err := w.EnsureRecord(ctx, r); err != nil {
		t.Fatalf("re-EnsureRecord: %v", err)
	}
	if len(w.Records) != 1 || w.Records[r.Key()].Values[0] != "y.dkim.amazonses.com" {
		t.Fatalf("upsert did not replace: %+v", w.Records)
	}
	if err := w.DeleteRecord(ctx, r); err != nil {
		t.Fatalf("DeleteRecord: %v", err)
	}
	if len(w.Records) != 0 {
		t.Fatalf("delete left %d records", len(w.Records))
	}
}

// "Already gone" is a success, because teardown must be re-runnable.
func TestMemWriterDeleteAbsentIsSuccess(t *testing.T) {
	w := NewMemWriter()
	if err := w.DeleteRecord(context.Background(),
		Record{Name: "nope.example.com", Type: TypeTXT}); err != nil {
		t.Fatalf("deleting an absent record returned %v, want nil", err)
	}
}

// FailNext is one-shot, so a test can drive a walk through a half-failure
// at an exact step and then let the retry succeed.
func TestMemWriterFailNextIsOneShot(t *testing.T) {
	ctx, w := context.Background(), NewMemWriter()
	boom := errors.New("boom")
	w.FailNext["EnsureRecord"] = boom
	r := Record{Name: "a.example.com", Type: TypeTXT, Values: []string{"v"}}
	if err := w.EnsureRecord(ctx, r); !errors.Is(err, boom) {
		t.Fatalf("first EnsureRecord = %v, want boom", err)
	}
	if len(w.Records) != 0 {
		t.Fatal("a failed call must leave state untouched")
	}
	if err := w.EnsureRecord(ctx, r); err != nil {
		t.Fatalf("second EnsureRecord = %v, want nil", err)
	}
}