api

type BodyFormatter interface {
	Section(title string, content []string) []string
	Link(url, text string) string
	LineBreak() string
}

type GitHub struct {
	GraphQLClient *api.GraphQLClient
	*github.Client
	Host       string
	Owner      string
	Repository string
	// contains filtered or unexported fields
}

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

type HTMLBodyFormatter struct{}

type PullRequest struct {
	ID  string
	URL string
	// State is what the provider reports the pull request as. An empty one is a
	// provider that does not say, which every caller treats as open, because that is
	// what the only lookup maiao had before this reported.
	State PullRequestState
	// Base is the branch the pull request currently targets on the provider. It
	// is what tells a review whose stack has been reordered which pull requests
	// have to be moved out of the way before the branches are pushed.
	Base string
}

type PullRequestOptions struct {
	Base             string
	Head             string
	Title            string
	Body             string
	WIP              bool
	Ready            bool
	ParentPullNumber string
}

type PullRequestState string

type PullRequester interface {
	// Update defines the interface to create or update a pull request to match options
	Update(context.Context, *PullRequest, PullRequestOptions) (*PullRequest, error)
	// Ensure ensures one and only one pull request exists for the given head
	Ensure(context.Context, PullRequestOptions) (*PullRequest, bool, error)
	// Find returns the pull request for the given head branch whatever state it is
	// in, or nil when there is none. Unlike Ensure it never creates one, so it can
	// be called before the head branch exists on the remote.
	//
	// It reports closed pull requests because a review that only looked at the open
	// ones opened a second pull request beside a closed one for the same change,
	// leaving its conversation behind. The caller decides what a given state is
	// good for: State says which.
	Find(ctx context.Context, head string) (*PullRequest, error)
	LinkedTopicIssues(topicSearchString string) string
	DefaultBranch(context.Context) string
	// StackManager returns the stack manager if native stacks are supported, or nil.
	StackManager() StackManager
	// BodyFormatter returns the formatter used to render PR body sections.
	BodyFormatter() BodyFormatter
}

type Repo struct {
	// Domain is the domain the API is exposed on
	Domain string
	// Repository is the name of the repository exposed on the API
	// (owner/repository for github repositories)
	Repository string
	// Username contains the name of the authenticated user
	// accessing the repository API
	Username string
	// Password contains the password of the authenticated user
	// accessing the repository API
	Password string
}

type Stack struct {
	ID  string
	PRs []int
}

type StackManager interface {
	// CreateOrUpdateStack registers a set of PRs as a GitHub native stack.
	// prNumbers must be ordered bottom-to-top (first targets the base branch).
	CreateOrUpdateStack(ctx context.Context, prNumbers []int) (*Stack, error)
	// GetStack retrieves the stack associated with a given PR number.
	GetStack(ctx context.Context, prNumber int) (*Stack, error)
	// Unstack dissolves a stack, leaving each pull request open on the base
	// branch it currently targets.
	//
	// It is all or nothing: GitHub offers no way to take one pull request out of
	// a stack, and none to reorder one, so a stack whose order has changed can
	// only be rebuilt by dissolving it and creating it again.
	// See https://docs.github.com/en/rest/pulls/stacks.
	//
	// Pull requests that cannot be unstacked, such as those queued for merge, are
	// left in the stack, and the call still succeeds.
	Unstack(ctx context.Context, stackID string) error
	// Available reports whether the GitHub Stack API is supported on this instance.
	Available(ctx context.Context) bool
}