verdande/internal/quickadd/quickadd_test.go

package quickadd

import (
	"testing"
	"time"
)

// The reference moment for every test: Tuesday 10 March 2026, 10:00, Copenhagen.
// A Tuesday is deliberate — it sits mid-week, so "next friday" and "monday" resolve
// in opposite directions and a bug in either cannot hide behind the other.
func ref(t *testing.T) time.Time {
	t.Helper()
	loc, err := time.LoadLocation("Europe/Copenhagen")
	if err != nil {
		t.Fatalf("load timezone: %v", err)
	}
	now := time.Date(2026, 3, 10, 10, 0, 0, 0, loc)
	if now.Weekday() != time.Tuesday {
		t.Fatalf("reference date is a %s; the expectations below assume Tuesday", now.Weekday())
	}
	return now
}

// The example from the brief, end to end.
func TestParseTheBriefExample(t *testing.T) {
	got := Parse("betal moms i morgen kl 10 p1 #Firma @regnskab", ref(t), "da")

	if got.Content != "betal moms" {
		t.Errorf("Content = %q, want %q", got.Content, "betal moms")
	}
	if got.DueDate != "2026-03-11" {
		t.Errorf("DueDate = %q, want 2026-03-11", got.DueDate)
	}
	if got.DueTime != "10:00" {
		t.Errorf("DueTime = %q, want 10:00", got.DueTime)
	}
	if got.Priority != 1 {
		t.Errorf("Priority = %d, want 1", got.Priority)
	}
	if got.Project != "Firma" {
		t.Errorf("Project = %q, want Firma", got.Project)
	}
	if len(got.Labels) != 1 || got.Labels[0] != "regnskab" {
		t.Errorf("Labels = %v, want [regnskab]", got.Labels)
	}
}

func TestParseDates(t *testing.T) {
	now := ref(t)
	cases := []struct {
		in   string
		want string
	}{
		// Danish relative
		{"ring til mor i dag", "2026-03-10"},
		{"ring til mor idag", "2026-03-10"},
		{"ring til mor i morgen", "2026-03-11"},
		{"ring til mor imorgen", "2026-03-11"},
		{"ring til mor i overmorgen", "2026-03-12"},
		{"ring til mor om 3 dage", "2026-03-13"},
		{"ring til mor om en uge", "2026-03-17"},
		{"ring til mor om 2 uger", "2026-03-24"},
		{"ring til mor om en måned", "2026-04-10"},
		{"ring til mor næste uge", "2026-03-16"},
		{"ring til mor næste måned", "2026-04-10"},

		// English relative
		{"call mum today", "2026-03-10"},
		{"call mum tomorrow", "2026-03-11"},
		{"call mum day after tomorrow", "2026-03-12"},
		{"call mum in 3 days", "2026-03-13"},
		{"call mum in a week", "2026-03-17"},
		{"call mum in 2 weeks", "2026-03-24"},
		{"call mum next week", "2026-03-16"},
		{"call mum next month", "2026-04-10"},

		// Weekdays. From a Tuesday: Friday is this week, Monday is the next one,
		// and Tuesday itself is today.
		{"møde fredag", "2026-03-13"},
		{"møde på fredag", "2026-03-13"},
		{"møde mandag", "2026-03-16"},
		{"møde tirsdag", "2026-03-10"},
		{"møde søndag", "2026-03-15"},
		{"meeting friday", "2026-03-13"},
		{"meeting on friday", "2026-03-13"},

		// "next <weekday>" is next week's, counted from Monday — not merely the
		// next one to come round.
		{"møde næste fredag", "2026-03-20"},
		{"meeting next friday", "2026-03-20"},
		{"møde næste mandag", "2026-03-16"},

		// Written dates
		{"deadline 15. marts", "2026-03-15"},
		{"deadline 15 marts", "2026-03-15"},
		{"deadline den 15. marts", "2026-03-15"},
		{"deadline march 15", "2026-03-15"},
		{"deadline 1. dec", "2026-12-01"},
		{"deadline dec 1", "2026-12-01"},

		// Numeric, day-first
		{"deadline 15/3", "2026-03-15"},
		{"deadline 15/3-2026", "2026-03-15"},
		{"deadline 2026-12-24", "2026-12-24"},

		// A date that has already gone by this year means next year.
		{"deadline 1. marts", "2027-03-01"},
		{"deadline 1/3", "2027-03-01"},
	}

	for _, tc := range cases {
		t.Run(tc.in, func(t *testing.T) {
			got := Parse(tc.in, now, "da")
			if got.DueDate != tc.want {
				t.Errorf("DueDate = %q, want %q (content %q)", got.DueDate, tc.want, got.Content)
			}
		})
	}
}

