// AddComment adds the given comment to the review.
func (r *Review) AddComment(c comment.Comment) error {
	commentNote, err := c.Write()
	if err != nil {
		return err
	}

	r.Repo.AppendNote(comment.Ref, r.Revision, commentNote)
	return nil
}

func TestCommentsOverlap(t *testing.T) {
	reviewLevelComment := comment.Comment{
		Timestamp: "00000000",
		Author:    "[email protected]",
		Location: &comment.Location{
			Commit: "ABCDEFG",
		},
		Description: "Please fix so and so...",
	}
	if !CommentsOverlap(reviewLevelComment, reviewLevelComment) {
		t.Fatal("Erroneous distinction drawn between identical review-level comments")
	}

	repeatedReviewLevelComment := comment.Comment{
		Timestamp: "00000000",
		Author:    "[email protected]",
		Location: &comment.Location{
			Commit: "ABCDEFH",
		},
		Description: "Please fix so and so...",
	}
	if CommentsOverlap(reviewLevelComment, repeatedReviewLevelComment) {
		t.Fatal("Failed to distinguish between review comments at different commits")
	}

	issueComment := comment.Comment{
		Timestamp:   "FFFFFFFF",
		Author:      "[email protected]",
		Description: "Please fix so and so...",
	}
	if !CommentsOverlap(reviewLevelComment, issueComment) {
		t.Fatal("Erroneous distinction drawn between a review-level comment and an issue comment")
	}
	reviewLevelCommentHash, err := reviewLevelComment.Hash()
	if err != nil {
		t.Fatal(err)
	}
	reviewLevelChildComment := comment.Comment{
		Timestamp: "FFFFFFFG",
		Author:    "[email protected]",
		Parent:    reviewLevelCommentHash,
		Location: &comment.Location{
			Commit: "ABCDEFG",
		},
		Description: "Done",
	}
	issueChildComment := comment.Comment{
		Timestamp:   "FFFFFFFH",
		Author:      "[email protected]",
		Description: "Done",
	}
	if !CommentsOverlap(reviewLevelChildComment, issueChildComment) {
		t.Fatal("Erroneous distinction drawn between a review-level child comment and an issue comment")
	}
}

func TestResolvedOverlaps(t *testing.T) {
	reject := false
	accept := true

	blankComment := comment.Comment{
		Timestamp: "012345",
		Author:    "[email protected]",
		Resolved:  &reject,
	}

	blankComment2 := comment.Comment{
		Timestamp: "012345",
		Author:    "[email protected]",
		Resolved:  &accept,
	}

	// should not overlap because resolved bits are set for both
	// and different even though with same timestamp
	if Overlaps(blankComment, blankComment2) {
		t.Errorf("%v and %v  overlap", blankComment, blankComment2)
	}

	blankComment2.Resolved = &reject
	// should overlap because resolved bits are set for both and the same with the same timestamp
	if !Overlaps(blankComment, blankComment2) {
		t.Errorf("%v and %v  do not overlap", blankComment, blankComment2)
	}

	blankComment2.Resolved = &accept
	// should not overlap because resolved bits are set for both and the timestamps are different
	if Overlaps(blankComment, blankComment2) {
		t.Errorf("%v and %v  overlap", blankComment, blankComment2)
	}

	blankComment2.Timestamp = "012345"
	blankComment2.Resolved = nil
	// should not overlap because resolved bit is nil for one
	if Overlaps(blankComment, blankComment2) {
		t.Errorf("%v and %v  overlap", blankComment, blankComment2)
	}

	blankComment.Resolved = nil
	// should overlap because resolved bit is nil for both and there is no other descriptor
	// seperating them apart
	if !Overlaps(blankComment, blankComment2) {
		t.Errorf("%v and %v do not overlap", blankComment, blankComment2)
	}
}

func getHash(c comment.Comment) string {
	cHash, error := c.Hash()
	if error != nil {
	}
	return cHash
}

