compass_teams_nhs/internal/dashboard/dashboard.go

// Package dashboard turns stored items into the per-child view required by
// AGENTS.md §4 (FR-6, FR-7) and §5: overdue first, then due today, due this
// week, then messages. It holds no state; the same code feeds the web
// dashboard and the stored draft brief (FR-9/FR-10).
package dashboard

import (
	"fmt"
	"sort"
	"strings"
	"time"

	"gitea.lab.audasmedia.com.au/sam/compass_teams_nhs/internal/store"
)

// Buckets is one child's items, split into the sections the dashboard shows.
// Later and NoDue are counted but not given a heading of their own unless they
// carry work, so the page stays brief (AGENTS.md §10 rule 6).
type Buckets struct {
	Overdue  []store.Item
	DueToday []store.Item
	DueWeek  []store.Item
	NoDue    []store.Item
	Messages []store.Item
	// Later is work due after this week; Done is submitted work. Both are kept
	// so the summary can count them and nothing is silently dropped.
	Later []store.Item
	Done  []store.Item
}

// Actionable is the number of task items that still need doing.
func (b Buckets) Actionable() int {
	return len(b.Overdue) + len(b.DueToday) + len(b.DueWeek) + len(b.NoDue)
}

// Empty reports whether the child has nothing to show at all.
func (b Buckets) Empty() bool {
	return b.Actionable() == 0 && len(b.Messages) == 0
}

// Headline is the one-line summary used at the top of a child tab and in the
// brief.
func (b Buckets) Headline() string {
	return fmt.Sprintf("%d overdue · %d due today · %d this week · %d message(s)",
		len(b.Overdue), len(b.DueToday), len(b.DueWeek), len(b.Messages))
}

// Classify splits items into buckets for one child.
//
// A task counts as overdue when Compass says so ("Status: Overdue" or
// "Submitted: Overdue"), or when it is not submitted and its due date is
// before today. Submitted work (On Time / Received Late) is not "due", so it
// is kept out of the due lists (the parser stores every historical task; the
// dashboard shows what still needs doing).
func Classify(items []store.Item, now time.Time, loc *time.Location) Buckets {
	if loc == nil {
		loc = time.UTC
	}
	startToday := startOfDay(now, loc)
	endToday := startToday.AddDate(0, 0, 1)
	endWeek := startToday.AddDate(0, 0, 7)

	var b Buckets
	for _, it := range items {
		switch it.Type {
		case "message":
			b.Messages = append(b.Messages, it)
			continue
		case "task":
			// handled below
		case "event":
			// A lesson or event is never "overdue": a past lesson is history, not
			// work to do. Only today and the coming week are shown.
			if it.DueAt == nil {
				continue
			}
			due := it.DueAt.In(loc)
			switch {
			case !due.Before(startToday) && due.Before(endToday):
				b.DueToday = append(b.DueToday, it)
			case !due.Before(endToday) && due.Before(endWeek):
				b.DueWeek = append(b.DueWeek, it)
			case !due.Before(endWeek):
				b.Later = append(b.Later, it)
			}
			continue
		default:
			continue
		}

		status := Status(it.Body)
		if isSubmitted(status) {
			b.Done = append(b.Done, it)
			continue
		}
		if it.DueAt == nil {
			b.NoDue = append(b.NoDue, it)
			continue
		}

		due := it.DueAt.In(loc)
		switch {
		case status == "overdue":
			b.Overdue = append(b.Overdue, it)
		case due.Before(startToday):
			b.Overdue = append(b.Overdue, it)
		case due.Before(endToday):
			b.DueToday = append(b.DueToday, it)
		case due.Before(endWeek):
			b.DueWeek = append(b.DueWeek, it)
		default:
			b.Later = append(b.Later, it)
		}
	}

	for _, s := range [][]store.Item{b.Overdue, b.DueToday, b.DueWeek, b.NoDue, b.Later, b.Done} {
		sort.SliceStable(s, func(i, j int) bool { return less(s[i], s[j]) })
	}
	sort.SliceStable(b.Messages, func(i, j int) bool {
		ti, tj := timeOf(b.Messages[i]), timeOf(b.Messages[j])
		return ti.After(tj)
	})
	return b
}

