// Copyright 2016 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package godash

import (
	"bytes"
	"fmt"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"time"

	"golang.org/x/build/gerrit"
)

// Parsing of Gerrit information and review messages to produce CL structure.

var (
	reviewerRE   = regexp.MustCompile(`(?m)^R=([\w\-.@]+)\b`)
	issueRefRE   = regexp.MustCompile(`#\d+\b`)
	goIssueRefRE = regexp.MustCompile(`\bgolang/go#\d+\b`)
)

// ParseCL takes a ChangeInfo as returned from the Gerrit API and
// applies Go-project-specific logic to turn it into a CL struct. The
// primary information that is added is the CL's state in the Go
// review process, based on parsing R= lines in the comments and the
// most recent commit message of the CL.
func ParseCL(ci *gerrit.ChangeInfo, reviewers *Reviewers, goReleaseCycle int) *CL {
	// Gather information.
	var (
		scores           = make(map[string]int)
		initialReviewer  = ""
		firstResponder   = ""
		explicitReviewer = ""
		closeReason      = ""
	)
	parseReviewer := func(msg string) {
		if m := reviewerRE.FindStringSubmatch(msg); m != nil {
			if m[1] == "close" {
				explicitReviewer = "close"
				closeReason = "Closed"
			} else if strings.HasPrefix(m[1], "go1.") {
				n, _ := strconv.Atoi(m[1][len("go1."):])
				if n > goReleaseCycle {
					explicitReviewer = "close"
					closeReason = "Go" + m[1][2:]
				}
			} else if m[1] == "golang-dev" || m[1] == "golang-codereviews" {
				explicitReviewer = "golang-dev"
			} else if x := reviewers.Resolve(m[1]); x != "" {
				explicitReviewer = x
			}
		}
	}

	rev := ci.Revisions[ci.CurrentRevision]

	for _, msg := range ci.Messages {
		if msg.Author == nil { // happens for Gerrit-generated messages
			continue
		}
		if strings.HasPrefix(msg.Message, "Uploaded patch set ") {
			if explicitReviewer == "close" && !strings.HasPrefix(closeReason, "Go") {
				explicitReviewer = ""
				closeReason = ""
			}
			if msg.RevisionNumber == rev.PatchSetNumber && rev.Commit != nil {
				parseReviewer(rev.Commit.Message)
			}
		}
		parseReviewer(msg.Message)
		if firstResponder == "" && reviewers.IsReviewer(msg.Author.Email) && msg.Author.Email != ci.Owner.Email {
			firstResponder = msg.Author.Email
		}
	}
	for _, score := range ci.Labels["Code-Review"].All {
		scores[score.Email] = score.Value
	}

	cl := &CL{
		Number:      ci.ChangeNumber,
		Subject:     ci.Subject,
		Project:     ci.Project,
		Author:      reviewers.Shorten(ci.Owner.Email),
		AuthorEmail: ci.Owner.Email,
		Scores:      scores,
		Status:      strings.ToLower(ci.Status),
	}

	// Determine reviewer, in priorty order.
	// When breaking ties, give preference to R= setting.
	// Otherwise compare by email address.
	maybe := func(who string) {
		if cl.ReviewerEmail == "" || who == explicitReviewer || cl.ReviewerEmail != explicitReviewer && cl.ReviewerEmail > who {
			cl.ReviewerEmail = who
		}
	}

	// 1. Anyone who -2'ed the CL.
	if cl.ReviewerEmail == "" {
		for who, score := range scores {
			if score == -2 {
				maybe(who)
			}
		}
	}

	// 2. Anyone who +2'ed the CL.
	if cl.ReviewerEmail == "" {
		for who, score := range scores {
			if score == +2 {
				maybe(who)
			}
		}
	}

	// 2½. Even if a CL is +2 or -2, R=closed wins,
	// so that it doesn't appear in listings by default.
	if explicitReviewer == "close" {
		cl.ReviewerEmail = "close"
	}

	// 3. Last explicit R= in review message.
	if cl.ReviewerEmail == "" {
		cl.ReviewerEmail = explicitReviewer
	}
	// 4. Initial target of review requecl.
	// TODO: If there's some way to figure this out, do so.
	_ = initialReviewer
	// 5. Whoever responds first and looks like a reviewer.
	if cl.ReviewerEmail == "" {
		cl.ReviewerEmail = firstResponder
	}

	// Allow R=golang-dev in #2 as "unassign".
	if cl.ReviewerEmail == "golang-dev" {
		cl.ReviewerEmail = ""
	}

	cl.Reviewer = reviewers.Shorten(cl.ReviewerEmail)

	// Now that we know who the reviewer is,
	// figure out whether the CL is in need of review
	// (or else is waiting for the author to do more work).
	for _, msg := range ci.Messages {
		if msg.Author == nil { // happens for Gerrit-generated messages
			continue
		}
		if cl.Start.IsZero() {
			cl.Start = msg.Time.Time()
		}
		if strings.HasPrefix(msg.Message, "Uploaded patch set ") {
			cl.NeedsReview = true
			cl.NeedsReviewChanged = msg.Time.Time()
		}
		if msg.Author.Email == cl.ReviewerEmail {
			cl.NeedsReview = false
			cl.NeedsReviewChanged = msg.Time.Time()
		}
	}

	if cl.ReviewerEmail == "close" {
		cl.Reviewer = closeReason
		cl.ReviewerEmail = ""
		cl.Closed = true
		cl.NeedsReview = false
	}

	// DO NOT REVIEW overrides anything in the CL state.
	// We shouldn't see these, because the query always
	// contains -message:do-not-review, but check anyway.
	if _, ok := ci.Labels["Do-Not-Review"]; ok {
		cl.Reviewer = "DoNotReview"
		cl.ReviewerEmail = ""
		cl.DoNotReview = true
		cl.NeedsReview = false
	}

	// Find issue numbers.
	cl.Issues = []int{} // non-nil for json
	refRE := issueRefRE
	if cl.Project != "go" {
		refRE = goIssueRefRE
	}

	for file := range rev.Files {
		cl.Files = append(cl.Files, file)
	}
	sort.Strings(cl.Files)
	if rev.Commit != nil {
		for _, ref := range refRE.FindAllString(rev.Commit.Message, -1) {
			n, _ := strconv.Atoi(ref[strings.Index(ref, "#")+1:])
			if n != 0 {
				cl.Issues = append(cl.Issues, n)
			}
		}
	}
	cl.Issues = uniq(cl.Issues)

	return cl
}

