package main

import (
	"bytes"
	"embed"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"net/url"
	"strings"
	"time"
)

//go:embed templates/*.html
var templateFS embed.FS

//go:embed static/style.css
var styleSheet []byte

var funcs = template.FuncMap{
	"pesc": url.PathEscape,
	"ago":  timeAgo,
	"size": byteSize,
}

var pages = template.Must(template.New("").Funcs(funcs).ParseFS(templateFS, "templates/*.html"))

func timeAgo(t time.Time) string {
	if t.IsZero() {
		return ""
	}
	d := time.Since(t)
	switch {
	case d < time.Minute:
		return "just now"
	case d < time.Hour:
		return fmt.Sprintf("%dm ago", int(d.Minutes()))
	case d < 24*time.Hour:
		return fmt.Sprintf("%dh ago", int(d.Hours()))
	case d < 30*24*time.Hour:
		return fmt.Sprintf("%dd ago", int(d.Hours()/24))
	default:
		return t.Format("Jan 2, 2006")
	}
}

func byteSize(n int64) string {
	switch {
	case n < 0:
		return ""
	case n < 1024:
		return fmt.Sprintf("%d B", n)
	case n < 1<<20:
		return fmt.Sprintf("%.1f KB", float64(n)/1024)
	default:
		return fmt.Sprintf("%.1f MB", float64(n)/(1<<20))
	}
}