func TestParseTimes(t *testing.T) {
	now := ref(t)
	cases := []struct {
		in     string
		locale string
		want   string
	}{
		{"møde kl 14", "da", "14:00"},
		{"møde kl. 14", "da", "14:00"},
		{"møde kl 14:30", "da", "14:30"},
		{"møde kl 14.30", "da", "14:30"},
		{"møde klokken 16", "da", "16:00"},
		{"møde 16:30", "da", "16:30"},
		{"meeting at 14", "en", "14:00"},
		{"meeting at 10am", "en", "10:00"},
		{"meeting at 7:30 pm", "en", "19:30"},
		{"meeting 10am", "en", "10:00"},
		{"meeting 12am", "en", "00:00"},
		{"meeting 12pm", "en", "12:00"},

		// "kl 3" from a Dane is three in the morning — Danish has no am/pm habit,
		// and the 24-hour clock is what people mean. English "at 3" is not.
		{"møde kl 3", "da", "03:00"},
		{"meeting at 3", "en", "15:00"},
	}

	for _, tc := range cases {
		t.Run(tc.in, func(t *testing.T) {
			got := Parse(tc.in, now, tc.locale)
			if got.DueTime != tc.want {
				t.Errorf("DueTime = %q, want %q", got.DueTime, tc.want)
			}
		})
	}
}

// A clock time with no day attached means the next time that clock reads it.
func TestTimeWithoutDateRollsForward(t *testing.T) {
	now := ref(t) // 10:00

	later := Parse("møde kl 14", now, "da")
	if later.DueDate != "2026-03-10" {
		t.Errorf("a time still to come today: DueDate = %q, want 2026-03-10", later.DueDate)
	}

	earlier := Parse("møde kl 8", now, "da")
	if earlier.DueDate != "2026-03-11" {
		t.Errorf("a time already past today: DueDate = %q, want 2026-03-11", earlier.DueDate)
	}
}

func TestParsePriority(t *testing.T) {
	now := ref(t)
	cases := map[string]int{
		"skriv rapport p1":  1,
		"skriv rapport p2":  2,
		"skriv rapport p3":  3,
		"skriv rapport p4":  4,
		"skriv rapport":     4,
		"skriv rapport !!!": 1,
		"skriv rapport !!":  2,
		"skriv rapport !":   3,
		// Not a priority: part of a word, or out of range.
		"skriv p5 rapport":   4,
		"skriv rapportp1":    4,
		"deploy p1beta node": 4,
	}
	for in, want := range cases {
		t.Run(in, func(t *testing.T) {
			if got := Parse(in, now, "da").Priority; got != want {
				t.Errorf("Priority = %d, want %d", got, want)
			}
		})
	}
}

