package command

import (
	"context"
	"fmt"
	"path/filepath"
	"strings"

	"go-common/app/tool/saga/model"
	"go-common/app/tool/saga/service/notification"
	"go-common/library/log"
)

type contributor struct {
	Owner    []string
	Author   []string
	Reviewer []string
}

func readContributor(content []byte) (c *contributor) {
	var (
		lines      []string
		lineStr    string
		curSection string
	)
	c = &contributor{}
	lines = strings.Split(string(content), "\n")
	for _, lineStr = range lines {
		if lineStr == "" {
			continue
		}
		if strings.Contains(strings.ToLower(lineStr), "owner") {
			curSection = "owner"
			continue
		}
		if strings.Contains(strings.ToLower(lineStr), "author") {
			curSection = "author"
			continue
		}
		if strings.Contains(strings.ToLower(lineStr), "reviewer") {
			curSection = "reviewer"
			continue
		}
		switch curSection {
		case "owner":
			c.Owner = append(c.Owner, strings.TrimSpace(lineStr))
		case "author":
			c.Author = append(c.Author, strings.TrimSpace(lineStr))
		case "reviewer":
			c.Reviewer = append(c.Reviewer, strings.TrimSpace(lineStr))
		}
	}
	return
}

// BuildContributor ...
func (c *Command) BuildContributor(repo *model.RepoInfo) (err error) {
	var (
		host   string
		token  string
		files  []string
		projID int
		branch = repo.Branch
	)
	if host, token, err = c.gitlab.HostToken(); err != nil {
		return
	}
	if files, err = c.dao.RepoFiles(context.TODO(), host, token, repo); err != nil {
		return
	}
	if projID, err = c.gitlab.ProjectID(fmt.Sprintf("git@%s:%s/%s.git", host, repo.Group, repo.Name)); err != nil {
		return
	}
	if err = c.SaveContributor(projID, branch, files, false); err != nil {
		return
	}
	return
}

func hasbranch(branch string, branchs []string) bool {
	for _, b := range branchs {
		if strings.EqualFold(b, branch) {
			return true
		}
	}
	return false
}

// UpdateContributor ...
func (c *Command) UpdateContributor(projID int, mrIID int, sourceBranch string, targetBranch string, authBranches []string) (err error) {
	var changeFiles []string
	var deleteFiles []string
	if !hasbranch(targetBranch, authBranches) {
		log.Info("UpdateContributor not authBranches: %d, %s, %+v", projID, targetBranch, authBranches)
		return
	}
	if changeFiles, deleteFiles, err = c.gitlab.MRChanges(projID, mrIID); err != nil {
		return
	}

	//log.Info("UpdateContributor: projID: %d, changeFiles: %+v, deleteFiles: %+v", projID, changeFiles, deleteFiles)
	if err = c.SaveContributor(projID, targetBranch, changeFiles, false); err != nil {
		return
	}
	if err = c.SaveContributor(projID, targetBranch, deleteFiles, true); err != nil {
		return
	}
	return
}

// SaveContributor ...
func (c *Command) SaveContributor(projID int, branch string, files []string, clean bool) (err error) {
	var (
		ctx = context.TODO()
		raw []byte
		cb  *contributor
	)
	for _, file := range files {
		if strings.EqualFold(filepath.Base(file), model.SagaContributorsName) {
			path := filepath.Dir(file)
			if clean {
				//delete redis key
				if err = c.dao.DeletePathAuthR(ctx, projID, branch, path); err != nil {
					log.Error("delete Auth Redis key error(%+v) project ID:%d, branch:%s, path:%s", err, projID, branch, path)
					err = nil
				}
				//delete hbase key
				if err = c.dao.DeletePathAuthH(ctx, projID, branch, path); err != nil {
					log.Error("delete Auth hbase key error(%+v) project ID:%d, branch:%s, path:%s", err, projID, branch, path)
					err = nil
				}
			} else {
				if raw, err = c.gitlab.RepoRawFile(projID, branch, file); err != nil {
					return
				}
				cb = readContributor(raw)
				log.Info("SaveContributor projectID:%d, branch:%s, path:%s, owner:%+v, reviewer:%+v", projID, branch, path, cb.Owner, cb.Reviewer)

				//add to redis
				authUser := &model.AuthUsers{
					Owners:    cb.Owner,
					Reviewers: cb.Reviewer,
				}
				if err = c.dao.SetPathAuthR(ctx, projID, branch, path, authUser); err != nil {
					log.Error("Set Auth to Redis error(%+v) project ID:%d, path:%s, owner:%+v, reviewer:%+v", err, projID, path, cb.Owner, cb.Reviewer)
					err = nil
				}

				//add to hbase
				if err = c.dao.SetPathAuthH(ctx, projID, branch, path, cb.Owner, cb.Reviewer); err != nil {
					log.Error("Set Auth to Hbase error(%+v) projectID:%d, branch:%s, path:%s, owner:%+v, reviewer:%+v", err, projID, branch, path, cb.Owner, cb.Reviewer)
					err = nil
				}
			}
		}
	}
	return
}

