pkg

type ActionConfig struct {
	Subscribe SubscribeActionConfig `yaml:"subscribe"`
	Email     EmailActionConfig     `yaml:"email"`
}

type Actioninator interface {
	WithAction(action GitHubItemAction) Actioninator
	Handle(ctx context.Context, item GitHubItem, logger *slog.Logger) error
}

type Config struct {
	// User is the GitHub username the watch will apply to.
	User string `yaml:"user"`
	// PATFile is the file containing the user's PAT used for authentication.
	PATFile string `yaml:"patFile"`
	// PAT is the PAT contained in the PATFile.
	PAT string `yaml:"-"`
	// Interval used to determine when to update watches.
	Interval time.Duration `yaml:"interval"`
	// Email sender configuration for email action.
	Email EmailConfig `yaml:"email"`
	// Watches is a list of Watch definitions.
	Watches []*Watch `yaml:"watches"`
}

type Configinator interface {
	// Watch will continually watch the given config path for changes.
	// If a change occurs, the new config will be validated and sent to the given callback.
	// If an error occurs, the watch stops and the error is returned.
	Watch(ctx context.Context, path string, callback func(*Config), gh GitHubinator, e Emailinator) error
}

type EmailActionConfig struct {
	Enabled bool   `yaml:"enabled"`
	SendTo  string `yaml:"sendTo"`
}

type EmailConfig struct {
	// Username to login to SMTP service with. Should be the same as the
	// sender email address.
	Username string `yaml:"username"`
	// PasswordFile containing the password used to login to the SMTP service.
	PasswordFile string `yaml:"passwordFile"`
	// Password contained within the PasswordFile
	Password string `yaml:"-"`
	// Host address of the SMTP service (ie smtp.gmail.com).
	Host string `yaml:"host"`
	// Port of the SMTP service to connect to.
	Port int `yaml:"port"`
}

type Emailinator interface {
	TestConnection(ctx context.Context) error
	Send(ctx context.Context, msg *mail.Msg) error
	WithConfig(cfg *EmailConfig) Emailinator
	NewMsg() (*mail.Msg, error)
}

type GitHubActor struct {
	Login string `json:"login"`
}

type GitHubIssue struct {
	Author       GitHubActor                `json:"author"`
	Body         string                     `json:"body"`
	Labels       []string                   `json:"labels"`
	Number       int                        `json:"number"`
	State        githubv4.IssueState        `json:"state"`
	Subscription githubv4.SubscriptionState `json:"Subscription"`
	Title        string                     `json:"title"`
	UpdatedAt    time.Time                  `json:"updatedAt"`
}

type GitHubIssueFilter struct {
	Labels []string
	States []string
}

type GitHubItem struct {
	GitHubIssue
	Type GitHubItemType   `json:"type"`
	Repo GitHubRepository `json:"repo"`
	ID   githubv4.ID      `json:"id"`
}

type GitHubItemAction struct {
	Handle func(ctx context.Context, i GitHubItem, logger *slog.Logger) error
	Name   string
}

type GitHubItemMatcher struct {
	// Matcher is a function that takes in a GitHubItem and returns a boolean specifying if the item was matched.
	Matcher func(i *GitHubItem) bool
	// Name is used to identify the above Matcher; helpful for debug logs.
	Name string
}

type GitHubItemType string

type GitHubLabel struct {
	Name string `json:"name"`
}

type GitHubNotFoundError error

type GitHubRepository struct {
	Owner string `json:"owner" yaml:"owner"`
	Name  string `json:"name" yaml:"name"`
}

type GitHubinator interface {
	// WithRetries will set the number of retries the GitHubinator will use when fetching or updating data.
	WithRetries(retries int) GitHubinator

	// WithTimeout sets the amount of time per try that the GitHubinator will wait for success before assuming a
	// request has failed.
	WithTimeout(timeout time.Duration) GitHubinator

	// WithToken sets the authentication token to use for the GH API, such as a PAT.
	// A test request will be sent to GitHub to verify authentication.
	WithToken(token string) GitHubinator

	// WhoAmI will make a test query to GitHub to get the name and login for the given PAT.
	WhoAmI(ctx context.Context) (string, error)

	// CheckRepository checks if the given repository exists.
	CheckRepository(ctx context.Context, ghr GitHubRepository) error

	// ListIssues returns a list of issues for the given repository.
	ListIssues(
		ctx context.Context, ghr GitHubRepository, filter *GitHubIssueFilter, matcher Matchinator,
	) ([]*GitHubItem, error)

	// SetSubscription sets the subscription state of the given item for the viewer.
	SetSubscription(ctx context.Context, id githubv4.ID, state githubv4.SubscriptionState) error
}