func TestParseProjectAndLabels(t *testing.T) {
	now := ref(t)

	got := Parse("køb kaffe #Hjem @indkøb @haster", now, "da")
	if got.Project != "Hjem" {
		t.Errorf("Project = %q, want Hjem", got.Project)
	}
	if len(got.Labels) != 2 || got.Labels[0] != "indkøb" || got.Labels[1] != "haster" {
		t.Errorf("Labels = %v, want [indkøb haster]", got.Labels)
	}
	if got.Content != "køb kaffe" {
		t.Errorf("Content = %q, want %q", got.Content, "køb kaffe")
	}

	t.Run("quoted names may contain spaces", func(t *testing.T) {
		got := Parse(`send faktura #"Q3 rapport" @"skal godkendes"`, now, "da")
		if got.Project != "Q3 rapport" {
			t.Errorf("Project = %q, want %q", got.Project, "Q3 rapport")
		}
		if len(got.Labels) != 1 || got.Labels[0] != "skal godkendes" {
			t.Errorf("Labels = %v", got.Labels)
		}
		if got.Content != "send faktura" {
			t.Errorf("Content = %q", got.Content)
		}
	})

	t.Run("the last project wins", func(t *testing.T) {
		// Typing a second one is a correction, not a second project.
		got := Parse("opgave #Arbejde #Privat", now, "da")
		if got.Project != "Privat" {
			t.Errorf("Project = %q, want Privat", got.Project)
		}
		if got.Content != "opgave" {
			t.Errorf("Content = %q, want %q", got.Content, "opgave")
		}
	})

	t.Run("a repeated label is added once", func(t *testing.T) {
		got := Parse("opgave @haster @Haster", now, "da")
		if len(got.Labels) != 1 {
			t.Errorf("Labels = %v, want one entry", got.Labels)
		}
	})

	t.Run("danish letters in names", func(t *testing.T) {
		got := Parse("bogfør bilag #Økonomi @årsregnskab", now, "da")
		if got.Project != "Økonomi" {
			t.Errorf("Project = %q, want Økonomi", got.Project)
		}
		if len(got.Labels) != 1 || got.Labels[0] != "årsregnskab" {
			t.Errorf("Labels = %v, want [årsregnskab]", got.Labels)
		}
	})
}

// The parser must not claim the same characters twice. "kl 10.12" is a time; a date
// parser reading the raw line would also see the 10th of December in it.
func TestOverlappingReadingsAreResolvedOnce(t *testing.T) {
	now := ref(t)

	got := Parse("møde kl 10.12", now, "da")
	if got.DueTime != "10:12" {
		t.Errorf("DueTime = %q, want 10:12", got.DueTime)
	}
	if got.DueDate != "2026-03-10" {
		t.Errorf("DueDate = %q, want today — the time is still to come", got.DueDate)
	}
	if got.Content != "møde" {
		t.Errorf("Content = %q, want %q", got.Content, "møde")
	}
}

// A project or label named after a weekday is a name, not a date.
func TestSigilNamesAreNotReadAsDates(t *testing.T) {
	now := ref(t)

	got := Parse("planlæg #Fredagsbar", now, "da")
	if got.DueDate != "" {
		t.Errorf("DueDate = %q, want none", got.DueDate)
	}
	if got.Project != "Fredagsbar" {
		t.Errorf("Project = %q", got.Project)
	}

	exact := Parse("drinks @fredag", now, "da")
	if exact.DueDate != "" {
		t.Errorf("a label spelled like a weekday set DueDate = %q", exact.DueDate)
	}
}

// A weekday must be found wherever it sits in the line. A pattern anchored on the
// whitespace around a word eats that whitespace and then matches every other word.
func TestWeekdayIsFoundAtAnyPosition(t *testing.T) {
	now := ref(t)
	cases := []string{
		"fredag",
		"ring fredag",
		"ring til fredag",
		"ring til Anders fredag",
		"ring til Anders om det der fredag",
		"a b c d e f fredag",
	}
	for _, in := range cases {
		t.Run(in, func(t *testing.T) {
			if got := Parse(in, now, "da").DueDate; got != "2026-03-13" {
				t.Errorf("DueDate = %q, want 2026-03-13", got)
			}
		})
	}
}

func TestContentKeepsWhatWasNotUnderstood(t *testing.T) {
	now := ref(t)
	cases := []struct{ in, want string }{
		{"betal moms i morgen kl 10 p1 #Firma @regnskab", "betal moms"},
		{"  ryd    op   ", "ryd op"},
		{"p1 #Firma", ""},
		{"skriv rapport om kvartalstallene", "skriv rapport om kvartalstallene"},
		{"i morgen ring til tandlægen", "ring til tandlægen"},
		{"ring #Privat til tandlægen i morgen", "ring til tandlægen"},
	}
	for _, tc := range cases {
		t.Run(tc.in, func(t *testing.T) {
			if got := Parse(tc.in, now, "da").Content; got != tc.want {
				t.Errorf("Content = %q, want %q", got, tc.want)
			}
		})
	}
}

