mugit @ 99ee247

package handlers

import (

	"bytes"

	"errors"

	"fmt"

	"html/template"

	"io"

	"log/slog"

	"net/http"

	"os"

	"path/filepath"

	"sort"

	"strconv"

	"strings"

	"time"

	securejoin "github.com/cyphar/filepath-securejoin"

	"github.com/yuin/goldmark"

	"github.com/yuin/goldmark/extension"

	"github.com/yuin/goldmark/renderer/html"

	"olexsmir.xyz/mugit/internal/git"

)

func (h *handlers) indexHandler(w http.ResponseWriter, r *http.Request) {

	repos, err := h.listPublicRepos()

	if err != nil {

		h.write500(w, err)

		return

	}

	data := make(map[string]any)

	data["meta"] = h.c.Meta

	data["repos"] = repos

	h.templ(w, "index", data)

}

var markdown = goldmark.New(

	goldmark.WithRendererOptions(html.WithUnsafe()),

	goldmark.WithExtensions(

		extension.GFM,

		extension.Linkify,

	))

func (h *handlers) repoIndex(w http.ResponseWriter, r *http.Request) {

	name := getNormalizedName(r.PathValue("name"))

	repo, err := h.openPublicRepo(name, "")

	if err != nil {

		h.write404(w, err)

		return

	}

	desc, err := repo.Description()

	if err != nil {

		h.write500(w, err)

		return

	}

	data := make(map[string]any)

	data["name"] = name

	data["desc"] = desc

	data["servername"] = h.c.Meta.Host

	data["meta"] = h.c.Meta

	if repo.IsEmpty() {

		data["empty"] = true

		h.templ(w, "repo_index", data)

		return

	}

	var readmeContents template.HTML

	for _, readme := range h.c.Repo.Readmes {

		ext := filepath.Ext(readme)

		content, _ := repo.FileContent(readme)

		if len(content) > 0 {

			switch ext {

			case ".md", ".markdown", ".mkd":

				var buf bytes.Buffer

				if cerr := markdown.Convert([]byte(content), &buf); cerr != nil {

					h.write500(w, cerr)

					return

				}

				readmeContents = template.HTML(buf.String())

			default:

				readmeContents = template.HTML(fmt.Sprintf(`<pre>%s</pre>`, content))

			}

			break

		}

	}

	masterBranch, err := repo.FindMasterBranch(h.c.Repo.Masters)

	if err != nil {

		h.write500(w, err)

		return

	}

	commits, err := repo.Commits()

	if err != nil {

		h.write500(w, err)

		return

	}

	if len(commits) >= 4 {

		commits = commits[:3]

	}

	data["ref"] = masterBranch

	data["readme"] = readmeContents

	data["commits"] = commits

	data["gomod"] = repo.IsGoMod()

	if isMirror, err := repo.IsMirror(); err == nil && isMirror {

		lastSync, _ := repo.LastSync()

		remoteURL, _ := repo.RemoteURL()

		data["mirrorinfo"] = map[string]any{

			"isMirror": true,

			"url":      remoteURL,

			"lastSync": lastSync,

		}

	}

	h.templ(w, "repo_index", data)

}

func (h *handlers) repoTreeHandler(w http.ResponseWriter, r *http.Request) {

	name := getNormalizedName(r.PathValue("name"))

	ref := r.PathValue("ref")

	treePath := r.PathValue("rest")

	repo, err := h.openPublicRepo(name, ref)

	if err != nil {

		h.write404(w, err)

		return

	}

	desc, err := repo.Description()

	if err != nil {

		h.write500(w, err)

		return

	}

	files, err := repo.FileTree(treePath)

	if err != nil {

		h.write500(w, err)

		return

	}

	data := make(map[string]any)

	data["name"] = name

	data["ref"] = ref

	data["parent"] = treePath

	data["dotdot"] = filepath.Dir(treePath)

	data["desc"] = desc

	data["meta"] = h.c.Meta

	data["files"] = files

	h.templ(w, "repo_tree", data)

}

func (h *handlers) fileContentsHandler(w http.ResponseWriter, r *http.Request) {

	name := getNormalizedName(r.PathValue("name"))

	ref := r.PathValue("ref")

	treePath := r.PathValue("rest")

	var raw bool

	if rawParam, err := strconv.ParseBool(r.URL.Query().Get("raw")); err == nil {

		raw = rawParam

	}

	repo, err := h.openPublicRepo(name, ref)

	if err != nil {

		h.write404(w, err)

		return

	}

	desc, err := repo.Description()

	if err != nil {

		h.write500(w, err)

		return

	}

	contents, err := repo.FileContent(treePath)

	if err != nil {

		if errors.Is(err, git.ErrFileNotFound) {

			h.write404(w, err)

			return

		}

		h.write500(w, err)

		return

	}

	if raw {

		w.WriteHeader(http.StatusOK)

		w.Header().Set("Content-Type", "text/plain")

		w.Write([]byte(contents))

		return

	}

	data := make(map[string]any)

	data["name"] = name

	data["ref"] = ref

	data["desc"] = desc

	data["path"] = treePath

	lc, err := countLines(strings.NewReader(contents))

	if err != nil {

		slog.Error("failed to count line numbers", "err", err)

	}

	lines := make([]int, lc)

	if lc > 0 {

		for i := range lines {

			lines[i] = i + 1

		}

	}

	data["linecount"] = lines

	data["content"] = contents

	data["meta"] = h.c.Meta

	h.templ(w, "repo_file", data)

}