func (srv *Server) render(w http.ResponseWriter, name string, data any) {
	var buf bytes.Buffer
	if err := pages.ExecuteTemplate(&buf, name, data); err != nil {
		log.Printf("render %s: %v", name, err)
		http.Error(w, "template error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	buf.WriteTo(w)
}

func (srv *Server) styleCSS(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/css; charset=utf-8")
	w.Header().Set("Cache-Control", "max-age=3600")
	w.Write(styleSheet)
}

func baseURL(r *http.Request) string {
	scheme := "http"
	if r.TLS != nil {
		scheme = "https"
	}
	if p := r.Header.Get("X-Forwarded-Proto"); p != "" {
		scheme = p
	}
	return scheme + "://" + r.Host
}

// page is the data every template receives.
type page struct {
	Title    string
	Repo     *RepoInfo
	Ref      string
	Path     string
	CloneURL string
	Tab      string
	Base     string
}

func (srv *Server) newPage(r *http.Request, repo *RepoInfo, ref, tab string) page {
	p := page{Title: "frieren", Tab: tab, Base: baseURL(r)}
	if repo != nil {
		p.Repo = repo
		p.Ref = ref
		p.Title = repo.Name + " · frieren"
		p.CloneURL = baseURL(r) + "/" + repo.Name + ".git"
	}
	return p
}

// openRepo loads the repo named in the route or writes a 404.
func (srv *Server) openRepo(w http.ResponseWriter, r *http.Request) *RepoInfo {
	info, err := srv.Store.open(repoParam(r))
	if err != nil {
		srv.notFound(w, r)
		return nil
	}
	return info
}

func (srv *Server) notFound(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotFound)
	srv.render(w, "notfound", page{Title: "not found · frieren"})
}

func (srv *Server) indexPage(w http.ResponseWriter, r *http.Request) {
	srv.render(w, "index", struct {
		page
		Repos []*RepoInfo
	}{srv.newPage(r, nil, "", ""), srv.Store.list()})
}

func (srv *Server) repoPage(w http.ResponseWriter, r *http.Request) {
	repo := srv.openRepo(w, r)
	if repo == nil {
		return
	}
	data := struct {
		page
		Entries    []TreeEntry
		ReadmeName string
		Readme     string
	}{page: srv.newPage(r, repo, repo.Default, "files")}
	if !repo.Empty {
		entries, err := srv.Store.lsTree(r.Context(), repo.Name, repo.Default, "")
		if err == nil {
			data.Entries = entries
		}
		if name, body := srv.Store.readme(r.Context(), repo.Name, repo.Default); name != "" && !isBinary(body) {
			data.ReadmeName = name
			data.Readme = string(body)
		}
	}
	srv.render(w, "repo", data)
}

type crumb struct {
	Name string
	Path string
}

func crumbs(path string) []crumb {
	if path == "" {
		return nil
	}
	parts := strings.Split(path, "/")
	out := make([]crumb, len(parts))
	for i, part := range parts {
		out[i] = crumb{Name: part, Path: strings.Join(parts[:i+1], "/")}
	}
	return out
}

func (srv *Server) treePage(w http.ResponseWriter, r *http.Request) {
	repo := srv.openRepo(w, r)
	if repo == nil {
		return
	}
	ref, path := r.PathValue("ref"), r.PathValue("path")
	if !validRef(ref) || !validPath(path) {
		srv.notFound(w, r)
		return
	}
	entries, err := srv.Store.lsTree(r.Context(), repo.Name, ref, path)
	if err != nil {
		srv.notFound(w, r)
		return
	}
	srv.render(w, "tree", struct {
		page
		Entries []TreeEntry
		Crumbs  []crumb
		Dir     string
	}{srv.newPage(r, repo, ref, "files"), entries, crumbs(path), path})
}

func isBinary(b []byte) bool {
	if len(b) > 8000 {
		b = b[:8000]
	}
	return bytes.IndexByte(b, 0) >= 0
}

func (srv *Server) blobPage(w http.ResponseWriter, r *http.Request) {
	repo := srv.openRepo(w, r)
	if repo == nil {
		return
	}
	ref, path := r.PathValue("ref"), r.PathValue("path")
	if !validRef(ref) || !validPath(path) || path == "" {
		srv.notFound(w, r)
		return
	}
	blob, err := srv.Store.catBlob(r.Context(), repo.Name, ref, path)
	if err != nil {
		srv.notFound(w, r)
		return
	}
	all := crumbs(path)
	data := struct {
		page
		Parents   []crumb
		FileName  string
		RawPath   string
		Lines     []string
		Bytes     int64
		Binary    bool
		Truncated bool
	}{
		page:     srv.newPage(r, repo, ref, "files"),
		Parents:  all[:len(all)-1],
		FileName: all[len(all)-1].Name,
		RawPath:  path,
		Bytes:    int64(len(blob)),
	}
	switch {
	case isBinary(blob):
		data.Binary = true
	case len(blob) > maxBlobBytes:
		data.Truncated = true
	default:
		data.Lines = strings.Split(strings.TrimSuffix(string(blob), "\n"), "\n")
	}
	srv.render(w, "blob", data)
}

var rawTypes = map[string]string{
	".svg": "image/svg+xml", ".png": "image/png", ".jpg": "image/jpeg",
	".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp",
	".ico": "image/x-icon", ".avif": "image/avif", ".pdf": "application/pdf",
	".mp4": "video/mp4", ".webm": "video/webm", ".mp3": "audio/mpeg",
}

func extOf(path string) string {
	if i := strings.LastIndexByte(path, '.'); i >= 0 && !strings.ContainsRune(path[i:], '/') {
		return strings.ToLower(path[i:])
	}
	return ""
}

func (srv *Server) rawFile(w http.ResponseWriter, r *http.Request) {
	repo := srv.openRepo(w, r)
	if repo == nil {
		return
	}
	ref, path := r.PathValue("ref"), r.PathValue("path")
	if !validRef(ref) || !validPath(path) || path == "" {
		http.NotFound(w, r)
		return
	}
	blob, err := srv.Store.catBlob(r.Context(), repo.Name, ref, path)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	// Never let the browser interpret repository content as HTML. Known
	// media types get their real content type so <img>/<video> embeds work.
	w.Header().Set("X-Content-Type-Options", "nosniff")
	switch {
	case rawTypes[extOf(path)] != "":
		w.Header().Set("Content-Type", rawTypes[extOf(path)])
	case isBinary(blob):
		w.Header().Set("Content-Type", "application/octet-stream")
	default:
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
	}
	w.Write(blob)
}

func (srv *Server) commitsPage(w http.ResponseWriter, r *http.Request) {
	repo := srv.openRepo(w, r)
	if repo == nil {
		return
	}
	ref := r.PathValue("ref")
	if ref == "" {
		ref = repo.Default
	}
	if !validRef(ref) {
		srv.notFound(w, r)
		return
	}
	var commits []Commit
	if !repo.Empty {
		var err error
		commits, err = srv.Store.log(r.Context(), repo.Name, ref, 100)
		if err != nil {
			srv.notFound(w, r)
			return
		}
	}
	srv.render(w, "commits", struct {
		page
		Commits []Commit
	}{srv.newPage(r, repo, ref, "commits"), commits})
}

type diffLine struct {
	Class string
	Text  string
}

func classifyPatch(patch string) []diffLine {
	if patch == "" {
		return nil
	}
	lines := strings.Split(strings.TrimSuffix(patch, "\n"), "\n")
	out := make([]diffLine, len(lines))
	for i, l := range lines {
		class := "ctx"
		switch {
		case strings.HasPrefix(l, "diff --git") || strings.HasPrefix(l, "index ") ||
			strings.HasPrefix(l, "new file") || strings.HasPrefix(l, "deleted file") ||
			strings.HasPrefix(l, "similarity ") || strings.HasPrefix(l, "rename "):
			class = "meta"
		case strings.HasPrefix(l, "+++") || strings.HasPrefix(l, "---"):
			class = "file"
		case strings.HasPrefix(l, "@@"):
			class = "hunk"
		case strings.HasPrefix(l, "+"):
			class = "add"
		case strings.HasPrefix(l, "-"):
			class = "del"
		}
		out[i] = diffLine{Class: class, Text: l}
	}
	return out
}

func (srv *Server) commitPage(w http.ResponseWriter, r *http.Request) {
	repo := srv.openRepo(w, r)
	if repo == nil {
		return
	}
	hash := r.PathValue("hash")
	if !validRef(hash) {
		srv.notFound(w, r)
		return
	}
	commit, err := srv.Store.commit(r.Context(), repo.Name, hash)
	if err != nil {
		srv.notFound(w, r)
		return
	}
	patch, truncated, err := srv.Store.patch(r.Context(), repo.Name, commit.Hash)
	if err != nil {
		srv.notFound(w, r)
		return
	}
	srv.render(w, "commit", struct {
		page
		Commit    *Commit
		Diff      []diffLine
		Truncated bool
	}{srv.newPage(r, repo, "", "commits"), commit, classifyPatch(patch), truncated})
}

func (srv *Server) refsPage(w http.ResponseWriter, r *http.Request) {
	repo := srv.openRepo(w, r)
	if repo == nil {
		return
	}
	branches, _ := srv.Store.refs(r.Context(), repo.Name, "heads")
	tags, _ := srv.Store.refs(r.Context(), repo.Name, "tags")
	srv.render(w, "refs", struct {
		page
		Branches []Ref
		Tags     []Ref
	}{srv.newPage(r, repo, "", "refs"), branches, tags})
}