func uniq(x []int) []int {
	sort.Ints(x)
	out := x[:0]
	for _, v := range x {
		if len(out) == 0 || out[len(out)-1] != v {
			out = append(out, v)
		}
	}
	return out
}

// CL records information about a single CL.
// This is also used by golang.org/x/build/cmd/cl and any changes need
// to reflected in its doc comment.
type CL struct {
	Number             int            // CL number
	Subject            string         // subject (first line of commit message)
	Project            string         // "go" or a subrepository name
	Author             string         // author, short form or else full email
	AuthorEmail        string         // author, full email
	Reviewer           string         // expected reviewer, short form or else full email
	ReviewerEmail      string         // expected reviewer, full email
	Start              time.Time      // time CL was first uploaded
	NeedsReview        bool           // CL is waiting for reviewer (otherwise author)
	NeedsReviewChanged time.Time      // time NeedsReview last changed
	Closed             bool           // CL closed with R=close
	DoNotReview        bool           // CL marked DO NOT REVIEW
	Issues             []int          // issues referenced by commit message
	Scores             map[string]int // current review scores
	Files              []string       // files changed in CL
	Status             string         // "new", "submitted", "merged", ...
}

func (cl *CL) Age(now time.Time) time.Duration {
	return now.Sub(cl.Start)
}

func (cl *CL) Delay(now time.Time) time.Duration {
	return now.Sub(cl.NeedsReviewChanged)
}

func (cl *CL) Summary(now time.Time) string {
	var buf bytes.Buffer
	who := "author"
	if cl.NeedsReview {
		who = "reviewer"
	}
	rev := cl.Reviewer
	if rev == "" {
		rev = "???"
	}
	score := ""
	if x := cl.Scores[cl.ReviewerEmail]; x != 0 {
		score = fmt.Sprintf("%+d", x)
	}
	fmt.Fprintf(&buf, "%s → %s%s, %d/%d days, waiting for %s", cl.Author, rev, score, int(now.Sub(cl.NeedsReviewChanged).Seconds()/86400), int(now.Sub(cl.Start).Seconds()/86400), who)
	for _, id := range cl.Issues {
		fmt.Fprintf(&buf, " #%d", id)
	}
	return buf.String()
}