// Danish and English are parsed together: people mix them mid-sentence.
func TestLanguagesMixInOneLine(t *testing.T) {
	got := Parse("ring til Anders on friday kl 14 #Arbejde", ref(t), "da")
	if got.DueDate != "2026-03-13" {
		t.Errorf("DueDate = %q, want 2026-03-13", got.DueDate)
	}
	if got.DueTime != "14:00" {
		t.Errorf("DueTime = %q, want 14:00", got.DueTime)
	}
	if got.Content != "ring til Anders" {
		t.Errorf("Content = %q, want %q", got.Content, "ring til Anders")
	}
}

// Spans drive the live highlighting in the input box, so they have to point at the
// right bytes of the original string — not of some lowercased or rewritten copy.
func TestSpansPointIntoTheOriginalInput(t *testing.T) {
	in := "betal moms i morgen kl 10 p1 #Firma @regnskab"
	got := Parse(in, ref(t), "da")

	// A span covers the whole phrase that was understood, marker included — the
	// highlight should sit under "kl 10", not under a bare "10" with a stray "kl"
	// left unhighlighted beside it.
	want := map[Kind]string{
		KindDate:     "i morgen",
		KindTime:     "kl 10",
		KindPriority: "p1",
		KindProject:  "#Firma",
		KindLabel:    "@regnskab",
	}
	seen := map[Kind]bool{}
	for _, s := range got.Spans {
		if s.Start < 0 || s.End > len(in) || s.Start >= s.End {
			t.Fatalf("span %+v is not a valid range of a %d-byte input", s, len(in))
		}
		text := in[s.Start:s.End]
		if w, ok := want[s.Kind]; ok && text != w {
			t.Errorf("span %s covers %q, want %q", s.Kind, text, w)
		}
		seen[s.Kind] = true
	}
	for kind := range want {
		if !seen[kind] {
			t.Errorf("no span of kind %s", kind)
		}
	}

	// Spans are handed to the UI in the order they appear.
	for i := 1; i < len(got.Spans); i++ {
		if got.Spans[i-1].Start > got.Spans[i].Start {
			t.Errorf("spans are not sorted: %+v", got.Spans)
		}
	}

	// And they must not overlap, or highlighting would paint over itself.
	for i := 1; i < len(got.Spans); i++ {
		if got.Spans[i].Start < got.Spans[i-1].End {
			t.Errorf("spans %+v and %+v overlap", got.Spans[i-1], got.Spans[i])
		}
	}
}

// Nothing typed into a quick-add box may produce an invalid date or a panic.
func TestNonsenseInputIsHarmless(t *testing.T) {
	now := ref(t)
	inputs := []string{
		"", "   ", "#", "@", "#\"", "p", "p9",
		"31. februar", "32/13", "0/0", "2026-13-45", "99:99", "kl 25:00",
		"@@@@", "####", "i morgen i morgen i morgen",
		"om dage", "in weeks", "næste", "next",
		"1/1/1/1/1", "----", "kl", "at",
	}
	for _, in := range inputs {
		t.Run(in, func(t *testing.T) {
			got := Parse(in, now, "da")
			if got.Priority < 1 || got.Priority > 4 {
				t.Errorf("Priority = %d, out of range", got.Priority)
			}
			if got.DueDate != "" {
				if _, err := time.Parse("2006-01-02", got.DueDate); err != nil {
					t.Errorf("DueDate = %q is not a date: %v", got.DueDate, err)
				}
			}
			if got.DueTime != "" {
				if _, err := time.Parse("15:04", got.DueTime); err != nil {
					t.Errorf("DueTime = %q is not a time: %v", got.DueTime, err)
				}
			}
		})
	}
}

// An impossible calendar date must be left in the title rather than rolled over
// into a different, plausible-looking one.
func TestImpossibleDatesAreNotSilentlyMoved(t *testing.T) {
	now := ref(t)
	for _, in := range []string{"deadline 31. februar", "deadline 30/2", "deadline 2026-02-30"} {
		t.Run(in, func(t *testing.T) {
			if got := Parse(in, now, "da").DueDate; got != "" {
				t.Errorf("DueDate = %q, want none — 30/31 February is not a date", got)
			}
		})
	}
}