type LogOptions struct {
	// LogUseJSON, if true, will output JSON-formatted logs. Otherwise, if false, text-formatted logs are outputted.
	LogUseJSON bool
	// LogVerbose, if true, sets the log level to Debug, increasing verbosity. Otherwise, if false, the log level is
	// set to Info.
	LogVerbose bool
	// LogShowTime, if true, will add timestamps to log messages. Otherwise, if false, timestamps will be omitted.
	LogShowTime bool
}

type Matchinator interface {
	// WithMatchFunc as a new GitHubItemMatcher to the list of critieria.
	WithMatchFunc(match GitHubItemMatcher) Matchinator

	// WithSelectors adds the given k8s.io/apimachinery/pkg/labels.Selectors to the match criteria.
	WithSelectors(selectors ...labels.Selector) Matchinator

	// WithBodyRegexes adds the given bodyRegexes to the match critieria.
	WithBodyRegexes(bodyRegexes ...*regexp.Regexp) Matchinator

	// WithTitleRegexes adds the given titleRegexes to the match critieria.
	WithTitleRegexes(titleRegexes ...*regexp.Regexp) Matchinator

	// HasBodyRegex returns if a bodyRegex is part of the match criteria.
	HasBodyRegex() bool

	// WithRequiredLabels adds the given labels to the match criteria.
	WithRequiredLabels(labels ...string) Matchinator

	// HasRequiredLabels returns if a label is part of the match criteria.
	HasRequiredLabels() bool

	// Matches returns a boolean specifying if the GitHubItem matched the configured criteria. If no criteria is
	// configured, then this function always returns true.
	Matches(item *GitHubItem) (bool, string)
}

type MockEmailinator struct {
	TestConnectionError error
	SendError           error
	NewMsgError         error
}

type MockGitHubinator struct {
	// CheckRepositoryRequests holds th parameters to calls to CheckRepository.
	CheckRepositoryRequests []GitHubRepository

	// CheckRepositoryError holds the returned error for CheckRepository.
	CheckRepositoryError error

	// WhoAmIRequests holds the number of times WhoAmI has been called
	WhoAmIRequests int

	// WhoAmIReturn holds the user returned from calls to WhoAmI.
	WhoAmIReturn string

	// WhoAmIError holds the errors that will be returned from WhoAmI.
	WhoAmIError error

	// SetSubscriptionRequests holds the issue IDs passed to SetSubscription.
	SetSubscriptionRequests []githubv4.ID

	// SetSubscriptionError holds the returned error for SetSubscription
	SetSubscriptionError error
}

type Pollinator interface {
	// Add creates a new poll, whose callback will be executed on the given interval.
	// If the given poll already exists, then it is updated with the given interval and callback.
	// The argument doInitialCallback can be used to toggle if the poll is executed for the first time after the
	// call to Add, or if the poll is executed for the first time after the given interval.
	Add(name string, interval time.Duration, callback func(t time.Time), doInitialCallback bool)

	// Delete removes the poll by the given name. If it doesn't exist, then this is a no-op.
	Delete(name string)

	// List returns a slice containing the names of all the polls currently running.
	List() []string

	// StopAll stops all the added polls, blocking until all exit. Use this as a cleanup.
	StopAll()
}

type SubscribeActionConfig struct {
	Enabled bool `yaml:"enabled"`
}

type Watch struct {
	// Name is a human-readable description of the watch.
	Name string `yaml:"name"`
	// Repositories to watch issues from.
	Repositories []GitHubRepository `yaml:"repos"`
	// Selectors are used to specify which items to watch, follows the k8s label selector syntax.
	// See the GitHubItem struct for valid keys and fields and
	// https://pkg.go.dev/k8s.io/apimachinery@v0.27.1/pkg/labels#Parse for the syntax.
	Selectors []string `yaml:"selectors"`

	// RequiredLabels are a list of labels that must be present for an item to be watched. An item must have all of
	// these labels to be watched.
	RequiredLabels []string `yaml:"requiredLabels"`
	// SearchLabels are a set of labels that will be used to find new items. They will not be used as criteria for if
	// an item is watched, but if an item is discovered from GitHub.
	SearchLabels []string `yaml:"searchLabels"`
	// BodyRegex is a list of regex expressions which must match the item's body.
	BodyRegex []string `yaml:"bodyRegex"`

	// TitleRegex is a list of regex expressions which must match the item's title.
	TitleRegex []string `yaml:"titleRegex"`

	// States are a list of issues states to filter by.
	States []string `yaml:"states"`
	// Actions are a list of actions to perform when an item matches the set of filters.
	Actions ActionConfig `yaml:"actions"`
	// contains filtered or unexported fields
}

type Watchinator interface {
	// Watch is the 'main' function of the Watchinator, which sets up both a Pollinator and a Configinator to
	// watch GitHub for new items and subscribe to them as needed.
	Watch(ctx context.Context, configFilePath string) error
}