package server

import ( "bytes" "errors" "html/template" "net/http" "net/url" "path" "strconv" "strings"

"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/object"

"gitweb/internal/gitrepo"
"gitweb/internal/render"

)

var gitTmpl = template.Must(template.ParseFS(tmplFS, "templates/git.html"))

const logLimit = 100

// serveGit handles a request that Locate resolved to a bare repo. repoPath is // the upspin repo root (e.g. "u@d.com/proj.git"); rest is the remaining URL // after it (e.g. "blob/main/src/x.go"). base is "/"+repoPath. func (s *Server) serveGit(w http.ResponseWriter, r *http.Request, repoPath, rest string) { repo, release, err := s.repos.Get(repoPath) if err != nil { s.storeErr(w, err) return } defer release() base := "/" + repoPath rest = strings.Trim(rest, "/") verb, rem, _ := strings.Cut(rest, "/")

switch verb {
case "":
	s.gitSummary(w, r, repo, repoPath, base)
case "refs":
	s.gitRefs(w, r, repo, repoPath, base)
case "tree":
	s.gitTree(w, r, repo, repoPath, base, rem)
case "blob":
	s.gitBlob(w, r, repo, repoPath, base, rem, false, r.URL.Query())
case "raw":
	s.gitBlob(w, r, repo, repoPath, base, rem, true, nil)
case "log":
	s.gitLog(w, r, repo, repoPath, base, rem)
case "commit":
	s.gitCommit(w, r, repo, repoPath, base, rem)
default:
	s.notFound(w)
}

}

// --- view models ---

type gitNav struct { RepoName string Base string Ref string LogURL string }

func newNav(repoName, base, ref string) gitNav { n := gitNav{RepoName: repoName, Base: base, Ref: ref} if ref != "" { n.LogURL = base + "/log/" + escapePath(ref) } return n }

type treeEntry struct { Name string IsDir bool URL string Size string }