// checkSuperAuth ...
func checkSuperAuth(username string, reviewedUsers []string, superUsers []string) (ok bool) {
	for _, super := range superUsers {
		if strings.EqualFold(super, username) {
			return true
		}
	}

	for _, r := range reviewedUsers {
		for _, s := range superUsers {
			if strings.EqualFold(r, s) {
				return true
			}
		}
	}
	return false
}

// checkAllPathAuth ...
func (c *Command) checkAllPathAuth(taskInfo *model.TaskInfo) (ok bool, err error) {
	var (
		comment              string
		files                []string
		folders              map[string]string
		owners               []string
		reviewers            []string
		requireOwners        []string
		requireReviewers     []string
		reviewedUsers        []string
		requireReviewFolders []*model.RequireReviewFolder
		username             = taskInfo.Event.User.UserName
		projID               = int(taskInfo.Event.MergeRequest.SourceProjectID)
		mrIID                = int(taskInfo.Event.MergeRequest.IID)
		sourceBranch         = taskInfo.Event.MergeRequest.SourceBranch
		targetBranch         = taskInfo.Event.MergeRequest.TargetBranch
		authBranch           = c.GetAuthBranch(targetBranch, taskInfo.Repo.Config.AuthBranches)
		url                  = taskInfo.Event.ObjectAttributes.URL
		minReviewer          = taskInfo.Repo.Config.MinReviewer
		limitAuth            = taskInfo.Repo.Config.LimitAuth
		minReviewTip         bool
		isOwner              bool
	)

	log.Info("checkAllPathAuth start ... MRIID: %d", mrIID)
	if reviewedUsers, err = c.reviewedUsers(projID, mrIID); err != nil {
		return
	}
	if len(taskInfo.Repo.Config.SuperAuthUsers) > 0 {
		log.Info("checkAllPathAuth MRIID: %d, reviewedUsers: %v, SuperAuthUsers: %v", mrIID, reviewedUsers, taskInfo.Repo.Config.SuperAuthUsers)
		ok = checkSuperAuth(username, reviewedUsers, taskInfo.Repo.Config.SuperAuthUsers)
		if !ok {
			comment, err = c.showRequireSuperAuthComment(taskInfo)
			go notification.WechatAuthor(c.dao, username, url, sourceBranch, targetBranch, comment)
		}
		return
	}

	if files, err = c.gitlab.CompareDiff(projID, targetBranch, sourceBranch); err != nil {
		return
	}

	log.Info("checkAllPathAuth projID:%d, MRIID:%d, reviewedUsers:%+v, files:%+v, targetBranch:%s, sourceBranch:%s", projID, mrIID, reviewedUsers, files, targetBranch, sourceBranch)
	// 去重目录，校验目录权限
	folders = make(map[string]string)
	for _, file := range files {
		folder := filepath.Dir(file)
		if _, has := folders[folder]; !has {
			folders[folder] = folder
			authEnough := false
			ownerPathReviewed := false
			ownerReviewedStat := false
			reviewedCount := 0
			requireOwners = []string{}
			requireReviewers = []string{}
			dir := folder
			for {
				if owners, reviewers, err = c.GetPathAuth(projID, authBranch, dir); err != nil {
					return
				}

				isOwner, ownerPathReviewed = reviewedOwner(owners, reviewedUsers, username)
				num := reviewedNum(reviewers, reviewedUsers)
				reviewedCount = reviewedCount + num

				if isOwner {
					log.Info("checkAllPathAuth user is owner, MRIID: %d, user: %s, owners %v, path: %s", mrIID, username, owners, dir)
					authEnough = true
					break
				}
				if ownerPathReviewed {
					ownerReviewedStat = true
					if reviewedCount >= minReviewer {
						log.Info("checkAllPathAuth owner reviewed and reach minReviewer, user: %s, owners %+v, path: %s, reviewedUsers: %+v, reviewedCount: %d, minReviewer: %d", username, owners, dir, reviewedUsers, reviewedCount, minReviewer)
						authEnough = true
						break
					}
				}

				if (len(requireOwners) == 0) && (len(owners) > 0) {
					log.Info("checkAllPathAuth required owners %v, path: %s, MRIID: %d", owners, dir, mrIID)
					requireOwners = owners
				}
				if (len(requireReviewers) == 0) && (len(reviewers) > 0) {
					log.Info("checkAllPathAuth required reviewers %v, path: %s, MRIID: %d", reviewers, dir, mrIID)
					requireReviewers = reviewers
				}
				if dir == "." {
					break
				}
				if (len(owners) > 0) && limitAuth {
					break
				}
				dir = filepath.Dir(dir)
			}
			if !authEnough {
				requireAuth := &model.RequireReviewFolder{}
				requireAuth.Folder = folder
				if !ownerReviewedStat {
					requireAuth.Owners = requireOwners
				}
				if reviewedCount < minReviewer {
					requireAuth.Reviewers = requireReviewers
					minReviewTip = true
				}
				requireReviewFolders = append(requireReviewFolders, requireAuth)
			}
		}
	}
	if len(requireReviewFolders) > 0 {
		comment, err = c.showRequireAuthComment(taskInfo, requireReviewFolders, minReviewTip)
		go notification.WechatAuthor(c.dao, username, url, sourceBranch, targetBranch, comment)
		return
	}
	ok = true
	return
}