func TestBuildCommentThreads(t *testing.T) {
	rejected := false
	accepted := true
	root := comment.Comment{
		Timestamp:   "012345",
		Resolved:    nil,
		Description: "root",
	}
	rootHash, err := root.Hash()
	if err != nil {
		t.Fatal(err)
	}
	child := comment.Comment{
		Timestamp:   "012346",
		Resolved:    &rejected,
		Parent:      rootHash,
		Description: "child",
	}
	childHash, err := child.Hash()
	if err != nil {
		t.Fatal(err)
	}
	leaf := comment.Comment{
		Timestamp:   "012347",
		Resolved:    &accepted,
		Parent:      childHash,
		Description: "leaf",
	}
	leafHash, err := leaf.Hash()
	if err != nil {
		t.Fatal(err)
	}
	commentsByHash := map[string]comment.Comment{
		rootHash:  root,
		childHash: child,
		leafHash:  leaf,
	}
	threads := buildCommentThreads(commentsByHash)
	if len(threads) != 1 {
		t.Fatalf("Unexpected threads: %v", threads)
	}
	rootThread := threads[0]
	if rootThread.Comment.Description != "root" {
		t.Fatalf("Unexpected root thread: %v", rootThread)
	}
	if len(rootThread.Children) != 1 {
		t.Fatalf("Unexpected root children: %v", rootThread.Children)
	}
	rootChild := rootThread.Children[0]
	if rootChild.Comment.Description != "child" {
		t.Fatalf("Unexpected child: %v", rootChild)
	}
	if len(rootChild.Children) != 1 {
		t.Fatalf("Unexpected leaves: %v", rootChild.Children)
	}
	threadLeaf := rootChild.Children[0]
	if threadLeaf.Comment.Description != "leaf" {
		t.Fatalf("Unexpected leaf: %v", threadLeaf)
	}
	if len(threadLeaf.Children) != 0 {
		t.Fatalf("Unexpected leaf children: %v", threadLeaf.Children)
	}
}

func LoadComments(review DifferentialReview, readTransactions ReadTransactions, readTransactionComment ReadTransactionComment, lookupUser UserLookup) []comment.Comment {

	allTransactions, err := readTransactions(review.PHID)
	if err != nil {
		log.Fatal(err)
	}
	var comments []comment.Comment
	commentsByPHID := make(map[string]comment.Comment)
	rejectionCommentsByUser := make(map[string][]string)

	log.Printf("LOADCOMMENTS: Returning %d transactions", len(allTransactions))
	for _, transaction := range allTransactions {
		author, err := lookupUser(transaction.AuthorPHID)
		if err != nil {
			log.Fatal(err)
		}
		c := comment.Comment{
			Author:    author.Email,
			Timestamp: fmt.Sprintf("%d", transaction.DateCreated),
		}
		if author.Email != "" {
			c.Author = author.Email
		} else {
			c.Author = author.UserName
		}

		if transaction.CommentPHID != nil {
			transactionComment, err := readTransactionComment(transaction.PHID)
			if err != nil {
				log.Fatal(err)
			}
			if transactionComment.FileName != "" {
				c.Location = &comment.Location{
					Commit: transactionComment.Commit,
					Path:   transactionComment.FileName,
				}
				if transactionComment.LineNumber != 0 {
					c.Location.Range = &comment.Range{
						StartLine: transactionComment.LineNumber,
					}
				}
			}
			c.Description = transactionComment.Content
			if transactionComment.ReplyToCommentPHID != nil {
				// We assume that the parent has to have been processed before the child,
				// and enforce that by ordering the transactions in our queries.
				if replyTo, ok := commentsByPHID[*transactionComment.ReplyToCommentPHID]; ok {
					parentHash, err := replyTo.Hash()
					if err != nil {
						log.Fatal(err)
					}
					c.Parent = parentHash
				}
			}
		}

		// Set the resolved bit based on whether the change was approved or not.
		if transaction.Type == "differential:action" && transaction.NewValue != nil {
			action := *transaction.NewValue
			var resolved bool
			if action == "\"accept\"" {
				resolved = true
				c.Resolved = &resolved

				// Add child comments to all previous rejects by this user and make them accepts
				for _, rejectionCommentHash := range rejectionCommentsByUser[author.UserName] {
					approveComment := comment.Comment{
						Author:    c.Author,
						Timestamp: c.Timestamp,
						Resolved:  &resolved,
						Parent:    rejectionCommentHash,
					}
					comments = append(comments, approveComment)
					log.Printf("LOADCOMMENTS: Received approval. Adding child comment %v with parent hash %x", approveComment, rejectionCommentHash)
				}
			} else if action == "\"reject\"" {
				resolved = false
				c.Resolved = &resolved
			}

		}

		// Phabricator only publishes inline comments when you publish a top-level comment.
		// This results in a lot of empty top-level comments, which we do not want to mirror.
		// To work around this, we only return comments that are non-empty.
		if c.Parent != "" || c.Location != nil || c.Description != "" || c.Resolved != nil {
			comments = append(comments, c)
			commentsByPHID[transaction.PHID] = c

			//If this was a rejection comment, add it to ordered comment hash
			if c.Resolved != nil && *c.Resolved == false {
				commentHash, err := c.Hash()
				if err != nil {
					log.Fatal(err)
				}
				log.Printf("LOADCOMMENTS: Received rejection. Adding comment %v with hash %x", c, commentHash)
				rejectionCommentsByUser[author.UserName] = append(rejectionCommentsByUser[author.UserName], commentHash)
			}

		}
//.........这里部分代码省略.........