Goit

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

package repo

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

	"github.com/Jamozed/Goit/src/goit"
	"github.com/Jamozed/Goit/src/util"
	"github.com/go-chi/chi/v5"
	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/plumbing"
)

const PAGE = 100

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

	tpath := chi.URLParam(r, "*")

	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
	}

	offset := int64(0)
	if o := r.URL.Query().Get("o"); o != "" {
		if i, err := strconv.ParseInt(o, 10, 64); err != nil {
			goit.HttpError(w, http.StatusBadRequest)
			return
		} else {
			offset = i
		}
	}

	type row struct{ Hash, Date, Message, Author, Files, Additions, Deletions string }
	data := struct {
		HeaderFields
		Title                        string
		Commits                      []row
		Page, PrevOffset, NextOffset int64
	}{
		Title:        repo.Name + " - Log",
		HeaderFields: GetHeaderFields(auth, user, repo, r.Host),

		Page:       offset/PAGE + 1,
		PrevOffset: util.Max(offset-PAGE, -1),
		NextOffset: offset + PAGE,
	}

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

	ref, err := gr.Head()
	if errors.Is(err, plumbing.ErrReferenceNotFound) {
		data.NextOffset = 0
		goto execute
	} else if err != nil {
		log.Println("[/repo/log]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	}

	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)
	}

	if iter, err := gr.Log(&git.LogOptions{
		From: ref.Hash(), Order: git.LogOrderCommitterTime, PathFilter: func(s string) bool {
			return tpath == "" || s == tpath || strings.HasPrefix(s, tpath+"/")
		},
	}); err != nil {
		log.Println("[/repo/log]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	} else {
		for i := int64(0); i < offset; i += 1 {
			if _, err := iter.Next(); err != nil {
				if errors.Is(err, io.EOF) {
					data.NextOffset = 0
					goto execute
				}

				log.Println("[/repo/log]", err.Error())
				goit.HttpError(w, http.StatusInternalServerError)
				return
			}
		}

		for i := 0; i < PAGE; i += 1 {
			c, err := iter.Next()
			if errors.Is(err, io.EOF) {
				data.NextOffset = 0
				goto execute
			} else if err != nil {
				log.Println("[/repo/log]", err.Error())
				goit.HttpError(w, http.StatusInternalServerError)
				return
			}

			var files, additions, deletions int

			if stats, err := goit.DiffStats(c); err != nil {
				log.Println("[/repo/log]", err.Error())
			} else {
				files = len(stats)
				for _, s := range stats {
					additions += s.Addition
					deletions += s.Deletion
				}
			}

			data.Commits = append(data.Commits, row{
				Hash: c.Hash.String(), Date: c.Author.When.UTC().Format(time.DateTime),
				Message: strings.SplitN(c.Message, "\n", 2)[0], Author: c.Author.Name, Files: fmt.Sprint(files),
				Additions: "+" + fmt.Sprint(additions), Deletions: "-" + fmt.Sprint(deletions),
			})
		}

		if _, err := iter.Next(); errors.Is(err, io.EOF) {
			data.NextOffset = 0
		}
	}

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