// GetAllPathAuth ...
func (c *Command) GetAllPathAuth(projID int, mrIID int, authBranch string) (pathOwners []model.RequireReviewFolder, err error) {
	var (
		files        []string
		deleteFiles  []string
		folders      map[string]string
		pathOwner    []string
		pathReviewer []string
	)
	if files, deleteFiles, err = c.gitlab.MRChanges(projID, mrIID); err != nil {
		return
	}
	files = append(files, deleteFiles...)
	// 去重目录，校验目录权限
	folders = make(map[string]string)
	for _, file := range files {
		folder := filepath.Dir(file)
		if _, has := folders[folder]; !has {
			folders[folder] = folder
			dir := folder

			for {
				if pathOwner, pathReviewer, err = c.GetPathAuth(projID, authBranch, dir); err != nil {
					return
				}

				if len(pathOwner) > 0 {
					exist := false
					for _, os := range pathOwners {
						if os.Folder == dir {
							exist = true
							break
						}
					}
					if exist {
						break
					}

					requireOwner := model.RequireReviewFolder{}
					requireOwner.Folder = dir
					requireOwner.Owners = pathOwner
					if len(pathReviewer) > 0 {
						requireOwner.Reviewers = pathReviewer
					}

					pathOwners = append(pathOwners, requireOwner)
					break
				}
				if dir == "." {
					break
				}
				dir = filepath.Dir(dir)
			}
		}
	}
	return
}

