query

type AccountInfo struct {
	ID          int64
	SourceType  string
	Identifier  string // email address
	DisplayName string
}

type Address struct {
	Email string
	Name  string
}

type AggregateFunc func(ctx context.Context, opts AggregateOptions) ([]AggregateRow, error)

type AggregateOptions struct {
	// Account filter
	SourceID *int64 // nil means all accounts

	// Date range
	After  *time.Time
	Before *time.Time

	// Sorting
	SortField     SortField
	SortDirection SortDirection

	// Limit results (0 means default, typically 100)
	Limit int

	// Time-specific options
	TimeGranularity TimeGranularity

	// Filter options
	WithAttachmentsOnly bool

	// Text search filter (filters aggregates to only include messages matching search)
	SearchQuery string
}

type AggregateRow struct {
	Key             string // email, domain, label name, or time period
	Count           int64  // number of messages
	TotalSize       int64  // sum of size_estimate in bytes
	AttachmentSize  int64  // sum of attachment sizes in bytes
	AttachmentCount int64  // number of attachments
	TotalUnique     int64  // total unique keys (same for all rows, computed via COUNT(*) OVER())
}

type AttachmentInfo struct {
	ID          int64
	Filename    string
	MimeType    string
	Size        int64
	ContentHash string
}

type DuckDBEngine struct {
	// contains filtered or unexported fields
}

type Engine interface {
	// Aggregate queries - return rows grouped by key
	AggregateBySender(ctx context.Context, opts AggregateOptions) ([]AggregateRow, error)
	AggregateBySenderName(ctx context.Context, opts AggregateOptions) ([]AggregateRow, error)
	AggregateByRecipient(ctx context.Context, opts AggregateOptions) ([]AggregateRow, error)
	AggregateByRecipientName(ctx context.Context, opts AggregateOptions) ([]AggregateRow, error)
	AggregateByDomain(ctx context.Context, opts AggregateOptions) ([]AggregateRow, error)
	AggregateByLabel(ctx context.Context, opts AggregateOptions) ([]AggregateRow, error)
	AggregateByTime(ctx context.Context, opts AggregateOptions) ([]AggregateRow, error)

	// SubAggregate performs aggregation on a filtered subset of messages.
	// This is used for sub-grouping after drill-down, e.g., drilling into
	// "Sender: foo@example.com" and then sub-grouping by Recipients or Labels.
	// The filter specifies the parent context (sender, domain, etc.) and
	// groupBy specifies what dimension to aggregate by.
	SubAggregate(ctx context.Context, filter MessageFilter, groupBy ViewType, opts AggregateOptions) ([]AggregateRow, error)

	// Message queries
	ListMessages(ctx context.Context, filter MessageFilter) ([]MessageSummary, error)
	GetMessage(ctx context.Context, id int64) (*MessageDetail, error)
	GetMessageBySourceID(ctx context.Context, sourceMessageID string) (*MessageDetail, error)
	GetAttachment(ctx context.Context, id int64) (*AttachmentInfo, error)

	// Search - full-text search using FTS5 (includes message body)
	Search(ctx context.Context, query *search.Query, limit, offset int) ([]MessageSummary, error)

	// SearchFast searches message metadata only (no body text).
	// This is much faster for large archives as it queries Parquet files directly.
	// Searches: subject, sender email/name (case-insensitive).
	// The filter parameter allows contextual search within a drill-down.
	SearchFast(ctx context.Context, query *search.Query, filter MessageFilter, limit, offset int) ([]MessageSummary, error)

	// SearchFastCount returns the total count of messages matching a search query.
	// This is used for pagination UI to show "N of M results".
	SearchFastCount(ctx context.Context, query *search.Query, filter MessageFilter) (int64, error)

	// GetGmailIDsByFilter returns Gmail message IDs (source_message_id) matching a filter.
	// This is useful for batch operations like staging messages for deletion.
	GetGmailIDsByFilter(ctx context.Context, filter MessageFilter) ([]string, error)

	// Account queries
	ListAccounts(ctx context.Context) ([]AccountInfo, error)

	// Stats
	GetTotalStats(ctx context.Context, opts StatsOptions) (*TotalStats, error)

	// Close releases any resources held by the engine.
	Close() error
}

type MessageDetail struct {
	ID              int64
	SourceMessageID string
	ConversationID  int64
	Subject         string
	Snippet         string
	SentAt          time.Time
	ReceivedAt      *time.Time
	SizeEstimate    int64
	HasAttachments  bool

	// Participants
	From []Address
	To   []Address
	Cc   []Address
	Bcc  []Address

	// Content
	BodyText string
	BodyHTML string

	// Metadata
	Labels      []string
	Attachments []AttachmentInfo
}

type MessageFilter struct {
	// Filter by aggregate key
	Sender        string // filter by sender email
	SenderName    string // filter by sender display name (COALESCE(display_name, email))
	Recipient     string // filter by recipient email
	RecipientName string // filter by recipient display name (COALESCE(display_name, email))
	Domain        string // filter by sender domain
	Label         string // filter by label name

	// Filter by conversation (thread)
	ConversationID *int64 // filter by conversation/thread ID

	// MatchEmpty* flags change how empty filter values are interpreted for each field.
	// When false (default): empty string means "no filter" (return all)
	// When true: empty string means "filter for NULL/empty values"
	// This enables drilldown into empty-bucket aggregates (e.g., messages with no sender).
	//
	// IMPORTANT: Only set ONE MatchEmpty* flag at a time. Setting multiple flags
	// creates an AND condition that may return no results (e.g., messages with
	// no sender AND no recipient AND no domain). The TUI sets exactly one flag
	// based on the current view type when drilling into an empty aggregate bucket.
	MatchEmptySender        bool
	MatchEmptySenderName    bool
	MatchEmptyRecipient     bool
	MatchEmptyRecipientName bool
	MatchEmptyDomain        bool
	MatchEmptyLabel         bool

	// Time range
	TimePeriod      string // e.g., "2024", "2024-01", "2024-01-15"
	TimeGranularity TimeGranularity

	// Account filter
	SourceID *int64 // nil means all accounts

	// Date range
	After  *time.Time
	Before *time.Time

	// Content filter
	WithAttachmentsOnly bool // only return messages with attachments

	// Pagination
	Limit  int
	Offset int

	// Sorting
	SortField     MessageSortField
	SortDirection SortDirection
}

type MessageSortField int

type MessageSummary struct {
	ID              int64
	SourceMessageID string
	ConversationID  int64
	Subject         string
	Snippet         string
	FromEmail       string
	FromName        string
	SentAt          time.Time
	SizeEstimate    int64
	HasAttachments  bool
	AttachmentCount int
	Labels          []string
	DeletedAt       *time.Time // When message was deleted from server (nil if not deleted)
}

type ParquetSyncState struct {
	LastMessageID int64     `json:"last_message_id"`
	LastSyncAt    time.Time `json:"last_sync_at,omitempty"`
}

type SQLiteEngine struct {
	// contains filtered or unexported fields
}

type SortDirection int

type SortField int

type StatsOptions struct {
	SourceID            *int64   // nil means all accounts
	WithAttachmentsOnly bool     // only count messages with attachments
	SearchQuery         string   // when set, stats reflect only messages matching this search
	GroupBy             ViewType // when set, search filters on this view's key columns instead of subject+sender
}

type TimeGranularity int

type TotalStats struct {
	MessageCount    int64
	TotalSize       int64
	AttachmentCount int64
	AttachmentSize  int64
	LabelCount      int64
	AccountCount    int64
}

type ViewType int