// less orders actionable items by due date, then title. A nil due date sorts last.
func less(a, b store.Item) bool {
	switch {
	case a.DueAt == nil && b.DueAt == nil:
		return a.Title < b.Title
	case a.DueAt == nil:
		return false
	case b.DueAt == nil:
		return true
	case a.DueAt.Equal(*b.DueAt):
		return a.Title < b.Title
	default:
		return a.DueAt.Before(*b.DueAt)
	}
}

func timeOf(it store.Item) time.Time {
	if it.DueAt == nil {
		return time.Time{}
	}
	return *it.DueAt
}

// Status reads the status line the parser writes into a task body: the JSON
// parser writes "Status: Overdue", the HTML grid writes "Submitted: Overdue".
// It returns a lower-case label, or "" when the body carries no status.
func Status(body string) string {
	for _, line := range strings.Split(body, "\n") {
		line = strings.TrimSpace(line)
		for _, prefix := range []string{"Status:", "Submitted:"} {
			if strings.HasPrefix(line, prefix) {
				v := strings.TrimSpace(strings.TrimPrefix(line, prefix))
				v = strings.TrimRight(v, ".")
				return strings.ToLower(v)
			}
		}
	}
	return ""
}

// submittedStatuses are the labels that mean the work no longer needs doing.
var submittedStatuses = map[string]bool{
	"on time":       true,
	"received late": true,
	"submitted":     true,
	"completed":     true,
}

func isSubmitted(status string) bool { return submittedStatuses[status] }

func startOfDay(t time.Time, loc *time.Location) time.Time {
	t = t.In(loc)
	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, loc)
}

// Render writes one child's brief as plain text: overdue first, then due today,
// due this week, no due date and messages (FR-9, FR-14, AGENTS.md §4 rule 6).
func Render(child string, b Buckets, loc *time.Location) string {
	if loc == nil {
		loc = time.UTC
	}
	var sb strings.Builder
	fmt.Fprintf(&sb, "%s — %s.\n", child, b.Headline())

	writeSection(&sb, "OVERDUE", b.Overdue, loc)
	writeSection(&sb, "DUE TODAY", b.DueToday, loc)
	writeSection(&sb, "DUE THIS WEEK", b.DueWeek, loc)
	writeSection(&sb, "NO DUE DATE", b.NoDue, loc)
	writeMessages(&sb, b.Messages, loc)
	return strings.TrimRight(sb.String(), "\n") + "\n"
}

func writeSection(sb *strings.Builder, title string, items []store.Item, loc *time.Location) {
	if len(items) == 0 {
		return
	}
	fmt.Fprintf(sb, "\n%s\n", title)
	for _, it := range items {
		fmt.Fprintf(sb, "- %s\n", line(it, loc))
	}
}

func writeMessages(sb *strings.Builder, items []store.Item, loc *time.Location) {
	if len(items) == 0 {
		return
	}
	sb.WriteString("\nMESSAGES\n")
	for _, it := range items {
		when := ""
		if it.DueAt != nil {
			when = " (" + it.DueAt.In(loc).Format("Mon 02 Jan 15:04") + ")"
		}
		fmt.Fprintf(sb, "- %s%s\n", it.Title, when)
	}
}

// line renders one actionable item for the brief.
func line(it store.Item, loc *time.Location) string {
	subject := strings.TrimSpace(it.Subject)
	title := strings.TrimSpace(it.Title)
	switch {
	case subject != "" && subject != title:
		title = subject + ": " + title
	}
	due := ""
	if it.DueAt != nil {
		due = " (due " + it.DueAt.In(loc).Format("Mon 02 Jan 15:04") + ")"
	}
	status := Status(it.Body)
	mark := ""
	if status != "" && status != "pending" {
		mark = " [" + status + "]"
	}
	return title + due + mark
}