// --- recurrence ---------------------------------------------------------------

func TestParseRecurrence(t *testing.T) {
	now := ref(t) // Tuesday 10 March 2026

	cases := []struct {
		in      string
		content string
		rule    string
		wantDue string
	}{
		{"vand planterne hver mandag", "vand planterne", "FREQ=WEEKLY;BYDAY=MO", "2026-03-16"},
		{"tag skraldet ud hver tirsdag", "tag skraldet ud", "FREQ=WEEKLY;BYDAY=TU", "2026-03-17"},
		{"løb hver dag", "løb", "FREQ=DAILY", "2026-03-11"},
		{"status hver 2. uge", "status", "FREQ=WEEKLY;INTERVAL=2", "2026-03-24"},
		{"betal husleje den 1. i måneden", "betal husleje", "FREQ=MONTHLY;BYMONTHDAY=1", "2026-04-01"},
		{"standup hverdage", "standup", "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR", "2026-03-11"},
		{"review every 2 weeks", "review", "FREQ=WEEKLY;INTERVAL=2", "2026-03-24"},
		{"backup weekly", "backup", "FREQ=WEEKLY", "2026-03-17"},
	}

	for _, tc := range cases {
		t.Run(tc.in, func(t *testing.T) {
			got := Parse(tc.in, now, "da")
			if got.Recurrence != tc.rule {
				t.Errorf("Recurrence = %q, want %q", got.Recurrence, tc.rule)
			}
			if got.Content != tc.content {
				t.Errorf("Content = %q, want %q", got.Content, tc.content)
			}
			if got.DueDate != tc.wantDue {
				t.Errorf("DueDate = %q, want %q", got.DueDate, tc.wantDue)
			}
		})
	}
}

// "hver mandag" contains a weekday. If the date parser ran first it would claim
// Monday as a one-off date and leave "hver" stranded in the title.
func TestRecurrenceBeatsAPlainWeekday(t *testing.T) {
	now := ref(t)

	repeating := Parse("møde hver fredag", now, "da")
	if repeating.Recurrence != "FREQ=WEEKLY;BYDAY=FR" {
		t.Errorf("Recurrence = %q", repeating.Recurrence)
	}
	if repeating.Content != "møde" {
		t.Errorf("Content = %q, want %q", repeating.Content, "møde")
	}

	// And a plain weekday is still a one-off.
	once := Parse("møde fredag", now, "da")
	if once.Recurrence != "" {
		t.Errorf("a one-off got a recurrence rule: %q", once.Recurrence)
	}
	if once.DueDate != "2026-03-13" {
		t.Errorf("DueDate = %q, want 2026-03-13", once.DueDate)
	}
}

// The repetition phrase sits in a line with everything else in it.
func TestRecurrenceAlongsideEverythingElse(t *testing.T) {
	got := Parse("send rapport hver mandag kl 9 p1 #Arbejde @fast", ref(t), "da")

	if got.Recurrence != "FREQ=WEEKLY;BYDAY=MO" {
		t.Errorf("Recurrence = %q", got.Recurrence)
	}
	if got.Content != "send rapport" {
		t.Errorf("Content = %q, want %q", got.Content, "send rapport")
	}
	if got.DueTime != "09:00" {
		t.Errorf("DueTime = %q, want 09:00", got.DueTime)
	}
	if got.Priority != 1 {
		t.Errorf("Priority = %d, want 1", got.Priority)
	}
	if got.Project != "Arbejde" {
		t.Errorf("Project = %q, want Arbejde", got.Project)
	}
	if len(got.Labels) != 1 || got.Labels[0] != "fast" {
		t.Errorf("Labels = %v", got.Labels)
	}
	// An explicit clock time with a repetition still anchors on the next occurrence.
	if got.DueDate != "2026-03-16" {
		t.Errorf("DueDate = %q, want 2026-03-16", got.DueDate)
	}
}

