folderRepositoryManager.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import { bulkhead } from 'cockatiel';
import * as vscode from 'vscode';
import type { Branch, Commit, Repository, UpstreamRef } from '../api/api';
import { GitApiImpl, GitErrorCodes } from '../api/api1';
import { GitHubManager } from '../authentication/githubServer';
import { AuthProvider, GitHubServerType } from '../common/authentication';
import { commands, contexts } from '../common/executeCommands';
import { InMemFileChange, SlimFileChange } from '../common/file';
import { findLocalRepoRemoteFromGitHubRef } from '../common/githubRef';
import Logger from '../common/logger';
import { Protocol, ProtocolType } from '../common/protocol';
import { GitHubRemote, parseRemote, parseRepositoryRemotes, Remote } from '../common/remote';
import {
	ALLOW_FETCH,
	AUTO_STASH,
	DEFAULT_MERGE_METHOD,
	GIT,
	PR_SETTINGS_NAMESPACE,
	PULL_BEFORE_CHECKOUT,
	PULL_BRANCH,
	REMOTES,
	UPSTREAM_REMOTE,
} from '../common/settingKeys';
import { ITelemetry } from '../common/telemetry';
import { EventType } from '../common/timelineEvent';
import { Schemes } from '../common/uri';
import { compareIgnoreCase, formatError, Predicate } from '../common/utils';
import { PULL_REQUEST_OVERVIEW_VIEW_TYPE } from '../common/webview';
import { NEVER_SHOW_PULL_NOTIFICATION, REPO_KEYS, ReposState } from '../extensionState';
import { git } from '../gitProviders/gitCommands';
import { OctokitCommon } from './common';
import { ConflictModel } from './conflictGuide';
import { ConflictResolutionCoordinator } from './conflictResolutionCoordinator';
import { Conflict, ConflictResolutionModel } from './conflictResolutionModel';
import { CredentialStore } from './credentials';
import { GitHubRepository, GraphQLError, GraphQLErrorType, ItemsData, PullRequestData, TeamReviewerRefreshKind, ViewerPermission } from './githubRepository';
import { MergeMethod as GraphQLMergeMethod, MergePullRequestInput, MergePullRequestResponse, PullRequestState, UserResponse } from './graphql';
import { IAccount, ILabel, IMilestone, IProject, IPullRequestsPagingOptions, Issue, ITeam, MergeMethod, PRType, PullRequestMergeability, RepoAccessAndMergeMethods, User } from './interface';
import { IssueModel } from './issueModel';
import { PullRequestGitHelper, PullRequestMetadata } from './pullRequestGitHelper';
import { IResolvedPullRequestModel, PullRequestModel } from './pullRequestModel';
import {
	convertRESTIssueToRawPullRequest,
	convertRESTPullRequestToRawPullRequest,
	getOverrideBranch,
	loginComparator,
	parseGraphQLUser,
	teamComparator,
	variableSubstitution,
} from './utils';

async function createConflictResolutionModel(pullRequest: PullRequestModel): Promise<ConflictResolutionModel | undefined> {
	const head = pullRequest.head;
	if (!head) {
		throw new Error('No head found for pull request');
	}
	const baseCommitSha = await pullRequest.getLatestBaseCommitSha();
	const prBaseOwner = pullRequest.base.owner;
	const prHeadOwner = head.owner;
	const prHeadRef = head.ref;
	const repositoryName = (await pullRequest.githubRepository.ensure()).remote.repositoryName;
	const potentialMergeConflicts: Conflict[] = [];
	if (pullRequest.item.mergeable === PullRequestMergeability.Conflict) {
		const mergeBaseIntoPrCompareData = await pullRequest.compareBaseBranchForMerge(prHeadOwner, prHeadRef, prBaseOwner, baseCommitSha);
		if ((pullRequest.item.mergeable === PullRequestMergeability.Conflict) && (mergeBaseIntoPrCompareData.length >= 300)) {
			// API limitation: it only returns the first 300 files
			return undefined;
		}

		const previousFilenames: Map<string, SlimFileChange | InMemFileChange> = new Map();
		// We must also check all the previous file names of the files in the PR. Assemble a map with this info
		for (const fileChange of pullRequest.fileChanges.values()) {
			if (fileChange.previousFileName) {
				previousFilenames.set(fileChange.previousFileName, fileChange);
			}
		}
		const knownConflicts = new Set<string>(pullRequest.conflicts);
		for (const mergeFile of mergeBaseIntoPrCompareData) {
			const fileChange = pullRequest.fileChanges.get(mergeFile.filename) ?? previousFilenames.get(mergeFile.filename);
			if (fileChange && (knownConflicts.size === 0 || knownConflicts.has(fileChange.fileName))) {
				const prHeadFilePath = fileChange.fileName;
				let contentsConflict = false;
				let filePathConflict = false;
				let modeConflict = false;
				if (mergeFile.status === 'modified') {
					contentsConflict = true;
				}
				if (mergeFile.previous_filename || fileChange.previousFileName) {
					filePathConflict = true;
				}
				potentialMergeConflicts.push({ prHeadFilePath, contentsConflict, filePathConflict, modeConflict });
			}
		}
	}
	return new ConflictResolutionModel(potentialMergeConflicts, repositoryName, prBaseOwner, baseCommitSha, prHeadOwner, prHeadRef,
		pullRequest.base.ref, pullRequest.mergeBase!);
}