type crumb struct { Name string URL string // empty for the last crumb }

type refLink struct { Name string Short string URL string LogURL string }

// --- summary ---

func (s *Server) gitSummary(w http.ResponseWriter, r *http.Request, repo *git.Repository, repoName, base string) { hash, ref, _, err := gitrepo.ResolveRef(repo, "") if err != nil { s.notFound(w) return } nav := newNav(repoName, base, ref)

tree, err := treeAt(repo, hash, "")
if err != nil {
	s.serverErr(w, err)
	return
}
entries := treeEntries(repo, tree, base, ref, "")

branches, tags, err := gitrepo.Refs(repo)
if err != nil {
	s.serverErr(w, err)
	return
}

var readme template.HTML
if name := findReadme(tree); name != "" {
	if f, err := tree.File(name); err == nil {
		if data, err := f.Contents(); err == nil {
			if h, err := s.renderer.ToHTML([]byte(data)); err == nil {
				readme = rebaseRepoHTML(template.HTML(h), base, ref, path.Dir(name))
			}
		}
	}
}

s.renderGit(w, r, repoName, "summary", struct {
	Nav      gitNav
	Branches []refLink
	Tags     []refLink
	Entries  []treeEntry
	Readme   template.HTML
}{
	Nav:      nav,
	Branches: refLinks(branches, base, "tree"),
	Tags:     refLinks(tags, base, "tree"),
	Entries:  entries,
	Readme:   readme,
})

}

// --- tree ---

func (s *Server) gitTree(w http.ResponseWriter, r *http.Request, repo *git.Repository, repoName, base, rem string) { hash, ref, sub, err := gitrepo.ResolveRef(repo, rem) if err != nil { s.notFound(w) return } tree, err := treeAt(repo, hash, sub) if err != nil { s.notFound(w) return } nav := newNav(repoName, base, ref) title := repoName if sub != "" { title = repoName + "/" + sub } s.renderGit(w, r, repoName, "tree", struct { Nav gitNav Title string Crumbs []crumb Entries []treeEntry }{ Nav: nav, Title: title, Crumbs: buildCrumbs(base, ref, sub, true), Entries: treeEntries(repo, tree, base, ref, sub), }) }

// --- blob / raw ---

func (s *Server) gitBlob(w http.ResponseWriter, r *http.Request, repo *git.Repository, repoName, base, rem string, raw bool, q url.Values) { hash, ref, sub, err := gitrepo.ResolveRef(repo, rem) if err != nil || sub == "" { s.notFound(w) return } if isAccessFile(path.Base(sub)) { s.notFound(w) // never render an upspin ACL, blob or raw return } tree, err := treeAt(repo, hash, "") if err != nil { s.notFound(w) return } file, err := tree.File(sub) if err != nil { s.notFound(w) return } data, err := file.Contents() if err != nil { s.serverErr(w, err) return } content := []byte(data)

if raw {
	ctype := http.DetectContentType(content)
	w.Header().Set("Content-Type", ctype)
	w.Write(content)
	return
}

rawURL := base + "/raw/" + escapePath(ref) + "/" + escapePath(sub)
binary := render.IsBinary(content)
name := path.Base(sub)
force := q.Get("force") == "1"
selected := s.renderers.Select(name, content, q.Get("render"), force)

var body template.HTML
var choices []rendererChoice
var forceURL string
if !binary {
	body, err = selected.Render(name, content)
	if err != nil {
		s.serverErr(w, err)
		return
	}
	if selected.ID == "markdown" {
		// Rewrite relative links/images so they resolve to the file's
		// directory in the repo rather than the current URL.
		body = rebaseRepoHTML(body, base, ref, path.Dir(sub))
	}
	blobURL := base + "/blob/" + escapePath(ref) + "/" + escapePath(sub)
	choices, forceURL = renderControls(s.renderers, blobURL, name, content, selected.ID, force)
}

s.renderGit(w, r, repoName, "blob", blobView{
	Nav:       newNav(repoName, base, ref),
	Crumbs:    buildCrumbs(base, ref, sub, true),
	Path:      sub,
	Size:      humanSize(file.Size),
	RawURL:    rawURL,
	Binary:    binary,
	Body:      body,
	Renderers: choices,
	Force:     force,
	ForceURL:  forceURL,
})

}

// blobView is the file-view model, including the renderer control bar. type blobView struct { Nav gitNav Crumbs []crumb Path string Size string RawURL string Binary bool Body template.HTML Renderers []rendererChoice Force bool ForceURL string }

// rendererChoice is one selectable renderer link in the control bar. type rendererChoice struct { Label string URL string Active bool }

// renderControls builds the renderer switch links and the force-toggle link for // a blob. With force on, every registered renderer is offered; otherwise only // the eligible ones. The default renderer's link carries no ?render= so its URL // stays clean. func renderControls(reg *render.Registry, blobURL, name string, content []byte, selectedID string, force bool) ([]rendererChoice, string) { mods := reg.Eligible(name, content) if force { mods = reg.All() } defID := reg.Default().ID

choices := make([]rendererChoice, 0, len(mods))
for _, m := range mods {
	choices = append(choices, rendererChoice{
		Label:  m.Label,
		URL:    blobURL + blobQuery(m.ID, defID, force),
		Active: m.ID == selectedID,
	})
}

var forceURL string
if force {
	// Turning force off: keep the selection only if it stays eligible.
	keep := selectedID
	if _, ok := find(reg.Eligible(name, content), keep); !ok {
		keep = defID
	}
	forceURL = blobURL + blobQuery(keep, defID, false)
} else {
	forceURL = blobURL + blobQuery(selectedID, defID, true)
}
return choices, forceURL

}

// blobQuery builds the query string for a blob link with the given renderer and // force state. The default renderer is encoded as no ?render= param. func blobQuery(id, defID string, force bool) string { v := url.Values{} if id != "" && id != defID { v.Set("render", id) } if force { v.Set("force", "1") } if len(v) == 0 { return "" } return "?" + v.Encode() }

func find(mods []render.Module, id string) (render.Module, bool) { for _, m := range mods { if m.ID == id { return m, true } } return render.Module{}, false }

// --- log ---

func (s *Server) gitLog(w http.ResponseWriter, r *http.Request, repo *git.Repository, repoName, base, rem string) { hash, ref, _, err := gitrepo.ResolveRef(repo, rem) if err != nil { s.notFound(w) return } iter, err := repo.Log(&git.LogOptions{From: hash}) if err != nil { s.serverErr(w, err) return } type commitRow struct { Subject, Author, When, Short, URL string } var commits []commitRow _ = iter.ForEach(func(c *object.Commit) error { if len(commits) >= logLimit { return errStopIter } commits = append(commits, commitRow{ Subject: subjectOf(c.Message), Author: c.Author.Name, When: c.Author.When.Format("2006-01-02"), Short: c.Hash.String()[:8], URL: base + "/commit/" + c.Hash.String(), }) return nil }) s.renderGit(w, r, repoName, "log", struct { Nav gitNav Commits interface{} }{ Nav: newNav(repoName, base, ref), Commits: commits, }) }

// --- commit ---

func (s *Server) gitCommit(w http.ResponseWriter, r *http.Request, repo *git.Repository, repoName, base, rem string) { rem = strings.Trim(rem, "/") h, err := repo.ResolveRevision(plumbing.Revision(rem)) if err != nil { s.notFound(w) return } c, err := repo.CommitObject(*h) if err != nil { s.notFound(w) return }

var fromTree *object.Tree
var parents []struct{ Short, URL string }
if c.NumParents() > 0 {
	p, err := c.Parent(0)
	if err == nil {
		fromTree, _ = p.Tree()
		parents = append(parents, struct{ Short, URL string }{
			Short: p.Hash.String()[:8],
			URL:   base + "/commit/" + p.Hash.String(),
		})
	}
}
toTree, err := c.Tree()
if err != nil {
	s.serverErr(w, err)
	return
}
changes, err := object.DiffTree(fromTree, toTree)
if err != nil {
	s.serverErr(w, err)
	return
}
patch, err := changes.Patch()
if err != nil {
	s.serverErr(w, err)
	return
}

s.renderGit(w, r, repoName, "commit", struct {
	Nav     gitNav
	Subject string
	Body    string
	Hash    string
	Author  string
	When    string
	Parents []struct{ Short, URL string }
	Diff    template.HTML
}{
	Nav:     newNav(repoName, base, ""),
	Subject: subjectOf(c.Message),
	Body:    bodyOf(c.Message),
	Hash:    c.Hash.String(),
	Author:  c.Author.Name + " <" + c.Author.Email + ">",
	When:    c.Author.When.Format("2006-01-02 15:04 -0700"),
	Parents: parents,
	Diff:    render.Diff(patch),
})

}

// --- refs ---

func (s *Server) gitRefs(w http.ResponseWriter, r *http.Request, repo *git.Repository, repoName, base string) { branches, tags, err := gitrepo.Refs(repo) if err != nil { s.serverErr(w, err) return } s.renderGit(w, r, repoName, "refs", struct { Nav gitNav Branches []refLink Tags []refLink }{ Nav: newNav(repoName, base, ""), Branches: refLinks(branches, base, "tree"), Tags: refLinks(tags, base, "tree"), }) }

// --- helpers ---

// errStopIter is a sentinel to stop a commit ForEach early. var errStopIter = errors.New("stop")

func (s *Server) renderGit(w http.ResponseWriter, r *http.Request, repoName, name string, data interface{}) { var body bytes.Buffer if err := gitTmpl.ExecuteTemplate(&body, name, data); err != nil { s.serverErr(w, err) return } s.renderPage(w, r, repoName, template.HTML(body.String())) }

// treeAt returns the tree at sub within the commit identified by hash. func treeAt(repo *git.Repository, hash plumbing.Hash, sub string) (*object.Tree, error) { c, err := repo.CommitObject(hash) if err != nil { return nil, err } tree, err := c.Tree() if err != nil { return nil, err } if sub == "" { return tree, nil } return tree.Tree(sub) }

func treeEntries(repo *git.Repository, tree *object.Tree, base, ref, sub string) []treeEntry { out := make([]treeEntry, 0, len(tree.Entries)) for _, e := range tree.Entries { if isAccessFile(e.Name) { continue // don't list an upspin ACL committed into the tree } child := e.Name if sub != "" { child = sub + "/" + e.Name } isDir := e.Mode == filemode.Dir te := treeEntry{Name: e.Name, IsDir: isDir} if isDir { te.URL = base + "/tree/" + escapePath(ref) + "/" + escapePath(child) } else { te.URL = base + "/blob/" + escapePath(ref) + "/" + escapePath(child) if b, err := repo.BlobObject(e.Hash); err == nil { te.Size = humanSize(b.Size) } } out = append(out, te) } // Directories first, then by name. sortTreeEntries(out) return out }

func sortTreeEntries(es []treeEntry) { // Simple insertion sort keeps dirs first then name (lists are small). for i := 1; i < len(es); i++ { for j := i; j > 0 && less(es[j], es[j-1]); j-- { es[j], es[j-1] = es[j-1], es[j] } } }

func less(a, b treeEntry) bool { if a.IsDir != b.IsDir { return a.IsDir } return a.Name < b.Name }

func buildCrumbs(base, ref, sub string, dirLinks bool) []crumb { crumbs := []crumb{{Name: ref, URL: base + "/tree/" + escapePath(ref)}} if sub == "" { return crumbs } parts := strings.Split(sub, "/") acc := "" for i, p := range parts { if acc == "" { acc = p } else { acc = acc + "/" + p } c := crumb{Name: p} last := i == len(parts)-1 if !last || dirLinks { c.URL = base + "/tree/" + escapePath(ref) + "/" + escapePath(acc) } if last { c.URL = "" // current location, not a link } crumbs = append(crumbs, c) } return crumbs }

func refLinks(refs []gitrepo.RefName, base, verb string) []refLink { out := make([]refLink, 0, len(refs)) for _, r := range refs { out = append(out, refLink{ Name: r.Name, Short: r.Hash.String()[:8], URL: base + "/" + verb + "/" + escapePath(r.Name), LogURL: base + "/log/" + escapePath(r.Name), }) } return out }

func findReadme(tree *object.Tree) string { for _, name := range []string{"README.md", "readme.md", "README.markdown", "README"} { if _, err := tree.File(name); err == nil { return name } } return "" }

// rebaseRepoHTML rewrites relative links/images in rendered repo markdown so // they resolve to the source file's location in the repo (blob view for links, // raw for images) at ref, given the markdown file's directory dir within the // tree ("" or "." for the repo root). func rebaseRepoHTML(h template.HTML, base, ref, dir string) template.HTML { prefix := escapePath(ref) + "/" if dir != "" && dir != "." { prefix += escapePath(dir) + "/" } return render.Rebase(h, base+"/blob/"+prefix, base+"/raw/"+prefix) }

// escapePath URL-escapes each slash-separated segment, preserving slashes. func escapePath(p string) string { parts := strings.Split(p, "/") for i, s := range parts { parts[i] = url.PathEscape(s) } return strings.Join(parts, "/") }

func subjectOf(msg string) string { if i := strings.IndexByte(msg, '\n'); i >= 0 { return strings.TrimSpace(msg[:i]) } return strings.TrimSpace(msg) }

func bodyOf(msg string) string { if i := strings.IndexByte(msg, '\n'); i >= 0 { return strings.TrimSpace(msg[i+1:]) } return "" }

func humanSize(n int64) string { const unit = 1024 if n < unit { return strconv.FormatInt(n, 10) + " B" } div, exp := int64(unit), 0 for m := n / unit; m >= unit; m /= unit { div *= unit exp++ } return strconv.FormatFloat(float64(n)/float64(div), 'f', 1, 64) + " " + string("KMGT"[exp]) + "iB" }