// An explicit date wins over the rule's own first occurrence: "hver mandag fra på
// fredag" is unusual, but "hver måned den 20/3" is somebody stating a start.
func TestExplicitDateAnchorsTheSeries(t *testing.T) {
	got := Parse("aflæs måler hver måned 20/3", ref(t), "da")

	if got.Recurrence != "FREQ=MONTHLY" {
		t.Errorf("Recurrence = %q", got.Recurrence)
	}
	if got.DueDate != "2026-03-20" {
		t.Errorf("DueDate = %q, want the stated date 2026-03-20", got.DueDate)
	}
}

func TestRecurrenceTextIsHumanReadable(t *testing.T) {
	got := Parse("vand planterne hver mandag", ref(t), "da")
	if got.RecurrenceText == "" {
		t.Fatal("no readable description was produced")
	}
	if got.RecurrenceText == got.Recurrence {
		t.Errorf("the description is just the raw rule: %q", got.RecurrenceText)
	}
}

// A repetition must be reported as a span so the input box can highlight it.
func TestRecurrenceIsHighlighted(t *testing.T) {
	in := "vand planterne hver mandag"
	got := Parse(in, ref(t), "da")

	var found bool
	for _, s := range got.Spans {
		if s.Kind != KindRepeat {
			continue
		}
		found = true
		if text := in[s.Start:s.End]; text != "hver mandag" {
			t.Errorf("the repeat span covers %q, want %q", text, "hver mandag")
		}
	}
	if !found {
		t.Error("no span of kind repeat")
	}
}

// A section, and the three shapes a slash takes in ordinary text.
//
// The sigil is the one that needed thinking about: '#' and '@' never occur in a
// Danish task line by accident, and '/' occurs constantly. What keeps it apart is
// that the slash must follow whitespace and the name must follow the slash with
// nothing in between — which "km/t", "3/4" and "20 kr / stk" all fail.
func TestASectionIsWrittenWithASlash(t *testing.T) {
	for _, c := range []struct {
		in      string
		section string
		content string
	}{
		{"ring til Karpenhøj /Produktion", "Produktion", "ring til Karpenhøj"},
		{"/Produktion ring til Karpenhøj", "Produktion", "ring til Karpenhøj"},
		// A real section name with a slash in it. The bare form is greedy, so the
		// whole thing comes across rather than stopping at the second slash.
		{"nye poser /Kunder/Ordrer", "Kunder/Ordrer", "nye poser"},
		{`nye poser /"Kunder og ordrer"`, "Kunder og ordrer", "nye poser"},
		// Retyping is a correction, not two sections.
		{"nye poser /Drift /Produktion", "Produktion", "nye poser"},
		// And alongside everything else.
		{"betal moms i morgen kl 10 p1 #Firma /Bogholderi", "Bogholderi", "betal moms"},

		// The ways a slash shows up when nobody meant a section. None of them may
		// produce one: the slash has to follow whitespace, and the name has to
		// follow the slash with nothing between.
		{"kør 80 km/t forbi", "", "kør 80 km/t forbi"},
		{"20 kr / stk hos grossisten", "", "20 kr / stk hos grossisten"},
		// "3/4" is a section to nobody and a date to a Dane — the 3rd of April —
		// and the date parser is right to claim it. What matters here is only that
		// it did not become a section.
		{"læs 3/4 af rapporten", "", "læs af rapporten"},
	} {
		got := Parse(c.in, ref(t), "da")
		if got.Section != c.section {
			t.Errorf("Parse(%q).Section = %q, want %q", c.in, got.Section, c.section)
		}
		if got.Content != c.content {
			t.Errorf("Parse(%q).Content = %q, want %q", c.in, got.Content, c.content)
		}
	}
}