interface PageInformation {
	pullRequestPage: number;
	hasMorePages: boolean | null;
}

export interface ItemsResponseResult<T> {
	items: T[];
	hasMorePages: boolean;
	hasUnsearchedRepositories: boolean;
}

export class NoGitHubReposError extends Error {
	constructor(public repository: Repository) {
		super();
	}

	get message() {
		return vscode.l10n.t('{0} has no GitHub remotes', this.repository.rootUri.toString());
	}
}

export class DetachedHeadError extends Error {
	constructor(public repository: Repository) {
		super();
	}

	get message() {
		return vscode.l10n.t('{0} has a detached HEAD (create a branch first', this.repository.rootUri.toString());
	}
}

export class BadUpstreamError extends Error {
	constructor(public branchName: string, public upstreamRef: UpstreamRef, public problem: string) {
		super();
	}

	get message() {
		const {
			upstreamRef: { remote, name },
			branchName,
			problem,
		} = this;
		return vscode.l10n.t('The upstream ref {0} for branch {1} {2}.', `${remote}/${name}`, branchName, problem);
	}
}

export const ReposManagerStateContext: string = 'ReposManagerStateContext';

export enum ReposManagerState {
	Initializing = 'Initializing',
	NeedsAuthentication = 'NeedsAuthentication',
	RepositoriesLoaded = 'RepositoriesLoaded',
}

export interface PullRequestDefaults {
	owner: string;
	repo: string;
	base: string;
}

enum PagedDataType {
	PullRequest,
	IssueSearch,
}

const CACHED_TEMPLATE_BODY = 'templateBody';

export class FolderRepositoryManager implements vscode.Disposable {
	static ID = 'FolderRepositoryManager';

	private _subs: vscode.Disposable[];
	private _activePullRequest?: PullRequestModel;
	private _activeIssue?: IssueModel;
	private _githubRepositories: GitHubRepository[];
	private _allGitHubRemotes: GitHubRemote[] = [];
	private _mentionableUsers?: { [key: string]: IAccount[] };
	private _fetchMentionableUsersPromise?: Promise<{ [key: string]: IAccount[] }>;
	private _assignableUsers?: { [key: string]: IAccount[] };
	private _teamReviewers?: { [key: string]: ITeam[] };
	private _fetchAssignableUsersPromise?: Promise<{ [key: string]: IAccount[] }>;
	private _fetchTeamReviewersPromise?: Promise<{ [key: string]: ITeam[] }>;
	private _gitBlameCache: { [key: string]: string } = {};
	private _githubManager: GitHubManager;
	private _repositoryPageInformation: Map<string, PageInformation> = new Map<string, PageInformation>();
	private _addedUpstreamCount: number = 0;

	private _onDidMergePullRequest = new vscode.EventEmitter<void>();
	readonly onDidMergePullRequest = this._onDidMergePullRequest.event;

	private _onDidChangeActivePullRequest = new vscode.EventEmitter<{ new: number | undefined, old: number | undefined }>();
	readonly onDidChangeActivePullRequest: vscode.Event<{ new: number | undefined, old: number | undefined }> = this._onDidChangeActivePullRequest.event;
	private _onDidChangeActiveIssue = new vscode.EventEmitter<void>();
	readonly onDidChangeActiveIssue: vscode.Event<void> = this._onDidChangeActiveIssue.event;

	private _onDidLoadRepositories = new vscode.EventEmitter<ReposManagerState>();
	readonly onDidLoadRepositories: vscode.Event<ReposManagerState> = this._onDidLoadRepositories.event;

	private _onDidChangeRepositories = new vscode.EventEmitter<void>();
	readonly onDidChangeRepositories: vscode.Event<void> = this._onDidChangeRepositories.event;

	private _onDidChangeAssignableUsers = new vscode.EventEmitter<IAccount[]>();
	readonly onDidChangeAssignableUsers: vscode.Event<IAccount[]> = this._onDidChangeAssignableUsers.event;

	private _onDidChangeGithubRepositories = new vscode.EventEmitter<GitHubRepository[]>();
	readonly onDidChangeGithubRepositories: vscode.Event<GitHubRepository[]> = this._onDidChangeGithubRepositories.event;

	private _onDidDispose = new vscode.EventEmitter<void>();
	readonly onDidDispose: vscode.Event<void> = this._onDidDispose.event;