func (h *handlers) logHandler(w http.ResponseWriter, r *http.Request) {

	name := getNormalizedName(r.PathValue("name"))

	ref := r.PathValue("ref")

	repo, err := h.openPublicRepo(name, ref)

	if err != nil {

		h.write404(w, err)

		return

	}

	commits, err := repo.Commits()

	if err != nil {

		h.write500(w, err)

		return

	}

	desc, err := repo.Description()

	if err != nil {

		h.write500(w, err)

		return

	}

	data := make(map[string]any)

	data["name"] = name

	data["ref"] = ref

	data["desc"] = desc

	data["meta"] = h.c.Meta

	data["log"] = true

	data["commits"] = commits

	h.templ(w, "repo_log", data)

}

func (h *handlers) commitHandler(w http.ResponseWriter, r *http.Request) {

	name := getNormalizedName(r.PathValue("name"))

	ref := r.PathValue("ref")

	repo, err := h.openPublicRepo(name, ref)

	if err != nil {

		h.write404(w, err)

		return

	}

	diff, err := repo.Diff()

	if err != nil {

		h.write500(w, err)

		return

	}

	desc, err := repo.Description()

	if err != nil {

		h.write500(w, err)

		return

	}

	data := make(map[string]any)

	data["stat"] = diff.Stat

	data["diff"] = diff.Diff

	data["commit"] = diff.Commit

	data["name"] = name

	data["ref"] = ref

	data["desc"] = desc

	h.templ(w, "repo_commit", data)

}

func (h *handlers) refsHandler(w http.ResponseWriter, r *http.Request) {

	name := getNormalizedName(r.PathValue("name"))

	repo, err := h.openPublicRepo(name, "")

	if err != nil {

		h.write404(w, err)

		return

	}

	desc, err := repo.Description()

	if err != nil {

		h.write500(w, err)

		return

	}

	branches, err := repo.Branches()

	if err != nil {

		h.write500(w, err)

		return

	}

	tags, err := repo.Tags()

	if err != nil {

		// repo should have at least one branch, tags are *optional*

		slog.Error("couldn't fetch repo tags", "err", err)

	}

	data := make(map[string]any)

	data["meta"] = h.c.Meta

	data["name"] = name

	data["desc"] = desc

	data["branches"] = branches

	data["tags"] = tags

	h.templ(w, "repo_refs", data)

}

func countLines(r io.Reader) (int, error) {

	buf := make([]byte, 32*1024)

	bufLen := 0

	count := 0

	nl := []byte{'\n'}

	for {

		c, err := r.Read(buf)

		if c > 0 {

			bufLen += c

		}

		count += bytes.Count(buf[:c], nl)

		switch {

		case err == io.EOF:

			// handle last line not having a newline at the end

			if bufLen >= 1 && buf[(bufLen-1)%(32*1024)] != '\n' {

				count++

			}

			return count, nil

		case err != nil:

			return 0, err

		}

	}

}

var errPrivateRepo = errors.New("private err")

func (h *handlers) openPublicRepo(name, ref string) (*git.Repo, error) {

	// Convert normalized name back to filesystem path with .git suffix

	name = repoNameToPath(name)

	path, err := securejoin.SecureJoin(h.c.Repo.Dir, name)

	if err != nil {

		return nil, err

	}

	repo, err := git.Open(path, ref)

	if err != nil {

		return nil, err

	}

	isPrivate, err := repo.IsPrivate()

	if err != nil {

		return nil, err

	}

	if isPrivate {

		return nil, errPrivateRepo

	}

	return repo, nil

}

type repoList struct {

	Name       string

	Desc       string

	LastCommit time.Time

}

func (h *handlers) listPublicRepos() ([]repoList, error) {

	dirs, err := os.ReadDir(h.c.Repo.Dir)

	if err != nil {

		return nil, err

	}

	var repos []repoList

	var errs []error

	for _, dir := range dirs {

		if !dir.IsDir() {

			continue

		}

		name := dir.Name()

		normalizedName := getNormalizedName(name)

		repo, err := h.openPublicRepo(normalizedName, "")

		if err != nil {

			if errors.Is(err, errPrivateRepo) {

				continue

			}

			errs = append(errs, err)

			continue

		}

		desc, err := repo.Description()

		if err != nil {

			errs = append(errs, err)

			continue

		}

		var lastCommitTime time.Time

		lastCommit, err := repo.LastCommit()

		if err != nil {

			if !errors.Is(err, git.ErrEmptyRepo) {

				errs = append(errs, err)

				continue

			}

		} else {

			lastCommitTime = lastCommit.Committed

		}

		repos = append(repos, repoList{

			Name:       normalizedName,

			Desc:       desc,

			LastCommit: lastCommitTime,

		})

	}

	sort.Slice(repos, func(i, j int) bool {

		return repos[j].LastCommit.Before(repos[i].LastCommit)

	})

	return repos, errors.Join(errs...)

}