package git

import (
	"bufio"
	"context"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
	"time"

	"code.gitea.io/gitea/modules/container"
	gitea_git "code.gitea.io/gitea/modules/git"
)

type CodeActivityStats struct {
	AuthorCount              int64                 `json:"author_count"`
	CommitCount              int64                 `json:"commit_count"`
	ChangedFiles             int64                 `json:"changed_files"`
	Additions                int64                 `json:"additions"`
	Deletions                int64                 `json:"deletions"`
	CommitCountInAllBranches int64                 `json:"commit_count_in_all_branches"`
	Authors                  []*CodeActivityAuthor `json:"authors"`
}

type CodeActivityAuthor struct {
	Name      string `json:"name"`
	Email     string `json:"email"`
	Commits   int64  `json:"commits"`
	Additions int64  `json:"additions"`
	Deletions int64  `json:"deletions"`
}

// GetCodeActivityStats returns code statistics for activity page
func GetCodeActivityStatsWithoutSince(repo *gitea_git.Repository, branch string) (*CodeActivityStats, error) {
	stats := &CodeActivityStats{}

	stdout, _, runErr := gitea_git.NewCommand(repo.Ctx, "rev-list", "--count", "--no-merges", "--branches=*", "--date=iso").RunStdString(&gitea_git.RunOpts{Dir: repo.Path})
	if runErr != nil {
		return nil, runErr
	}

	c, err := strconv.ParseInt(strings.TrimSpace(stdout), 10, 64)
	if err != nil {
		return nil, err
	}
	stats.CommitCountInAllBranches = c

	stdoutReader, stdoutWriter, err := os.Pipe()
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = stdoutReader.Close()
		_ = stdoutWriter.Close()
	}()
	gitCmd := gitea_git.NewCommand(repo.Ctx, "log", "--numstat", "--no-merges", "--pretty=format:---%n%h%n%aN%n%aE%n", "--date=iso")
	if len(branch) == 0 {
		gitCmd.AddArguments("--branches=*")
	} else {
		gitCmd.AddArguments("--first-parent").AddDynamicArguments(branch)
	}

	stderr := new(strings.Builder)
	err = gitCmd.Run(&gitea_git.RunOpts{
		Env:    []string{},
		Dir:    repo.Path,
		Stdout: stdoutWriter,
		Stderr: stderr,
		PipelineFunc: func(ctx context.Context, cancel context.CancelFunc) error {
			_ = stdoutWriter.Close()
			scanner := bufio.NewScanner(stdoutReader)
			scanner.Split(bufio.ScanLines)
			stats.CommitCount = 0
			stats.Additions = 0
			stats.Deletions = 0
			authors := make(map[string]*CodeActivityAuthor)
			files := make(container.Set[string])
			var author string
			var currentAuthor *CodeActivityAuthor
			p := 0
			for scanner.Scan() {
				l := strings.TrimSpace(scanner.Text())
				if l == "---" {
					p = 1
				} else if p == 0 {
					continue
				} else {
					p++
				}
				if p > 4 && len(l) == 0 {
					continue
				}
				switch p {
				case 1: // Separator
				case 2: // Commit sha-1
					stats.CommitCount++
				case 3: // Author
					author = l
				case 4: // E-mail
					email := strings.ToLower(l)
					if _, ok := authors[email+author]; !ok {
						authors[email+author] = &CodeActivityAuthor{Name: author, Email: email, Commits: 0}
					}
					authors[email+author].Commits++
					currentAuthor = authors[email+author]
				default: // Changed file
					if parts := strings.Fields(l); len(parts) >= 3 {
						if parts[0] != "-" {
							if c, err := strconv.ParseInt(strings.TrimSpace(parts[0]), 10, 64); err == nil {
								stats.Additions += c
								currentAuthor.Additions += c
							}
						}
						if parts[1] != "-" {
							if c, err := strconv.ParseInt(strings.TrimSpace(parts[1]), 10, 64); err == nil {
								stats.Deletions += c
								currentAuthor.Deletions += c
							}
						}
						files.Add(parts[2])
					}
				}
			}
			a := make([]*CodeActivityAuthor, 0, len(authors))
			for _, v := range authors {
				a = append(a, v)
			}
			// Sort authors descending depending on commit count
			sort.Slice(a, func(i, j int) bool {
				return a[i].Commits > a[j].Commits
			})
			stats.AuthorCount = int64(len(authors))
			stats.ChangedFiles = int64(len(files))
			stats.Authors = a
			_ = stdoutReader.Close()
			return nil
		},
	})
	if err != nil {
		return nil, fmt.Errorf("Failed to get GetCodeActivityStats for repository.\nError: %w\nStderr: %s", err, stderr)
	}

	return stats, nil
}