	constructor(
		private _id: number,
		public context: vscode.ExtensionContext,
		private _repository: Repository,
		public readonly telemetry: ITelemetry,
		private _git: GitApiImpl,
		private _credentialStore: CredentialStore,
	) {
		this._subs = [];
		this._githubRepositories = [];
		this._githubManager = new GitHubManager();

		this._subs.push(
			vscode.workspace.onDidChangeConfiguration(async e => {
				if (e.affectsConfiguration(`${PR_SETTINGS_NAMESPACE}.${REMOTES}`)) {
					await this.updateRepositories();
				}
			}),
		);

		this._subs.push(_credentialStore.onDidInitialize(() => this.updateRepositories()));

		this.cleanStoredRepoState();
	}

	private cleanStoredRepoState() {
		const deleteDate: number = new Date().valueOf() - 30 /*days*/ * 86400000 /*milliseconds in a day*/;
		const reposState = this.context.globalState.get<ReposState>(REPO_KEYS);
		if (reposState?.repos) {
			let keysChanged = false;
			Object.keys(reposState.repos).forEach(repo => {
				const repoState = reposState.repos[repo];
				if ((repoState.stateModifiedTime ?? 0) < deleteDate) {
					keysChanged = true;
					delete reposState.repos[repo];
				}
			});
			if (keysChanged) {
				this.context.globalState.update(REPO_KEYS, reposState);
			}
		}
	}

	private get id(): string {
		return `${FolderRepositoryManager.ID}+${this._id}`;
	}

	get gitHubRepositories(): GitHubRepository[] {
		return this._githubRepositories;
	}