// "hver anden tirsdag" er den måde, folk siger det på.
//
// recurrence-pakken har oversat "hver anden" til "hver 2." siden den blev skrevet,
// men sætningen nåede aldrig frem til den: mønsteret her tog kun ét ord efter
// "hver", så det, der blev givet videre, var "hver anden" — ikke en regel. Så blev
// de to ord stående i titlen, og "tirsdag" blev til en forfaldsdato. Opgaven
// gentog sig ikke, og der stod ikke noget om det.
//
// Fundet af en prøve, der brugte vendingen som selvfølgelig og opdagede, at den
// ikke var det.
func TestEveryOtherWeekdayIsARepetition(t *testing.T) {
	for _, tc := range []struct {
		text string
		rule string
		left string
	}{
		{"vande planterne hver anden tirsdag", "FREQ=WEEKLY;BYDAY=TU;INTERVAL=2", "vande planterne"},
		{"vande planterne hver 2. tirsdag", "FREQ=WEEKLY;BYDAY=TU;INTERVAL=2", "vande planterne"},
		{"water the plants every other tuesday", "FREQ=WEEKLY;BYDAY=TU;INTERVAL=2", "water the plants"},
		{"gå tur hver tredje søndag", "FREQ=WEEKLY;BYDAY=SU;INTERVAL=3", "gå tur"},
		// Den, der virkede i forvejen, skal blive ved med at gøre det.
		{"tømme opvasker hver mandag", "FREQ=WEEKLY;BYDAY=MO", "tømme opvasker"},
	} {
		got := Parse(tc.text, time.Date(2026, 8, 20, 9, 0, 0, 0, time.UTC), "da")
		if got.Recurrence != tc.rule {
			t.Errorf("%q gav reglen %q, want %q", tc.text, got.Recurrence, tc.rule)
		}
		if got.Content != tc.left {
			t.Errorf("%q efterlod titlen %q, want %q", tc.text, got.Content, tc.left)
		}
	}
}

// --- reminders ----------------------------------------------------------------

// A dictated sentence can set its own alarm.
//
// The offset is negative because the store ADDS it to the due moment
// (`due_datetime + offset_min * 60`). A positive number there is an alarm after
// the thing it was meant to warn about, which is the one direction a reminder must
// never be wrong in — so the sign is asserted here and not assumed.
func TestParseReminderOffset(t *testing.T) {
	now := ref(t)
	cases := []struct {
		in   string
		want int
	}{
		{"ring til tandlægen i morgen kl 9 mind mig en time før", -60},
		{"ring til tandlægen i morgen kl 9 mind mig 10 min før", -10},
		{"ring til tandlægen i morgen kl 9 mind mig 10 minutter før", -10},
		{"ring til tandlægen i morgen kl 9 mind mig et kvarter før", -15},
		{"ring til tandlægen i morgen kl 9 mind mig en halv time før", -30},
		{"møde i morgen kl 9 mind mig dagen før", -1440},
		{"møde i morgen kl 9 mind mig to dage før", -2880},
		{"møde i morgen kl 9 mind mig 2 timer før", -120},
		// Det er talt ind, så kommaet hører til sætningen og ikke til syntaksen.
		{"ring til tandlægen i morgen kl 9, mind mig en time før", -60},
		{"ring til tandlægen i morgen kl 9, påmind mig en time før", -60},
		{"ring til tandlægen i morgen kl 9, mind mig om det en time før", -60},
		// Engelsk i samme linje, som resten af parseren gør det.
		{"call the dentist tomorrow at 9 remind me an hour before", -60},
		{"call the dentist tomorrow at 9 remind me 15 minutes before", -15},
		{"call the dentist tomorrow at 9 remind me two days before", -2880},
		// En bar påmindelse er på selve forfaldstidspunktet.
		{"ring til tandlægen i morgen kl 9 mind mig", 0},
		{"ring til tandlægen i morgen kl 9 med alarm", 0},
	}
	for _, c := range cases {
		got := Parse(c.in, now, "da")
		if got.ReminderOffsetMin == nil {
			t.Errorf("Parse(%q): ReminderOffsetMin = nil, want %d", c.in, c.want)
			continue
		}
		if *got.ReminderOffsetMin != c.want {
			t.Errorf("Parse(%q): ReminderOffsetMin = %d, want %d", c.in, *got.ReminderOffsetMin, c.want)
		}
	}
}

