Goit

// Copyright (C) 2023, Jakob Wakeling
// All rights reserved.

package repo

import (
	"errors"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/Jamozed/Goit/src/goit"
	"github.com/buildkite/terminal-to-html/v3"
	"github.com/go-chi/chi/v5"
	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/plumbing"
)

func HandleCommit(w http.ResponseWriter, r *http.Request) {
	auth, user, err := goit.Auth(w, r, true)
	if err != nil {
		log.Println("[/repo/commit]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
	}

	repo, err := goit.GetRepoByName(chi.URLParam(r, "repo"))
	if err != nil {
		goit.HttpError(w, http.StatusInternalServerError)
		return
	} else if repo == nil || !goit.IsVisible(repo, auth, user) {
		goit.HttpError(w, http.StatusNotFound)
		return
	}

	type stat struct {
		Name, Path, Status, Num, Plusses, Minuses string
		IsBinary                                  bool
	}

	data := struct {
		HeaderFields
		Title                       string
		Author, Date, Commit        string
		Parents                     []string
		MessageSubject, MessageBody string
		Stats                       []stat
		Summary                     string
		Diff                        template.HTML
	}{
		Title:        repo.Name + " - Log",
		HeaderFields: GetHeaderFields(auth, user, repo, r.Host),
	}

	gr, err := git.PlainOpen(goit.RepoPath(repo.Name, true))
	if err != nil {
		log.Println("[/repo/commit]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	}

	ref, err := gr.Head()
	if err != nil {
		if !errors.Is(err, plumbing.ErrReferenceNotFound) {
			log.Println("[/repo/log]", err.Error())
			goit.HttpError(w, http.StatusInternalServerError)
			return
		}
	} else {
		if readme, _ := findPattern(gr, ref, readmePattern); readme != "" {
			data.Readme = filepath.Join("/", repo.Name, "file", readme)
		}
		if licence, _ := findPattern(gr, ref, licencePattern); licence != "" {
			data.Licence = filepath.Join("/", repo.Name, "file", licence)
		}
	}

	commit, err := gr.CommitObject(plumbing.NewHash(chi.URLParam(r, "hash")))
	if errors.Is(err, plumbing.ErrObjectNotFound) {
		goit.HttpError(w, http.StatusNotFound)
		return
	} else if err != nil {
		log.Println("[/repo/commit]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	}

	data.Author = commit.Author.String()
	data.Date = commit.Author.When.UTC().Format(time.DateTime)
	data.Commit = commit.Hash.String()

	for _, h := range commit.ParentHashes {
		data.Parents = append(data.Parents, h.String())
	}

	data.MessageSubject, data.MessageBody, _ = strings.Cut(commit.Message, "\n")

	st, err := goit.DiffStats(commit)
	if err != nil {
		log.Println("[/repo/commit]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	}

	var files, additions, deletions int = len(st), 0, 0
	for _, s := range st {
		f := stat{Name: s.Name, Path: s.Name, Status: s.Status}
		f.Num = strconv.FormatInt(int64(s.Addition+s.Deletion), 10)

		if s.Addition+s.Deletion > 80 {
			f.Plusses = strings.Repeat("+", (s.Addition*80)/(s.Addition+s.Deletion))
			f.Minuses = strings.Repeat("-", (s.Deletion*80)/(s.Addition+s.Deletion))
		} else {
			f.Plusses = strings.Repeat("+", s.Addition)
			f.Minuses = strings.Repeat("-", s.Deletion)
		}

		if s.Status == "R" {
			f.Name = s.Prev + " -> " + s.Name
		}
		if s.IsBinary {
			f.IsBinary = true
		}

		data.Stats = append(data.Stats, f)

		additions += s.Addition
		deletions += s.Deletion
	}

	data.Summary = fmt.Sprintf("%d files changed, %d insertions, %d deletions", files, additions, deletions)

	var phash string
	if commit.NumParents() > 0 {
		phash = commit.ParentHashes[0].String()
	} else {
		phash = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
	}

	c := goit.NewGitCommand("diff", "--color=always", "-p", phash, commit.Hash.String())
	c.Dir = goit.RepoPath(repo.Name, true)
	out, _, err := c.Run(nil, nil)
	if err != nil {
		log.Println("[/repo/commit]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	}

	data.Diff = template.HTML(terminal.Render(out))

	if err := goit.Tmpl.ExecuteTemplate(w, "repo/commit", data); err != nil {
		log.Println("[/repo/commit]", err.Error())
	}
}