// GetCodeActivityStats returns code statistics for activity page
func GetPaginateCodeAuthors(repo *gitea_git.Repository, fromTime time.Time, branch string, page, pageSize int) (int64, []*CodeActivityAuthor, error) {
	var total int64
	var authors []*CodeActivityAuthor
	since := fromTime.Format(time.RFC3339)

	authorCmd := gitea_git.NewCommand(repo.Ctx, "log", "--no-merges", "--format=%aN <%aE>", "--date=iso").AddDynamicArguments(fmt.Sprintf("--since='%s'", since))
	if len(branch) == 0 {
		authorCmd.AddArguments("--branches=*")
	} else {
		authorCmd.AddArguments("--first-parent").AddDynamicArguments(branch)
	}
	authorStdout, _, runErr := authorCmd.RunStdString(&gitea_git.RunOpts{Dir: repo.Path})
	if runErr != nil {
		return total, nil, runErr
	}

	skip := (page - 1) * pageSize

	var filterAuthor string
	var ca int
	authorArr := strings.Split(authorStdout, "\n")
	authorSet := make(map[string]bool, len(authorArr))
	for _, author := range authorArr {
		_, ok := authorSet[author]
		if ok || author == "" {
			continue
		}
		authorSet[author] = true
		authorArr[total] = author
		total++
		if skip > 0 {
			skip--
		} else {
			if ca < pageSize {
				if ca != 0 {
					filterAuthor += "\\|"
				}
				filterAuthor += author
				ca++
			}
		}
	}

	if filterAuthor == "" {
		return total, authors, nil
	}

	stdoutReader, stdoutWriter, err := os.Pipe()
	if err != nil {
		return total, nil, err
	}
	defer func() {
		_ = stdoutReader.Close()
		_ = stdoutWriter.Close()
	}()
	gitCmd := gitea_git.NewCommand(repo.Ctx, "log", "--numstat", "--no-merges", "--pretty=format:---%n%h%n%aN%n%aE%n", "--date=iso").AddDynamicArguments(fmt.Sprintf("--author=%s", filterAuthor))
	if len(branch) == 0 {
		gitCmd.AddArguments("--branches=*")
	} else {
		gitCmd.AddArguments("--first-parent").AddDynamicArguments(branch)
	}

	stderr := new(strings.Builder)
	err = gitCmd.Run(&gitea_git.RunOpts{
		Env:    []string{},
		Dir:    repo.Path,
		Stdout: stdoutWriter,
		Stderr: stderr,
		PipelineFunc: func(ctx context.Context, cancel context.CancelFunc) error {
			_ = stdoutWriter.Close()
			scanner := bufio.NewScanner(stdoutReader)
			scanner.Split(bufio.ScanLines)
			authorsMap := make(map[string]*CodeActivityAuthor)
			files := make(container.Set[string])
			var author string
			var currentAuthor *CodeActivityAuthor
			p := 0
			for scanner.Scan() {
				l := strings.TrimSpace(scanner.Text())
				if l == "---" {
					p = 1
				} else if p == 0 {
					continue
				} else {
					p++
				}
				if p > 4 && len(l) == 0 {
					continue
				}
				switch p {
				case 1: // Separator
				case 2: // Commit sha-1
				case 3: // Author
					author = l
				case 4: // E-mail
					email := strings.ToLower(l)
					if _, ok := authorsMap[email+author]; !ok {
						authorsMap[email+author] = &CodeActivityAuthor{Name: author, Email: email, Commits: 0}
					}
					authorsMap[email+author].Commits++
					currentAuthor = authorsMap[email+author]
				default: // Changed file
					if parts := strings.Fields(l); len(parts) >= 3 {
						if parts[0] != "-" {
							if c, err := strconv.ParseInt(strings.TrimSpace(parts[0]), 10, 64); err == nil {
								currentAuthor.Additions += c
							}
						}
						if parts[1] != "-" {
							if c, err := strconv.ParseInt(strings.TrimSpace(parts[1]), 10, 64); err == nil {
								currentAuthor.Deletions += c
							}
						}
						files.Add(parts[2])
					}
				}
			}
			for _, v := range authorsMap {
				authors = append(authors, v)
			}

			_ = stdoutReader.Close()
			return nil
		},
	})
	if err != nil {
		return total, nil, fmt.Errorf("Failed to get GetCodeActivityStats for repository.\nError: %w\nStderr: %s", err, stderr)
	}

	return total, authors, nil
}