// A reminder with a clock of its own takes the day the task is due.
//
// "mind mig kl 8" about something due Friday means Friday at eight. Resolving it
// against today instead would fire the alarm days early, silently.
func TestParseReminderClockTakesTheDueDay(t *testing.T) {
	now := ref(t)
	cases := []struct {
		in   string
		want string
	}{
		{"ring til tandlægen i morgen kl 9 mind mig kl 8", "2026-03-11T08:00"},
		{"ring til tandlægen i morgen kl 9 mind mig kl. 7.30", "2026-03-11T07:30"},
		{"ring til tandlægen i morgen kl 9, påmind kl 7:15", "2026-03-11T07:15"},
		{"call the dentist tomorrow at 9 remind me at 8", "2026-03-11T08:00"},
		// Ingen dato i linjen: så er det i dag, som en bar klokketid også er.
		{"ring til tandlægen mind mig kl 23", "2026-03-10T23:00"},
	}
	for _, c := range cases {
		got := Parse(c.in, now, "da")
		if got.ReminderAt != c.want {
			t.Errorf("Parse(%q): ReminderAt = %q, want %q", c.in, got.ReminderAt, c.want)
		}
		if got.ReminderOffsetMin != nil {
			t.Errorf("Parse(%q): also set an offset (%d); a reminder is one or the other",
				c.in, *got.ReminderOffsetMin)
		}
	}
}

// The alarm does not eat the task's own time, and the task's time does not eat the
// alarm. This is the ordering the stage exists for.
func TestReminderDoesNotTakeTheTasksOwnTime(t *testing.T) {
	got := Parse("ring til tandlægen i morgen kl 9 mind mig kl 8", ref(t), "da")

	if got.DueTime != "09:00" {
		t.Errorf("DueTime = %q, want 09:00 — the reminder took the task's clock", got.DueTime)
	}
	if got.DueDate != "2026-03-11" {
		t.Errorf("DueDate = %q, want 2026-03-11", got.DueDate)
	}
	if got.ReminderAt != "2026-03-11T08:00" {
		t.Errorf("ReminderAt = %q, want 2026-03-11T08:00", got.ReminderAt)
	}
	if got.Content != "ring til tandlægen" {
		t.Errorf("Content = %q, want %q", got.Content, "ring til tandlægen")
	}
}

// Nothing becomes an alarm by standing near a clock.
func TestNoReminderWhereNoneWasAskedFor(t *testing.T) {
	now := ref(t)
	for _, in := range []string{
		"ring til tandlægen i morgen kl 9",
		"betal moms i morgen kl 10 p1 #Firma @regnskab",
		// The \b cases: these words merely begin with the keywords.
		"skift batteri i alarmen",
		"mind migrationen om at køre",
		"vand planterne hver mandag kl 9",
	} {
		got := Parse(in, now, "da")
		if got.ReminderOffsetMin != nil {
			t.Errorf("Parse(%q): ReminderOffsetMin = %d, want none", in, *got.ReminderOffsetMin)
		}
		if got.ReminderAt != "" {
			t.Errorf("Parse(%q): ReminderAt = %q, want none", in, got.ReminderAt)
		}
	}
}

// The phrase is highlighted, like every other thing the parser claims — see the
// package comment: a parser you cannot see working is one you stop trusting.
func TestReminderIsHighlighted(t *testing.T) {
	in := "ring til tandlægen i morgen kl 9 mind mig en time før"
	got := Parse(in, ref(t), "da")

	var span *Span
	for i := range got.Spans {
		if got.Spans[i].Kind == KindReminder {
			span = &got.Spans[i]
		}
	}
	if span == nil {
		t.Fatalf("no %q span in %v", KindReminder, got.Spans)
	}
	if marked := in[span.Start:span.End]; marked != "mind mig en time før" {
		t.Errorf("highlighted %q, want %q", marked, "mind mig en time før")
	}
}

// An impossible clock is not a reminder: the store would keep 25:00 and never fire
// it, so saying nothing is the honest answer.
func TestImpossibleReminderClockIsNotKept(t *testing.T) {
	got := Parse("ring til tandlægen i morgen kl 9 mind mig kl 25", ref(t), "da")

	if got.ReminderAt != "" {
		t.Errorf("ReminderAt = %q, want none", got.ReminderAt)
	}
	if got.ReminderOffsetMin != nil {
		t.Errorf("ReminderOffsetMin = %d, want none", *got.ReminderOffsetMin)
	}
}