/*---------------------------------------------------------------------------------------------

* Copyright (c) Microsoft Corporation. All rights reserved.

* Licensed under the MIT License. See License.txt in the project root for license information.

*--------------------------------------------------------------------------------------------*/

'use strict';

import * as path from 'path';

import * as vscode from 'vscode';

import * as Github from '@octokit/rest';

import { PullRequestStateEnum, ReviewEvent, ReviewState, ILabel, IAccount, MergeMethodsAvailability, MergeMethod } from './interface';

import { onDidUpdatePR } from '../commands';

import { formatError } from '../common/utils';

import { GitErrorCodes } from '../api/api';

import { Comment } from '../common/comment';

import { writeFile, unlink } from 'fs';

import Logger from '../common/logger';

import { DescriptionNode } from '../view/treeNodes/descriptionNode';

import { TreeNode, Revealable } from '../view/treeNodes/treeNode';

import { PullRequestManager } from './pullRequestManager';

import { PullRequestModel } from './pullRequestModel';

import { TimelineEvent, ReviewEvent as CommonReviewEvent, isReviewEvent } from '../common/timelineEvent';

interface IRequestMessage<T> {

req: string;

command: string;

args: T;

}

interface IReplyMessage {

seq?: string;

err?: any;

res?: any;

}

export class PullRequestOverviewPanel {

public static ID: string = 'PullRequestOverviewPanel';

/**

* Track the currently panel. Only allow a single panel to exist at a time.

*/

public static currentPanel?: PullRequestOverviewPanel;

private static readonly _viewType = 'PullRequestOverview';

private readonly _panel: vscode.WebviewPanel;

private readonly _extensionPath: string;

private _disposables: vscode.Disposable[] = [];

private _descriptionNode: DescriptionNode;

private _pullRequest: PullRequestModel;

private _pullRequestManager: PullRequestManager;

private _scrollPosition = { x: 0, y: 0 };

private _existingReviewers: ReviewState[];

public static createOrShow(extensionPath: string, pullRequestManager: PullRequestManager, pullRequestModel: PullRequestModel, descriptionNode: DescriptionNode, toTheSide: Boolean = false) {

let activeColumn = toTheSide ?

vscode.ViewColumn.Beside :

vscode.window.activeTextEditor ?

vscode.window.activeTextEditor.viewColumn :

vscode.ViewColumn.One;

// If we already have a panel, show it.

// Otherwise, create a new panel.

if (PullRequestOverviewPanel.currentPanel) {

PullRequestOverviewPanel.currentPanel._panel.reveal(activeColumn, true);

} else {

const title = `Pull Request #${pullRequestModel.prNumber.toString()}`;

PullRequestOverviewPanel.currentPanel = new PullRequestOverviewPanel(extensionPath, activeColumn || vscode.ViewColumn.Active, title, pullRequestManager, descriptionNode);

}

PullRequestOverviewPanel.currentPanel!.update(pullRequestModel, descriptionNode);

}

public static refresh(): void {

if (this.currentPanel) {

this.currentPanel.refreshPanel();

}

}

private constructor(extensionPath: string, column: vscode.ViewColumn, title: string, pullRequestManager: PullRequestManager, descriptionNode: DescriptionNode) {

this._extensionPath = extensionPath;

this._pullRequestManager = pullRequestManager;

this._descriptionNode = descriptionNode;

// Create and show a new webview panel

this._panel = vscode.window.createWebviewPanel(PullRequestOverviewPanel._viewType, title, column, {

// Enable javascript in the webview

enableScripts: true,

// And restric the webview to only loading content from our extension's `media` directory.

localResourceRoots: [

vscode.Uri.file(path.join(this._extensionPath, 'media'))

]

});

// Listen for when the panel is disposed

// This happens when the user closes the panel or when the panel is closed programatically

this._panel.onDidDispose(() => this.dispose(), null, this._disposables);

// Listen for changes to panel visibility, if the webview comes into view resubmit data

this._panel.onDidChangeViewState(e => {

if (e.webviewPanel.visible && this._pullRequest) {

this.update(this._pullRequest, this._descriptionNode);

}

}, this, this._disposables);

// Handle messages from the webview

this._panel.webview.onDidReceiveMessage(async message => {

await this._onDidReceiveMessage(message);

}, null, this._disposables);

this._pullRequestManager.onDidChangeActivePullRequest(_ => {

if (this._pullRequestManager && this._pullRequest) {

const isCurrentlyCheckedOut = this._pullRequest.equals(this._pullRequestManager.activePullRequest);

this._postMessage({

command: 'pr.update-checkout-status',

isCurrentlyCheckedOut: isCurrentlyCheckedOut

});

}

}, null, this._disposables);

onDidUpdatePR(pr => {

if (pr) {

this._pullRequest.update(pr);

}

this._postMessage({

command: 'update-state',

state: this._pullRequest.state,

});

}, null, this._disposables);

}

public async refreshPanel(): Promise<void> {

if (this._panel && this._panel.visible) {

this.update(this._pullRequest, this._descriptionNode);

}

}

/**

* Create a list of reviewers composed of people who have already left reviews on the PR, and

* those that have had a review requested of them. If a reviewer has left multiple reviews, the

* state should be the state of their most recent review, or 'REQUESTED' if they have an outstanding

* review request.

* @param requestedReviewers The list of reviewers that are requested for this pull request

* @param timelineEvents All timeline events for the pull request

* @param author The author of the pull request

*/

private parseReviewers(requestedReviewers: IAccount[], timelineEvents: TimelineEvent[], author: IAccount): ReviewState[] {

const reviewEvents = timelineEvents.filter(isReviewEvent).filter(event => event.state !== 'PENDING');

let reviewers: ReviewState[] = [];

const seen = new Map<string, boolean>();

// Do not show the author in the reviewer list

seen.set(author.login, true);

for (let i = reviewEvents.length -1; i >= 0; i--) {

const reviewer = reviewEvents[i].user;

if (!seen.get(reviewer.login)) {

seen.set(reviewer.login, true);

reviewers.push({

reviewer: reviewer,

state: reviewEvents[i].state

});

}

}

requestedReviewers.forEach(request => {

if (!seen.get(request.login)) {

reviewers.push({

reviewer: request,

state: 'REQUESTED'

});

} else {

const reviewer = reviewers.find(r => r.reviewer.login === request.login);

reviewer!.state = 'REQUESTED';

}

});

// Put completed reviews before review requests and alphabetize each section

reviewers = reviewers.sort((a, b) => {

if (a.state === 'REQUESTED' && b.state !== 'REQUESTED') {

return 1;

}

if (b.state === 'REQUESTED' && a.state !== 'REQUESTED') {

return -1;

}

return a.reviewer.login.toLowerCase() < b.reviewer.login.toLowerCase() ? -1 : 1;

});

this._existingReviewers = reviewers;

return reviewers;

}

public async update(pullRequestModel: PullRequestModel, descriptionNode: DescriptionNode): Promise<void> {

this._descriptionNode = descriptionNode;

this._postMessage({

command: 'set-scroll',

scrollPosition: this._scrollPosition,

});

this._panel.webview.html = this.getHtmlForWebview(pullRequestModel.prNumber.toString());

Promise.all([

this._pullRequestManager.resolvePullRequest(

pullRequestModel.remote.owner,

pullRequestModel.remote.repositoryName,

pullRequestModel.prNumber

),

this._pullRequestManager.getTimelineEvents(pullRequestModel),

this._pullRequestManager.getPullRequestRepositoryDefaultBranch(pullRequestModel),

this._pullRequestManager.getStatusChecks(pullRequestModel),

this._pullRequestManager.getReviewRequests(pullRequestModel),

this._pullRequestManager.getPullRequestRepositoryMergeMethodsAvailability(pullRequestModel),

]).then(result => {

const [pullRequest, timelineEvents, defaultBranch, status, requestedReviewers, mergeMethodsAvailability] = result;

if (!pullRequest) {

throw new Error(`Fail to resolve Pull Request #${pullRequestModel.prNumber} in ${pullRequestModel.remote.owner}/${pullRequestModel.remote.repositoryName}`);

}

this._pullRequest = pullRequest;

this._panel.title = `Pull Request #${pullRequestModel.prNumber.toString()}`;

const isCurrentlyCheckedOut = pullRequestModel.equals(this._pullRequestManager.activePullRequest);

const canEdit = this._pullRequestManager.canEditPullRequest(this._pullRequest);

const preferredMergeMethod = vscode.workspace.getConfiguration('githubPullRequests').get<MergeMethod>('defaultMergeMethod');

const supportsGraphQl = pullRequestModel.githubRepository.supportsGraphQl;

const defaultMergeMethod = getDetaultMergeMethod(mergeMethodsAvailability, preferredMergeMethod);

this._postMessage({

command: 'pr.initialize',

pullrequest: {

number: this._pullRequest.prNumber,

title: this._pullRequest.title,

url: this._pullRequest.html_url,

createdAt: this._pullRequest.createdAt,

body: this._pullRequest.body,

bodyHTML: this._pullRequest.bodyHTML,

labels: this._pullRequest.prItem.labels,

author:{

login: this._pullRequest.author.login,

name: this._pullRequest.author.name,

avatarUrl: this._pullRequest.userAvatar,

url: this._pullRequest.author.url

},

state: this._pullRequest.state,

events: timelineEvents,

isCurrentlyCheckedOut: isCurrentlyCheckedOut,

base: this._pullRequest.base && this._pullRequest.base.label || 'UNKNOWN',

head: this._pullRequest.head && this._pullRequest.head.label || 'UNKNOWN',

repositoryDefaultBranch: defaultBranch,

canEdit: canEdit,

status: status,

mergeable: this._pullRequest.prItem.mergeable,

reviewers: this.parseReviewers(requestedReviewers, timelineEvents, this._pullRequest.author),

mergeMethodsAvailability,

defaultMergeMethod,

supportsGraphQl

}

});

}).catch(e => {

vscode.window.showErrorMessage(formatError(e));

});

}

private async _postMessage(message: any) {

this._panel.webview.postMessage({

res: message

});

}

private async _replyMessage(originalMessage: IRequestMessage<any>, message: any) {

const reply: IReplyMessage = {

seq: originalMessage.req,

res: message

};

this._panel.webview.postMessage(reply);

}

private async _throwError(originalMessage: IRequestMessage<any>, error: any) {

const reply: IReplyMessage = {

seq: originalMessage.req,

err: error

};

this._panel.webview.postMessage(reply);

}

private async _onDidReceiveMessage(message: IRequestMessage<any>) {

switch (message.command) {

case 'alert':

vscode.window.showErrorMessage(message.args);

return;

case 'pr.checkout':

return this.checkoutPullRequest(message);

case 'pr.merge':

return this.mergePullRequest(message);

case 'pr.close':

return this.closePullRequest(message);

case 'pr.approve':

return this.approvePullRequest(message);

case 'pr.request-changes':

return this.requestChanges(message);

case 'pr.submit':

return this.submitReview(message);

case 'pr.checkout-default-branch':

return this.checkoutDefaultBranch(message.args);

case 'pr.comment':

return this.createComment(message);

case 'scroll':

this._scrollPosition = message.args;

return;

case 'pr.edit-comment':

return this.editComment(message);

case 'pr.delete-comment':

return this.deleteComment(message);

case 'pr.edit-description':

return this.editDescription(message);

case 'pr.apply-patch':

return this.applyPatch(message);

case 'pr.open-diff':

return this.openDiff(message);

case 'pr.edit-title':

return this.editTitle(message);

case 'pr.refresh':

this.refreshPanel();

return;

case 'pr.add-reviewers':

return this.addReviewers(message);

case 'pr.remove-reviewer':

return this.removeReviewer(message);

case 'pr.add-labels':

return this.addLabels(message);

case 'pr.remove-label':

return this.removeLabel(message);

}

}

private async addReviewers(message: IRequestMessage<void>): Promise<void> {

try {

const allMentionableUsers = await this._pullRequestManager.getMentionableUsers();

const mentionableUsers = allMentionableUsers[this._pullRequest.remote.remoteName];

const newReviewers = mentionableUsers

.filter(user =>

!this._existingReviewers.some(reviewer => reviewer.reviewer.login === user.login)

&& user.login !== this._pullRequest.author.login);

const reviewersToAdd = await vscode.window.showQuickPick(newReviewers.map(reviewer => {

return {

label: reviewer.login,

description: reviewer.name

};

}), {

canPickMany: true,

matchOnDescription: true

});

if (reviewersToAdd) {

await this._pullRequestManager.requestReview(this._pullRequest, reviewersToAdd.map(r => r.label));

const addedReviewers: ReviewState[] = reviewersToAdd.map(reviewer => {

return {

reviewer: newReviewers.find(r => r.login === reviewer.label)!,

state: 'REQUESTED'

};

});

this._existingReviewers = this._existingReviewers.concat(addedReviewers);

this._replyMessage(message, {

added: addedReviewers

});

}

} catch (e) {

vscode.window.showErrorMessage(formatError(e));

}

}

private async removeReviewer(message: IRequestMessage<string>): Promise<void> {

try {

await this._pullRequestManager.deleteRequestedReview(this._pullRequest, message.args);

const index = this._existingReviewers.findIndex(reviewer => reviewer.reviewer.login === message.args);

this._existingReviewers.splice(index, 1);

this._replyMessage(message, { });

} catch (e) {

vscode.window.showErrorMessage(formatError(e));

}

}

private async addLabels(message: IRequestMessage<void>): Promise<void> {

try {

let newLabels: ILabel[] = [];

async function getLabelOptions(prManager: PullRequestManager, pr: PullRequestModel): Promise<vscode.QuickPickItem[]> {

const allLabels = await prManager.getLabels(pr);

newLabels = allLabels.filter(l => !pr.prItem.labels.some(label => label.name === l.name));

return newLabels.map(label => {

return {

label: label.name

};

});

}

const labelsToAdd = await vscode.window.showQuickPick(await getLabelOptions(this._pullRequestManager, this._pullRequest), { canPickMany: true });

if (labelsToAdd) {

await this._pullRequestManager.addLabels(this._pullRequest, labelsToAdd.map(r => r.label));

const addedLabels: ILabel[] = labelsToAdd.map(label => newLabels.find(l => l.name === label.label)!);

this._pullRequest.prItem.labels = this._pullRequest.prItem.labels.concat(...addedLabels);

this._replyMessage(message, {

added: addedLabels

});

}

} catch (e) {

vscode.window.showErrorMessage(formatError(e));

}

}

private async removeLabel(message: IRequestMessage<string>): Promise<void> {

try {

await this._pullRequestManager.removeLabel(this._pullRequest, message.args);

const index = this._pullRequest.prItem.labels.findIndex(label => label.name === message.args);

this._pullRequest.prItem.labels.splice(index, 1);

this._replyMessage(message, { });

} catch (e) {

vscode.window.showErrorMessage(formatError(e));

}

}

private applyPatch(message: IRequestMessage<{ comment: Comment }>): void {

try {

const comment = message.args.comment;

const regex = /```diff\n([\s\S]*)\n```/g;

const matches = regex.exec(comment.body);

if (!vscode.workspace.rootPath) {

throw new Error('Current workspace rootpath is undefined.');

}

const tempFilePath = path.resolve(vscode.workspace.rootPath, '.git', `${comment.id}.diff`);

writeFile(tempFilePath, matches![1], {}, async (writeError) => {

if (writeError) {

throw writeError;

}

try {

await this._pullRequestManager.repository.apply(tempFilePath);

// Need to mark conversation as resolved

unlink(tempFilePath, (err) => {

if (err) {

throw err;

}

this._replyMessage(message, { });

});

} catch (e) {

Logger.appendLine(`Applying patch failed: ${e}`);

vscode.window.showErrorMessage(`Applying patch failed: ${formatError(e)}`);

}

});

} catch (e) {

Logger.appendLine(`Applying patch failed: ${e}`);

vscode.window.showErrorMessage(`Applying patch failed: ${formatError(e)}`);

}

}

private openDiff(message: IRequestMessage<{ comment: Comment }>): void {

try {

const comment = message.args.comment;

const prContainer = this._descriptionNode.parent;

if ((prContainer as TreeNode | Revealable<TreeNode>).revealComment) {

(prContainer as TreeNode | Revealable<TreeNode>).revealComment!(comment);

}

} catch (e) {

Logger.appendLine(`Open diff view failed: ${formatError(e)}`, PullRequestOverviewPanel.ID);

}

}

private editDescription(message: IRequestMessage<{ text: string }>) {

this._pullRequestManager.editPullRequest(this._pullRequest, { body: message.args.text }).then(result => {

this._replyMessage(message, { text: result.body });

}).catch(e => {

this._throwError(message, e);

vscode.window.showErrorMessage(`Editing description failed: ${formatError(e)}`);

});

}

private editTitle(message: IRequestMessage<{ text: string }>) {

this._pullRequestManager.editPullRequest(this._pullRequest, { title: message.args.text }).then(result => {

this._replyMessage(message, { text: result.title });

}).catch(e => {

this._throwError(message, e);

vscode.window.showErrorMessage(`Editing title failed: ${formatError(e)}`);

});

}

private editComment(message: IRequestMessage<{ comment: Comment, text: string }>) {

const { comment, text } = message.args;

const editCommentPromise = comment.pullRequestReviewId !== undefined

? this._pullRequestManager.editReviewComment(this._pullRequest, comment, text)

: this._pullRequestManager.editIssueComment(this._pullRequest, comment.id.toString(), text);

editCommentPromise.then(result => {

this._replyMessage(message, {

text: result.body

});

}).catch(e => {

this._throwError(message, e);

vscode.window.showErrorMessage(formatError(e));

});

}

private deleteComment(message: IRequestMessage<Comment>) {

const comment = message.args;

vscode.window.showWarningMessage('Are you sure you want to delete this comment?', { modal: true }, 'Delete').then(value => {

if (value === 'Delete') {

const deleteCommentPromise = comment.pullRequestReviewId !== undefined

? this._pullRequestManager.deleteReviewComment(this._pullRequest, comment.id.toString())

: this._pullRequestManager.deleteIssueComment(this._pullRequest, comment.id.toString());

deleteCommentPromise.then(result => {

this._replyMessage(message, { });

}).catch(e => {

this._throwError(message, e);

vscode.window.showErrorMessage(formatError(e));

});

}

});

}

private checkoutPullRequest(message: IRequestMessage<any>): void {

vscode.commands.executeCommand('pr.pick', this._pullRequest).then(() => {

const isCurrentlyCheckedOut = this._pullRequest.equals(this._pullRequestManager.activePullRequest);

this._replyMessage(message, { isCurrentlyCheckedOut: isCurrentlyCheckedOut });

}, () => {

const isCurrentlyCheckedOut = this._pullRequest.equals(this._pullRequestManager.activePullRequest);

this._replyMessage(message, { isCurrentlyCheckedOut: isCurrentlyCheckedOut });

});

}

private mergePullRequest(message: IRequestMessage<{ title: string, description: string, method: 'merge' | 'squash' | 'rebase' }>): void {

const { title, description, method } = message.args;

this._pullRequestManager.mergePullRequest(this._pullRequest, title, description, method).then(result => {

vscode.commands.executeCommand('pr.refreshList');

if (!result.merged) {

vscode.window.showErrorMessage(`Merging PR failed: ${result.message}`);

}

this._replyMessage(message, {

state: result.merged ? PullRequestStateEnum.Merged : PullRequestStateEnum.Open

});

}).catch(e => {

vscode.window.showErrorMessage(`Unable to merge pull request. ${formatError(e)}`);

this._throwError(message, {});

});

}

private closePullRequest(message: IRequestMessage<string>): void {

vscode.commands.executeCommand<Github.PullRequestsGetResponse>('pr.close', this._pullRequest, message.args).then(comment => {

if (comment) {

this._replyMessage(message, {

value: comment

});

}

});

}

private async checkoutDefaultBranch(branch: string): Promise<void> {

try {

// This should be updated for multi-root support and consume the git extension API if possible

const branchObj = await this._pullRequestManager.repository.getBranch('@{-1}');

if (branch === branchObj.name) {

await this._pullRequestManager.repository.checkout(branch);

} else {

const didCheckout = await vscode.commands.executeCommand('git.checkout');

if (!didCheckout) {

this._postMessage({

command: 'pr.enable-exit'

});

}

}

} catch (e) {

if (e.gitErrorCode) {

// for known git errors, we should provide actions for users to continue.

if (e.gitErrorCode === GitErrorCodes.DirtyWorkTree) {

vscode.window.showErrorMessage('Your local changes would be overwritten by checkout, please commit your changes or stash them before you switch branches');

this._postMessage({

command: 'pr.enable-exit'

});

return;

}

}

vscode.window.showErrorMessage(`Exiting failed: ${e}`);

this._postMessage({

command: 'pr.enable-exit'

});

}

}

private createComment(message: IRequestMessage<string>) {

this._pullRequestManager.createIssueComment(this._pullRequest, message.args).then(comment => {

this._replyMessage(message, {

value: comment

});

});

}

private updateReviewers(review?: CommonReviewEvent): void {

if (review) {

const existingReviewer = this._existingReviewers.find(reviewer => review.user.login === reviewer.reviewer.login);

if (existingReviewer) {

existingReviewer.state = review.state;

} else {

this._existingReviewers.push({

reviewer: review.user,

state: review.state

});

}

}

}

private approvePullRequest(message: IRequestMessage<string>): void {

vscode.commands.executeCommand<CommonReviewEvent>('pr.approve', this._pullRequest, message.args).then(review => {

this.updateReviewers(review);

this._replyMessage(message, {

review: review,

reviewers: this._existingReviewers

});

}, (e) => {

vscode.window.showErrorMessage(`Approving pull request failed. ${formatError(e)}`);

this._throwError(message, `${formatError(e)}`);

});

}

private requestChanges(message: IRequestMessage<string>): void {

vscode.commands.executeCommand<CommonReviewEvent>('pr.requestChanges', this._pullRequest, message.args).then(review => {

this.updateReviewers(review);

this._replyMessage(message, {

review: review,

reviewers: this._existingReviewers

});

}, (e) => {

vscode.window.showErrorMessage(`Requesting changes failed. ${formatError(e)}`);

this._throwError(message, `${formatError(e)}`);

});

}

private submitReview(message: IRequestMessage<string>): void {

this._pullRequestManager.submitReview(this._pullRequest, ReviewEvent.Comment, message.args).then(review => {

this.updateReviewers(review);

this._replyMessage(message, {

review: review,

reviewers: this._existingReviewers

});

}, (e) => {

vscode.window.showErrorMessage(`Requesting changes failed. ${formatError(e)}`);

this._throwError(message, `${formatError(e)}`);

});

}

public dispose() {

PullRequestOverviewPanel.currentPanel = undefined;

// Clean up our resources

this._panel.dispose();

while (this._disposables.length) {

const x = this._disposables.pop();

if (x) {

x.dispose();

}

}

}

private getHtmlForWebview(number: string) {

const scriptPathOnDisk = vscode.Uri.file(path.join(this._extensionPath, 'media', 'index.js'));

const scriptUri = scriptPathOnDisk.with({ scheme: 'vscode-resource' });

const nonce = getNonce();

return `<!DOCTYPE html>

<html lang="en">

<head>

<meta charset="UTF-8">

<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src vscode-resource: https:; script-src 'nonce-${nonce}'; style-src vscode-resource: 'unsafe-inline' http: https: data:;">

<meta name="viewport" content="width=device-width, initial-scale=1.0">

<title>Pull Request #${number}</title>

</head>

<body class="${process.platform}">

<div id=app></div>

<script nonce="${nonce}" src="${scriptUri}"></script>

</body>

</html>`;

}

}

function getNonce() {

let text = '';

const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

for (let i = 0; i < 32; i++) {

text += possible.charAt(Math.floor(Math.random() * possible.length));

}

return text;

}

function getDetaultMergeMethod(methodsAvailability: MergeMethodsAvailability, userPreferred: MergeMethod | undefined): MergeMethod {

// Use default merge method specified by user if it is avaialbe

if (userPreferred && methodsAvailability.hasOwnProperty(userPreferred) && methodsAvailability[userPreferred]) {

return userPreferred;

}

const methods: MergeMethod[] = ['merge', 'squash', 'rebase'];

// GitHub requires to have at leas one merge method to be enabled; use first available as default

return methods.find(method => methodsAvailability[method])!;

}