Goit

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

package repo

import (
	"errors"
	"log"
	"net/http"
	"path/filepath"
	"slices"
	"strings"
	"time"

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

func HandleRefs(w http.ResponseWriter, r *http.Request) {
	auth, user, err := goit.Auth(w, r, true)
	if err != nil {
		log.Println("[admin]", 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 row struct {
		Name, Hash, Message, Author, LastCommit string
		Commits                                 uint64
	}
	data := struct {
		HeaderFields
		Title          string
		Branches, Tags []row
	}{
		Title:        repo.Name + " - References",
		HeaderFields: GetHeaderFields(auth, user, repo, r.Host),
	}

	gr, err := git.PlainOpen(goit.RepoPath(repo.Name, true))
	if err != nil {
		log.Println("[/repo/refs]", 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)
		}
	}

	if iter, err := gr.Branches(); err != nil {
		log.Println("[/repo/refs]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	} else if err := iter.ForEach(func(r *plumbing.Reference) error {
		commit, err := gr.CommitObject(r.Hash())
		if err != nil {
			return err
		}

		commits, err := goit.CommitCount(repo.Name, r.Name().Short(), r.Hash())
		if err != nil {
			return err
		}

		data.Branches = append(data.Branches, row{
			Name: r.Name().Short(), Hash: r.Hash().String(), Message: strings.SplitN(commit.Message, "\n", 2)[0],
			Author: commit.Author.Name, LastCommit: commit.Author.When.UTC().Format(time.DateTime), Commits: commits,
		})

		return nil
	}); err != nil {
		log.Println("[/repo/refs]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	}

	if iter, err := gr.Tags(); err != nil {
		log.Println("[/repo/refs]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	} else if err := iter.ForEach(func(r *plumbing.Reference) error {
		var c *object.Commit

		if tag, err := gr.TagObject(r.Hash()); err != nil {
			if !errors.Is(err, plumbing.ErrObjectNotFound) {
				return err
			}
		} else {
			if c, err = gr.CommitObject(tag.Target); err != nil {
				return err
			}
		}

		if c == nil {
			if c, err = gr.CommitObject(r.Hash()); err != nil {
				return err
			}
		}

		data.Tags = append(data.Tags, row{
			Name: r.Name().Short(), Message: strings.SplitN(c.Message, "\n", 2)[0], Author: c.Author.Name,
			LastCommit: c.Author.When.UTC().Format(time.DateTime), Hash: r.Hash().String(),
		})

		return nil
	}); err != nil {
		log.Println("[/repo/refs]", err.Error())
		goit.HttpError(w, http.StatusInternalServerError)
		return
	}

	slices.Reverse(data.Tags)

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