// GetPathAuth ...
func (c *Command) GetPathAuth(projID int, branch string, path string) (owners []string, reviewers []string, err error) {
	var (
		ctx      = context.TODO()
		authUser *model.AuthUsers
	)

	if authUser, err = c.dao.PathAuthR(ctx, projID, branch, path); err != nil || authUser == nil {
		if err != nil {
			log.Error("GetPathAuthInfo error project ID:%d, branch:%s, path: %s (err: %+v) ", projID, branch, path, err)
		}

		if owners, reviewers, err = c.dao.PathAuthH(ctx, projID, branch, path); err != nil {
			return
		}
		if len(owners) <= 0 && len(reviewers) <= 0 {
			return
		}

		if authUser == nil {
			authUser = new(model.AuthUsers)
		}
		authUser.Owners = owners
		authUser.Reviewers = reviewers
		if err1 := c.dao.SetPathAuthR(ctx, projID, branch, path, authUser); err1 != nil {
			log.Error("SetPathAuthR error project ID:%d, branch:%s, path: %s (err1: %+v) ", projID, branch, path, err1)
		}
		return
	}
	if authUser != nil {
		owners = authUser.Owners
		reviewers = authUser.Reviewers
	}
	return
}

// GetAuthBranch ...
func (c *Command) GetAuthBranch(targetBranch string, authBranches []string) (authBranch string) {
	for _, r := range authBranches {
		if r == targetBranch {
			return r
		}
	}
	return authBranches[0]
}

// showRequireAuthComment ...
func (c *Command) showRequireAuthComment(taskInfo *model.TaskInfo, requireReviewFolders []*model.RequireReviewFolder, minReviewTip bool) (comment string, err error) {
	var (
		username    = taskInfo.Event.User.UserName
		mrIID       = int(taskInfo.Event.MergeRequest.IID)
		projID      = int(taskInfo.Event.MergeRequest.SourceProjectID)
		noteID      = taskInfo.NoteID
		minReviewer = taskInfo.Repo.Config.MinReviewer
	)

	if minReviewTip {
		comment = fmt.Sprintf("<pre>[%s]尝试合并失败，无权限的文件目录如下，并且最少需要review人数 [%d] 个，请寻找对应的大佬 +1 后再 +merge：</pre>", username, minReviewer)
	} else {
		comment = fmt.Sprintf("<pre>[%s]尝试合并失败，无权限的文件目录如下，请寻找对应的大佬 +1 后再 +merge：</pre>", username)
	}
	comment += "\n"

	for _, reviewFolder := range requireReviewFolders {
		comment += fmt.Sprintf("+ %s ", reviewFolder.Folder)
		if len(reviewFolder.Owners) > 0 {
			comment += "；OWNER: "
			for _, o := range reviewFolder.Owners {
				if o == "all" {
					comment += "所有人" + " 或 "
				} else {
					comment += o + " 或 "
				}
			}
			comment = comment[:len(comment)-len(" 或 ")]
		}
		if len(reviewFolder.Reviewers) > 0 {
			comment += "；REVIEWER: "
			for _, o := range reviewFolder.Reviewers {
				if o == "all" {
					comment += "所有人" + " 与 "
				} else {
					comment += o + " 与 "
				}
			}
			comment = comment[:len(comment)-len(" 与 ")]
			//comment += fmt.Sprintf("<pre>; 已review人数 [%d] 个</pre>", minReviewer)
		}
		comment += "\n\n"
	}

	err = c.gitlab.UpdateMRNote(projID, mrIID, noteID, comment)
	return
}

// showRequireSuperAuthComment ...
func (c *Command) showRequireSuperAuthComment(taskInfo *model.TaskInfo) (comment string, err error) {
	var (
		username = taskInfo.Event.User.UserName
		mrIID    = int(taskInfo.Event.MergeRequest.IID)
		projID   = int(taskInfo.Event.MergeRequest.SourceProjectID)
		noteID   = taskInfo.NoteID
	)

	comment = fmt.Sprintf("<pre>[%s]尝试合并失败，已配置超级权限用户，请寻找其中至少一位大佬 +1 后再 +merge：</pre>", username)
	comment += "\n"

	comment += fmt.Sprintf("+ SUPERMAN: ")
	for _, user := range taskInfo.Repo.Config.SuperAuthUsers {
		comment += fmt.Sprintf("%s 或 ", user)
	}
	comment = comment[:len(comment)-len(" 或 ")]

	err = c.gitlab.UpdateMRNote(projID, mrIID, noteID, comment)
	return
}