tui

type Calendar struct {
	ID   int64
	Name string
	// OwnerEmail is the account the calendar belongs to, which is what tells two calendars of
	// the same name apart — a reader with a work account and a personal one has two "Maybe"s
	// and no way to know which is which from the name. It is what the web app shows under a
	// calendar in its own list.
	OwnerEmail string
	Color      string
	Personal   bool
	// External is a calendar HEY subscribes to rather than owns — haystack's `internal`
	// scope is `where.missing(:subscription)`, and this is the other side of it.
	External bool
}

type CalendarWatcher func(ctx, connectionCtx context.Context) (<-chan struct{}, error)

type CalendarYear struct {
	// PaddingDays is how many cells sit before January 1st, so the grid lines up under
	// the reader's first weekday.
	PaddingDays   int
	Days          []YearDay
	SpannedEvents []Recording
}

type Contact struct {
	ID           int64
	Name         string
	EmailAddress string
	Aliases      []Contact
}

type MailConnection uint8

type MailWatchEvent struct {
	BoxID         int64
	Connection    MailConnection
	WillReconnect bool
}

type MailWatcher func(ctx context.Context) (<-chan MailWatchEvent, error)

type OngoingTrack struct {
	ID        int64
	Category  string
	StartedAt time.Time
}

type OpenRequest struct {
	TopicID   int64  `json:"topic_id,omitempty"`
	AccountID int64  `json:"account_id,omitempty"`
	Title     string `json:"title,omitempty"`
	Screener  bool   `json:"screener,omitempty"`
}

type Options struct {
	Open     OpenRequest
	Instance string
}

type Recording struct {
	ID       int64
	ParentID int64
	Title    string
	AllDay   bool
	StartsAt time.Time
	EndsAt   time.Time
	Type     string
	// StartsAtZone and EndsAtZone are the IANA names of the zones the event was set in, and
	// they are empty for most events — HEY serves them only for one saved with a zone of its
	// own. They do not move the event: it is at one instant whatever zone it was set in, and
	// the calendar draws it where the reader's clock puts it. What they are for is the form,
	// which shows a zoned event on the clock it was written on.
	StartsAtZone string
	EndsAtZone   string
	CompletedAt  time.Time
	Label        string
	Icon         string
	// Color is a habit's own color. An event has none — what it wears is its
	// calendar's, which is CalendarColor, and the two are different fields in HEY too.
	Color string
	// Notes, Location, Link, Attendees and AttachedEntryID are what an event carries besides
	// when it is. They are read as well as written because HEY's update clears the lot of them
	// on any write that leaves them out — so an edit form that did not know them would wipe an
	// event's notes and location every time somebody changed its name.
	//
	// Notes arrive as plain text however they were written: HEY serves the description through
	// to_plain_text, so formatting cannot survive a round trip through any client.
	Notes           string
	Location        string
	Link            string
	Attendees       []string
	AttachedEntryID int64
	// Highlighted is what HEY calls the web app's "Circle event".
	Highlighted bool
	// Recurring and RepeatKind are how an event repeats. The kind is served but neither the
	// date it runs until nor the number of times, which is why an edit form can keep a
	// schedule or replace it but cannot show what it is bounded by.
	Recurring  bool
	RepeatKind string
	// ParentTitle is the title of the recording this one hangs off, which is the only place
	// some recordings have one: a countdown carries a label — "10 days before" — and no title
	// of its own, because what it is counting down to is the event above it.
	ParentTitle string
	// OccurrenceID names one instance of a repeating event — "153688907_2026-08-21", the
	// series and the day — and is what HEY serves instead of an id for an occurrence it has
	// not written down yet. Such a recording arrives with ID 0, which is why the arrows hold
	// on to key() rather than to the id: selecting by the id alone meant a repeating event
	// could never be picked out at all.
	OccurrenceID string
	// CalendarID is which calendar this is filed on, and CalendarColor how a reader tells
	// whose event they are looking at. HEY leaves the color empty for the personal calendar
	// and two calendars can wear the same one, so the id is what the edit form matches on and
	// the color only what it falls back to.
	CalendarID    int64
	CalendarColor string
	Days          []int32
}

type ScreenerWatcher func(ctx, connectionCtx context.Context, signedStreamName string) (<-chan struct{}, error)

type Theme struct {
	Accent    color.Color
	Selection color.Color // nil when the theme gives no selection background
	Muted     color.Color
	Bright    color.Color
	Error     color.Color

	// Background is the theme's own paper, and Hues are the colors it renders the ANSI
	// slots as — both nil when no theme file said. They matter for anything drawn *on*
	// a hue: an ANSI slot's nominal value says nothing about what a reader sees, since
	// a theme retints the running terminal over OSC 4. ANSI blue is #000080 nominally
	// and a light periwinkle in a dark Omarchy theme, so ink picked against the nominal
	// value comes out backwards. Keyed by the color names HEY uses.
	Background color.Color
	Hues       map[string]color.Color

	// Dark reports whether the theme is for a dark background. HasMode is true when
	// a theme file said so; otherwise Dark is a guess the terminal can correct.
	Dark    bool
	HasMode bool

	// Trusted marks a theme the user pointed at explicitly (HEY_THEME). Trusted
	// values skip the accent and selection readability gates: the gates exist for
	// machine-derived palettes, not for a file chosen by hand.
	Trusted bool

	// Source names the file the overlay came from, "" for the ANSI defaults and
	// "NO_COLOR" when color is disabled.
	Source string
}

type Watchers struct {
	Mail     MailWatcher
	Screener ScreenerWatcher
	Calendar CalendarWatcher
}

type YearDay struct {
	Date         time.Time
	Backgrounded bool
}