	public async computeAllUnknownRemotes(): Promise<Remote[]> {
		const remotes = parseRepositoryRemotes(this.repository);
		const potentialRemotes = remotes.filter(remote => remote.host);
		const serverTypes = await Promise.all(
			potentialRemotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),
		).catch(e => {
			Logger.error(`Resolving GitHub remotes failed: ${e}`);
			vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));
			return [];
		});
		const unknownRemotes: Remote[] = [];
		let i = 0;
		for (const potentialRemote of potentialRemotes) {
			if (serverTypes[i] === GitHubServerType.None) {
				unknownRemotes.push(potentialRemote);
			}
			i++;
		}
		return unknownRemotes;
	}

	public async computeAllGitHubRemotes(): Promise<GitHubRemote[]> {
		const remotes = parseRepositoryRemotes(this.repository);
		const potentialRemotes = remotes.filter(remote => remote.host);
		const serverTypes = await Promise.all(
			potentialRemotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),
		).catch(e => {
			Logger.error(`Resolving GitHub remotes failed: ${e}`);
			vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));
			return [];
		});
		const githubRemotes: GitHubRemote[] = [];
		let i = 0;
		for (const potentialRemote of potentialRemotes) {
			if (serverTypes[i] !== GitHubServerType.None) {
				githubRemotes.push(GitHubRemote.remoteAsGitHub(potentialRemote, serverTypes[i]));
			}
			i++;
		}
		return githubRemotes;
	}

	public async getActiveGitHubRemotes(allGitHubRemotes: GitHubRemote[]): Promise<GitHubRemote[]> {
		const remotesSetting = vscode.workspace.getConfiguration(PR_SETTINGS_NAMESPACE).get<string[]>(REMOTES);

		if (!remotesSetting) {
			Logger.error(`Unable to read remotes setting`);
			return Promise.resolve([]);
		}

		const missingRemotes = remotesSetting.filter(remote => {
			return !allGitHubRemotes.some(repo => repo.remoteName === remote);
		});

		if (missingRemotes.length === remotesSetting.length) {
			Logger.warn(`No remotes found. The following remotes are missing: ${missingRemotes.join(', ')}`);
		} else {
			Logger.debug(`Not all remotes found. The following remotes are missing: ${missingRemotes.join(', ')}`, this.id);
		}

		Logger.debug(`Displaying configured remotes: ${remotesSetting.join(', ')}`, this.id);

		return remotesSetting
			.map(remote => allGitHubRemotes.find(repo => repo.remoteName === remote))
			.filter((repo: GitHubRemote | undefined): repo is GitHubRemote => !!repo);
	}

	get activeIssue(): IssueModel | undefined {
		return this._activeIssue;
	}

	set activeIssue(issue: IssueModel | undefined) {
		this._activeIssue = issue;
		this._onDidChangeActiveIssue.fire();
	}

	get activePullRequest(): PullRequestModel | undefined {
		return this._activePullRequest;
	}

	set activePullRequest(pullRequest: PullRequestModel | undefined) {
		if (pullRequest === this._activePullRequest) {
			return;
		}
		const oldNumber = this._activePullRequest?.number;
		if (this._activePullRequest) {
			this._activePullRequest.isActive = false;
		}

		if (pullRequest) {
			pullRequest.isActive = true;
			pullRequest.githubRepository.commentsHandler?.unregisterCommentController(pullRequest.number);
		}
		const newNumber = pullRequest?.number;

		this._activePullRequest = pullRequest;
		this._onDidChangeActivePullRequest.fire({ old: oldNumber, new: newNumber });
	}

	get repository(): Repository {
		return this._repository;
	}

	set repository(repository: Repository) {
		this._repository = repository;
	}

	get credentialStore(): CredentialStore {
		return this._credentialStore;
	}

	/**
	 * Using these contexts is fragile in a multi-root workspace where multiple PRs are checked out.
	 * If you have two active PRs that have the same file path relative to their rootdir, then these context can get confused.
	 */
	public setFileViewedContext() {
		const states = this.activePullRequest?.getViewedFileStates();
		if (states) {
			commands.setContext(contexts.VIEWED_FILES, Array.from(states.viewed));
			commands.setContext(contexts.UNVIEWED_FILES, Array.from(states.unviewed));
		} else {
			this.clearFileViewedContext();
		}
	}

	private clearFileViewedContext() {
		commands.setContext(contexts.VIEWED_FILES, []);
		commands.setContext(contexts.UNVIEWED_FILES, []);
	}

	public async loginAndUpdate() {
		if (!this._credentialStore.isAnyAuthenticated()) {
			const waitForRepos = new Promise<void>(c => {
				const onReposChange = this.onDidChangeRepositories(() => {
					onReposChange.dispose();
					c();
				});
			});
			await this._credentialStore.login(AuthProvider.github);
			await waitForRepos;
		}
	}

	private async getActiveRemotes(): Promise<GitHubRemote[]> {
		this._allGitHubRemotes = await this.computeAllGitHubRemotes();
		const activeRemotes = await this.getActiveGitHubRemotes(this._allGitHubRemotes);

		if (activeRemotes.length) {
			await vscode.commands.executeCommand('setContext', 'github:hasGitHubRemotes', true);
			Logger.appendLine(`Found GitHub remote for folder ${this.repository.rootUri.fsPath}`);
		} else {
			Logger.appendLine(`No GitHub remotes found for folder ${this.repository.rootUri.fsPath}`);
		}

		return activeRemotes;
	}

	private _updatingRepositories: Promise<boolean> | undefined;
	async updateRepositories(silent: boolean = false): Promise<boolean> {
		if (this._updatingRepositories) {
			await this._updatingRepositories;
		}
		this._updatingRepositories = this.doUpdateRepositories(silent);
		return this._updatingRepositories;
	}

	private checkForAuthMatch(activeRemotes: GitHubRemote[]): boolean {
		// Check that our auth matches the remote.
		let dotComCount = 0;
		let enterpriseCount = 0;
		for (const remote of activeRemotes) {
			if (remote.githubServerType === GitHubServerType.GitHubDotCom) {
				dotComCount++;
			} else if (remote.githubServerType === GitHubServerType.Enterprise) {
				enterpriseCount++;
			}
		}

		let isAuthenticated = this._credentialStore.isAuthenticated(AuthProvider.github) || this._credentialStore.isAuthenticated(AuthProvider.githubEnterprise);
		if ((dotComCount > 0) && this._credentialStore.isAuthenticated(AuthProvider.github)) {
			// good
		} else if ((enterpriseCount > 0) && this._credentialStore.isAuthenticated(AuthProvider.githubEnterprise)) {
			// also good
		} else if (isAuthenticated) {
			// Not good. We have a mismatch between auth type and server type.
			isAuthenticated = false;
		}
		vscode.commands.executeCommand('setContext', 'github:authenticated', isAuthenticated);
		return isAuthenticated;
	}

	private async doUpdateRepositories(silent: boolean): Promise<boolean> {
		if (this._git.state === 'uninitialized') {
			Logger.appendLine('Cannot updates repositories as git is uninitialized');

			return false;
		}

		const activeRemotes = await this.getActiveRemotes();
		const isAuthenticated = this.checkForAuthMatch(activeRemotes);
		if (this.credentialStore.isAnyAuthenticated() && (activeRemotes.length === 0)) {
			const areAllNeverGitHub = (await this.computeAllUnknownRemotes()).every(remote => GitHubManager.isNeverGitHub(vscode.Uri.parse(remote.normalizedHost).authority));
			if (areAllNeverGitHub) {
				this._onDidLoadRepositories.fire(ReposManagerState.RepositoriesLoaded);
				return true;
			}
		}
		const repositories: GitHubRepository[] = [];
		const resolveRemotePromises: Promise<boolean>[] = [];
		const oldRepositories: GitHubRepository[] = [];
		this._githubRepositories.forEach(repo => oldRepositories.push(repo));

		const authenticatedRemotes = activeRemotes.filter(remote => this._credentialStore.isAuthenticated(remote.authProviderId));
		for (const remote of authenticatedRemotes) {
			const repository = await this.createGitHubRepository(remote, this._credentialStore);
			resolveRemotePromises.push(repository.resolveRemote());
			repositories.push(repository);
		}

		return Promise.all(resolveRemotePromises).then(async (remoteResults: boolean[]) => {
			const missingSaml: string[] = [];
			for (let i = 0; i < remoteResults.length; i++) {
				if (!remoteResults[i]) {
					missingSaml.push(repositories[i].remote.owner);
				}
			}
			if (missingSaml.length > 0) {
				const result = await this._credentialStore.showSamlMessageAndAuth(missingSaml);
				if (result.canceled) {
					this.dispose();
					return true;
				}
			}

			this._githubRepositories = repositories;
			oldRepositories.filter(old => this._githubRepositories.indexOf(old) < 0).forEach(repo => repo.dispose());

			const repositoriesChanged =
				oldRepositories.length !== this._githubRepositories.length ||
				!oldRepositories.every(oldRepo =>
					this._githubRepositories.some(newRepo => newRepo.remote.equals(oldRepo.remote)),
				);

			if (repositoriesChanged) {
				this._onDidChangeGithubRepositories.fire(this._githubRepositories);
			}

			if (this._githubRepositories.length && repositoriesChanged) {
				if (await this.checkIfMissingUpstream()) {
					this.updateRepositories(silent);
					return true;
				}
			}

			if (this.activePullRequest) {
				this.getMentionableUsers(repositoriesChanged);
			}

			this.getAssignableUsers(repositoriesChanged);
			if (isAuthenticated && activeRemotes.length) {
				this._onDidLoadRepositories.fire(ReposManagerState.RepositoriesLoaded);
			} else if (!isAuthenticated) {
				this._onDidLoadRepositories.fire(ReposManagerState.NeedsAuthentication);
			}
			if (!silent) {
				this._onDidChangeRepositories.fire();
			}
			return true;
		});
	}

	private async checkIfMissingUpstream(): Promise<boolean> {
		try {
			const origin = await this.getOrigin();
			const metadata = await origin.getMetadata();
			const configuration = vscode.workspace.getConfiguration(PR_SETTINGS_NAMESPACE);
			if (metadata.fork && metadata.parent && (configuration.get<'add' | 'never'>(UPSTREAM_REMOTE, 'add') === 'add')) {
				const parentUrl = new Protocol(metadata.parent.git_url);
				const missingParentRemote = !this._githubRepositories.some(
					repo =>
						(compareIgnoreCase(repo.remote.owner, parentUrl.owner) === 0) &&
						(compareIgnoreCase(repo.remote.repositoryName, parentUrl.repositoryName) === 0),
				);

				if (missingParentRemote) {
					const upstreamAvailable = !this.repository.state.remotes.some(remote => remote.name === 'upstream');
					const remoteName = upstreamAvailable ? 'upstream' : metadata.parent.owner?.login;
					if (remoteName) {
						// check the remotes to see what protocol is being used
						const isSSH = this.gitHubRepositories[0].remote.gitProtocol.type === ProtocolType.SSH;
						if (isSSH) {
							await this.repository.addRemote(remoteName, metadata.parent.ssh_url);
						} else {
							await this.repository.addRemote(remoteName, metadata.parent.clone_url);
						}
						this._addedUpstreamCount++;
						if (this._addedUpstreamCount > 1) {
							// We've already added this remote, which means the user likely removed it. Let the user know they can disable this feature.
							const neverOption = vscode.l10n.t('Set to `never`');
							vscode.window.showInformationMessage(vscode.l10n.t('An `upstream` remote has been added for this repository. You can disable this feature by setting `githubPullRequests.upstreamRemote` to `never`.'), neverOption)
								.then(choice => {
									if (choice === neverOption) {
										configuration.update(UPSTREAM_REMOTE, 'never', vscode.ConfigurationTarget.Global);
									}
								});
						}
						return true;
					}
				}
			}
		} catch (e) {
			Logger.appendLine(`Missing upstream check failed: ${e}`);
			// ignore
		}
		return false;
	}

	getAllAssignableUsers(): IAccount[] | undefined {
		if (this._assignableUsers) {
			const allAssignableUsers: IAccount[] = [];
			Object.keys(this._assignableUsers).forEach(k => {
				allAssignableUsers.push(...this._assignableUsers![k]);
			});

			return allAssignableUsers;
		}

		return undefined;
	}

	private async getCachedFromGlobalState<T>(userKind: 'assignableUsers' | 'teamReviewers' | 'mentionableUsers' | 'orgProjects'): Promise<{ [key: string]: T[] } | undefined> {
		Logger.appendLine(`Trying to use globalState for ${userKind}.`);

		const usersCacheLocation = vscode.Uri.joinPath(this.context.globalStorageUri, userKind);
		let usersCacheExists;
		try {
			usersCacheExists = await vscode.workspace.fs.stat(usersCacheLocation);
		} catch (e) {
			// file doesn't exit
		}
		if (!usersCacheExists) {
			Logger.appendLine(`GlobalState does not exist for ${userKind}.`);
			return undefined;
		}

		const cache: { [key: string]: T[] } = {};
		const hasAllRepos = (await Promise.all(this._githubRepositories.map(async (repo) => {
			const key = `${repo.remote.owner}/${repo.remote.repositoryName}.json`;
			const repoSpecificFile = vscode.Uri.joinPath(usersCacheLocation, key);
			let repoSpecificCache;
			let cacheAsJson;
			try {
				repoSpecificCache = await vscode.workspace.fs.readFile(repoSpecificFile);
				cacheAsJson = JSON.parse(repoSpecificCache.toString());
			} catch (e) {
				if (e instanceof Error && e.message.includes('Unexpected non-whitespace character after JSON')) {
					Logger.error(`Error parsing ${userKind} cache for ${repo.remote.remoteName}.`);
				}
				// file doesn't exist
			}
			if (repoSpecificCache && repoSpecificCache.toString()) {
				cache[repo.remote.remoteName] = cacheAsJson ?? [];
				return true;
			}
		}))).every(value => value);
		if (hasAllRepos) {
			Logger.appendLine(`Using globalState ${userKind} for ${Object.keys(cache).length}.`);
			return cache;
		}

		Logger.appendLine(`No globalState for ${userKind}.`);
		return undefined;
	}

	private async saveInGlobalState<T>(userKind: 'assignableUsers' | 'teamReviewers' | 'mentionableUsers' | 'orgProjects', cache: { [key: string]: T[] }): Promise<void> {
		const cacheLocation = vscode.Uri.joinPath(this.context.globalStorageUri, userKind);
		await Promise.all(this._githubRepositories.map(async (repo) => {
			const key = `${repo.remote.owner}/${repo.remote.repositoryName}.json`;
			const repoSpecificFile = vscode.Uri.joinPath(cacheLocation, key);
			await vscode.workspace.fs.writeFile(repoSpecificFile, new TextEncoder().encode(JSON.stringify(cache[repo.remote.remoteName])));
		}));
	}

	private createFetchMentionableUsersPromise(): Promise<{ [key: string]: IAccount[] }> {
		const cache: { [key: string]: IAccount[] } = {};
		return new Promise<{ [key: string]: IAccount[] }>(resolve => {
			const promises = this._githubRepositories.map(async githubRepository => {
				const data = await githubRepository.getMentionableUsers();
				cache[githubRepository.remote.remoteName] = data;
				return;
			});

			Promise.all(promises).then(() => {
				this._mentionableUsers = cache;
				this._fetchMentionableUsersPromise = undefined;
				this.saveInGlobalState('mentionableUsers', cache)
					.then(() => resolve(cache));
			});
		});
	}

	async getMentionableUsers(clearCache?: boolean): Promise<{ [key: string]: IAccount[] }> {
		if (clearCache) {
			delete this._mentionableUsers;
		}

		if (this._mentionableUsers) {
			Logger.appendLine('Using in-memory cached mentionable users.');
			return this._mentionableUsers;
		}

		const globalStateMentionableUsers = await this.getCachedFromGlobalState<IAccount>('mentionableUsers');

		if (!this._fetchMentionableUsersPromise) {
			this._fetchMentionableUsersPromise = this.createFetchMentionableUsersPromise();
			return globalStateMentionableUsers ?? this._fetchMentionableUsersPromise;
		}

		return this._fetchMentionableUsersPromise;
	}

	async getAssignableUsers(clearCache?: boolean): Promise<{ [key: string]: IAccount[] }> {
		if (clearCache) {
			delete this._assignableUsers;
		}

		if (this._assignableUsers) {
			Logger.appendLine('Using in-memory cached assignable users.');
			return this._assignableUsers;
		}

		const globalStateAssignableUsers = await this.getCachedFromGlobalState<IAccount>('assignableUsers');

		if (!this._fetchAssignableUsersPromise) {
			const cache: { [key: string]: IAccount[] } = {};
			const allAssignableUsers: IAccount[] = [];
			this._fetchAssignableUsersPromise = new Promise(resolve => {
				const promises = this._githubRepositories.map(async githubRepository => {
					const data = await githubRepository.getAssignableUsers();
					cache[githubRepository.remote.remoteName] = data.sort(loginComparator);
					allAssignableUsers.push(...data);
					return;
				});

				Promise.all(promises).then(() => {
					this._assignableUsers = cache;
					this._fetchAssignableUsersPromise = undefined;
					this.saveInGlobalState('assignableUsers', cache);
					resolve(cache);
					this._onDidChangeAssignableUsers.fire(allAssignableUsers);
				});
			});
			return globalStateAssignableUsers ?? this._fetchAssignableUsersPromise;
		}

		return this._fetchAssignableUsersPromise;
	}

	async getTeamReviewers(refreshKind: TeamReviewerRefreshKind): Promise<{ [key: string]: ITeam[] }> {
		if (refreshKind === TeamReviewerRefreshKind.Force) {
			delete this._teamReviewers;
		}

		if (this._teamReviewers) {
			Logger.appendLine('Using in-memory cached team reviewers.');
			return this._teamReviewers;
		}

		const globalStateTeamReviewers = (refreshKind === TeamReviewerRefreshKind.Force) ? undefined : await this.getCachedFromGlobalState<ITeam>('teamReviewers');
		if (globalStateTeamReviewers) {
			this._teamReviewers = globalStateTeamReviewers;
			return globalStateTeamReviewers || {};
		}

		if (!this._fetchTeamReviewersPromise) {
			const cache: { [key: string]: ITeam[] } = {};
			return (this._fetchTeamReviewersPromise = new Promise(async (resolve) => {
				// Keep track of the org teams we have already gotten so we don't make duplicate calls
				const orgTeams: Map<string, (ITeam & { repositoryNames: string[] })[]> = new Map();
				// Go through one github repo at a time so that we don't make overlapping auth calls
				for (const githubRepository of this._githubRepositories) {
					if (!orgTeams.has(githubRepository.remote.owner)) {
						try {
							const data = await githubRepository.getOrgTeams(refreshKind);
							orgTeams.set(githubRepository.remote.owner, data);
						} catch (e) {
							break;
						}
					}
					const allTeamsForOrg = orgTeams.get(githubRepository.remote.owner) ?? [];
					cache[githubRepository.remote.remoteName] = allTeamsForOrg.filter(team => team.repositoryNames.includes(githubRepository.remote.repositoryName)).sort(teamComparator);
				}

				this._teamReviewers = cache;
				this._fetchTeamReviewersPromise = undefined;
				this.saveInGlobalState('teamReviewers', cache);
				resolve(cache);
			}));
		}

		return this._fetchTeamReviewersPromise;
	}

	private createFetchOrgProjectsPromise(): Promise<{ [key: string]: IProject[] }> {
		const cache: { [key: string]: IProject[] } = {};
		return new Promise<{ [key: string]: IProject[] }>(async resolve => {
			// Keep track of the org teams we have already gotten so we don't make duplicate calls
			const orgProjects: Map<string, IProject[]> = new Map();
			// Go through one github repo at a time so that we don't make overlapping auth calls
			for (const githubRepository of this._githubRepositories) {
				if (!orgProjects.has(githubRepository.remote.owner)) {
					try {
						const data = await githubRepository.getOrgProjects();
						orgProjects.set(githubRepository.remote.owner, data);
					} catch (e) {
						break;
					}
				}
				cache[githubRepository.remote.remoteName] = orgProjects.get(githubRepository.remote.owner) ?? [];
			}

			await this.saveInGlobalState('orgProjects', cache);
			resolve(cache);
		});
	}

	async getOrgProjects(clearCache?: boolean): Promise<{ [key: string]: IProject[] }> {
		if (clearCache) {
			return this.createFetchOrgProjectsPromise();
		}

		const globalStateProjects = await this.getCachedFromGlobalState<IProject>('orgProjects');
		return globalStateProjects ?? this.createFetchOrgProjectsPromise();
	}

	async getAllProjects(githubRepository: GitHubRepository, clearOrgCache?: boolean): Promise<IProject[]> {
		const isInOrganization = !!(await githubRepository.getMetadata()).organization;
		const [repoProjects, orgProjects] = (await Promise.all([githubRepository.getProjects(), (isInOrganization ? this.getOrgProjects(clearOrgCache) : undefined)]));
		return [...(repoProjects ?? []), ...(orgProjects ? orgProjects[githubRepository.remote.remoteName] : [])];
	}

	async getOrgTeamsCount(repository: GitHubRepository): Promise<number> {
		if ((await repository.getMetadata()).organization) {
			return repository.getOrgTeamsCount();
		}
		return 0;
	}

	async getPullRequestParticipants(githubRepository: GitHubRepository, pullRequestNumber: number): Promise<{ participants: IAccount[], viewer: IAccount }> {
		return {
			participants: await githubRepository.getPullRequestParticipants(pullRequestNumber),
			viewer: await this.getCurrentUser(githubRepository)
		};
	}

	/**
	 * Returns the remotes that are currently active, which is those that are important by convention (origin, upstream),
	 * or the remotes configured by the setting githubPullRequests.remotes
	 */
	async getGitHubRemotes(): Promise<GitHubRemote[]> {
		const githubRepositories = this._githubRepositories;

		if (!githubRepositories || !githubRepositories.length) {
			return [];
		}

		const remotes = githubRepositories.map(repo => repo.remote).flat();

		const serverTypes = await Promise.all(
			remotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),
		).catch(e => {
			Logger.error(`Resolving GitHub remotes failed: ${e}`);
			vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));
			return [];
		});

		const githubRemotes = remotes.map((remote, index) => GitHubRemote.remoteAsGitHub(remote, serverTypes[index]));
		if (this.checkForAuthMatch(githubRemotes)) {
			return githubRemotes;
		}
		return [];
	}

	/**
	 * Returns all remotes from the repository.
	 */
	async getAllGitHubRemotes(): Promise<GitHubRemote[]> {
		return await this.computeAllGitHubRemotes();
	}

	async getLocalPullRequests(): Promise<PullRequestModel[]> {
		const githubRepositories = this._githubRepositories;

		if (!githubRepositories || !githubRepositories.length) {
			return [];
		}

		const localBranches = (await this.repository.getRefs({ pattern: 'refs/heads/' }))
			.filter(r => r.name !== undefined)
			.map(r => r.name!);

		// Chunk localBranches into chunks of 100 to avoid hitting the GitHub API rate limit
		const chunkedLocalBranches: string[][] = [];
		const chunkSize = 100;
		for (let i = 0; i < localBranches.length; i += chunkSize) {
			const chunk = localBranches.slice(i, i + chunkSize);
			chunkedLocalBranches.push(chunk);
		}

		const models: (PullRequestModel | undefined)[] = [];
		for (const chunk of chunkedLocalBranches) {
			models.push(...await Promise.all(chunk.map(async localBranchName => {
				const matchingPRMetadata = await PullRequestGitHelper.getMatchingPullRequestMetadataForBranch(
					this.repository,
					localBranchName,
				);

				if (matchingPRMetadata) {
					const { owner, prNumber } = matchingPRMetadata;
					const githubRepo = githubRepositories.find(
						repo => repo.remote.owner.toLocaleLowerCase() === owner.toLocaleLowerCase(),
					);

					if (githubRepo) {
						const pullRequest: PullRequestModel | undefined = await githubRepo.getPullRequest(prNumber);

						if (pullRequest) {
							pullRequest.localBranchName = localBranchName;
							return pullRequest;
						}
					}
				}
			})));
		}

		return models.filter(value => value !== undefined) as PullRequestModel[];
	}

	async getLabels(issue?: IssueModel, repoInfo?: { owner: string; repo: string }): Promise<ILabel[]> {
		const repo = issue
			? issue.githubRepository
			: this._githubRepositories.find(
				r => r.remote.owner === repoInfo?.owner && r.remote.repositoryName === repoInfo?.repo,
			);
		if (!repo) {
			throw new Error(`No matching repository found for getting labels.`);
		}

		const { remote, octokit } = await repo.ensure();
		let hasNextPage = false;
		let page = 1;
		let results: ILabel[] = [];

		do {
			const result = await octokit.call(octokit.api.issues.listLabelsForRepo, {
				owner: remote.owner,
				repo: remote.repositoryName,
				per_page: 100,
				page,
			});

			results = results.concat(
				result.data.map(label => {
					return {
						name: label.name,
						color: label.color,
						description: label.description ?? undefined
					};
				}),
			);

			results = results.sort((a, b) => a.name.localeCompare(b.name));

			hasNextPage = !!result.headers.link && result.headers.link.indexOf('rel="next"') > -1;
			page += 1;
		} while (hasNextPage);

		return results;
	}

	async deleteLocalPullRequest(pullRequest: PullRequestModel, force?: boolean): Promise<void> {
		if (!pullRequest.localBranchName) {
			return;
		}
		await this.repository.deleteBranch(pullRequest.localBranchName, force);

		let remoteName: string | undefined = undefined;
		try {
			remoteName = await this.repository.getConfig(`branch.${pullRequest.localBranchName}.remote`);
		} catch (e) { }

		if (!remoteName) {
			return;
		}

		// If the extension created a remote for the branch, remove it if there are no other branches associated with it
		const isPRRemote = await PullRequestGitHelper.isRemoteCreatedForPullRequest(this.repository, remoteName);
		if (isPRRemote) {
			const configs = await this.repository.getConfigs();
			const hasOtherAssociatedBranches = configs.some(
				({ key, value }) => /^branch.*\.remote$/.test(key) && value === remoteName,
			);

			if (!hasOtherAssociatedBranches) {
				await this.repository.removeRemote(remoteName);
			}
		}

		/* __GDPR__
			"branch.delete" : {}
		*/
		this.telemetry.sendTelemetryEvent('branch.delete');
	}

	// Keep track of how many pages we've fetched for each query, so when we reload we pull the same ones.
	private totalFetchedPages = new Map<string, number>();

	/**
	 * This method works in three different ways:
	 * 1) Initialize: fetch the first page of the first remote that has pages
	 * 2) Fetch Next: fetch the next page from this remote, or if it has no more pages, the first page from the next remote that does have pages
	 * 3) Restore: fetch all the pages you previously have fetched
	 *
	 * When `options.fetchNextPage === false`, we are in case 2.
	 * Otherwise:
	 *   If `this.totalFetchQueries[queryId] === 0`, we are in case 1.
	 *   Otherwise, we're in case 3.
	 */
	private async fetchPagedData<T>(
		options: IPullRequestsPagingOptions = { fetchNextPage: false },
		queryId: string,
		pagedDataType: PagedDataType = PagedDataType.PullRequest,
		type: PRType = PRType.All,
		query?: string,
	): Promise<ItemsResponseResult<T>> {
		const githubRepositoriesWithGitRemotes = pagedDataType === PagedDataType.PullRequest ? this._githubRepositories.filter(repo => this.repository.state.remotes.find(r => r.name === repo.remote.remoteName)) : this._githubRepositories;
		if (!githubRepositoriesWithGitRemotes.length) {