package main

import (
	"bytes"
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"time"
)

// All repository access goes through the real git binary: frieren owns HTTP,
// auth, and rendering, while git owns object storage and the pack protocol.

var repoNameRe = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]*$`)

// reservedNames are path roots the web UI and JSON API claim for themselves.
var reservedNames = map[string]bool{"static": true, "api": true}

func validRepoName(name string) bool {
	return repoNameRe.MatchString(name) && !reservedNames[name] && len(name) <= 100
}

func validRef(ref string) bool {
	if ref == "" || len(ref) > 250 || strings.HasPrefix(ref, "-") || strings.Contains(ref, "..") {
		return false
	}
	for _, r := range ref {
		if r < 0x20 || r == 0x7f || r == ' ' || r == '~' || r == '^' || r == ':' || r == '\\' {
			return false
		}
	}
	return true
}

func validPath(p string) bool {
	if p == "" {
		return true
	}
	if strings.HasPrefix(p, "/") || strings.Contains(p, "\x00") {
		return false
	}
	for _, seg := range strings.Split(p, "/") {
		if seg == "" || seg == "." || seg == ".." {
			return false
		}
	}
	return true
}

type Store struct {
	Root string
}

func (s *Store) repoPath(name string) string {
	return filepath.Join(s.Root, name+".git")
}

func (s *Store) exists(name string) bool {
	if !validRepoName(name) {
		return false
	}
	fi, err := os.Stat(filepath.Join(s.repoPath(name), "HEAD"))
	return err == nil && fi.Mode().IsRegular()
}

func (s *Store) create(name, description string) error {
	if !validRepoName(name) {
		return fmt.Errorf("invalid repository name %q", name)
	}
	if s.exists(name) {
		return fmt.Errorf("repository %q already exists", name)
	}
	if _, err := runGit(context.Background(), s.Root, nil, "init", "--bare", "-b", "master", "--quiet", name+".git"); err != nil {
		return err
	}
	if description != "" {
		return os.WriteFile(filepath.Join(s.repoPath(name), "description"), []byte(description+"\n"), 0o644)
	}
	return nil
}

// runGit executes git with -C dir and returns stdout. Stderr is folded into
// the error so callers can surface git's own explanation.
func runGit(ctx context.Context, dir string, stdin []byte, args ...string) ([]byte, error) {
	full := append([]string{"-C", dir}, args...)
	cmd := exec.CommandContext(ctx, "git", full...)
	if stdin != nil {
		cmd.Stdin = bytes.NewReader(stdin)
	}
	var out, errb bytes.Buffer
	cmd.Stdout = &out
	cmd.Stderr = &errb
	if err := cmd.Run(); err != nil {
		return nil, fmt.Errorf("git %s: %w: %s", strings.Join(args, " "), err, strings.TrimSpace(errb.String()))
	}
	return out.Bytes(), nil
}

type RepoInfo struct {
	Name        string    `json:"name"`
	Description string    `json:"description"`
	Default     string    `json:"default"`
	LastCommit  time.Time `json:"lastCommit"`
	Empty       bool      `json:"empty"`
}

func (s *Store) open(name string) (*RepoInfo, error) {
	if !s.exists(name) {
		return nil, fmt.Errorf("no such repository %q", name)
	}
	info := &RepoInfo{Name: name, Default: "master"}
	dir := s.repoPath(name)
	if b, err := os.ReadFile(filepath.Join(dir, "description")); err == nil {
		d := strings.TrimSpace(string(b))
		if !strings.HasPrefix(d, "Unnamed repository") {
			info.Description = d
		}
	}
	if b, err := runGit(context.Background(), dir, nil, "symbolic-ref", "--short", "HEAD"); err == nil {
		info.Default = strings.TrimSpace(string(b))
	}
	b, err := runGit(context.Background(), dir, nil,
		"for-each-ref", "--sort=-committerdate", "--count=1", "--format=%(committerdate:unix)", "refs/heads")
	if err != nil || len(bytes.TrimSpace(b)) == 0 {
		info.Empty = true
		return info, nil
	}
	if unix, err := strconv.ParseInt(strings.TrimSpace(string(b)), 10, 64); err == nil {
		info.LastCommit = time.Unix(unix, 0)
	}
	return info, nil
}

func (s *Store) list() []*RepoInfo {
	entries, err := os.ReadDir(s.Root)
	if err != nil {
		return nil
	}
	var repos []*RepoInfo
	for _, e := range entries {
		if !e.IsDir() || !strings.HasSuffix(e.Name(), ".git") {
			continue
		}
		name := strings.TrimSuffix(e.Name(), ".git")
		if info, err := s.open(name); err == nil {
			repos = append(repos, info)
		}
	}
	sort.Slice(repos, func(i, j int) bool { return repos[i].LastCommit.After(repos[j].LastCommit) })
	return repos
}

type TreeEntry struct {
	Mode string `json:"mode"`
	Type string `json:"type"` // blob, tree, commit (submodule)
	Hash string `json:"hash"`
	Size int64  `json:"size"` // -1 for trees
	Name string `json:"name"`
}

func (s *Store) lsTree(ctx context.Context, repo, ref, path string) ([]TreeEntry, error) {
	spec := ref
	if path != "" {
		spec += ":" + path
	}
	out, err := runGit(ctx, s.repoPath(repo), nil, "ls-tree", "-z", "-l", spec)
	if err != nil {
		return nil, err
	}
	var entries []TreeEntry
	for _, rec := range bytes.Split(out, []byte{0}) {
		if len(rec) == 0 {
			continue
		}
		meta, name, ok := bytes.Cut(rec, []byte{'\t'})
		if !ok {
			continue
		}
		f := strings.Fields(string(meta))
		if len(f) != 4 {
			continue
		}
		size := int64(-1)
		if f[3] != "-" {
			size, _ = strconv.ParseInt(f[3], 10, 64)
		}
		entries = append(entries, TreeEntry{Mode: f[0], Type: f[1], Hash: f[2], Size: size, Name: string(name)})
	}
	sort.Slice(entries, func(i, j int) bool {
		if (entries[i].Type == "tree") != (entries[j].Type == "tree") {
			return entries[i].Type == "tree"
		}
		return entries[i].Name < entries[j].Name
	})
	return entries, nil
}

const maxBlobBytes = 2 << 20 // 2 MiB shown in the web UI; raw endpoint streams everything

func (s *Store) catBlob(ctx context.Context, repo, ref, path string) ([]byte, error) {
	return runGit(ctx, s.repoPath(repo), nil, "cat-file", "blob", ref+":"+path)
}

type Commit struct {
	Hash    string    `json:"hash"`
	Short   string    `json:"short"`
	Author  string    `json:"author"`
	When    time.Time `json:"when"`
	Subject string    `json:"subject"`
}

const logFormat = "%H%x1f%h%x1f%an%x1f%at%x1f%s%x1e"

func parseCommits(out []byte) []Commit {
	var commits []Commit
	for _, rec := range bytes.Split(out, []byte{0x1e}) {
		rec = bytes.TrimSpace(rec)
		if len(rec) == 0 {
			continue
		}
		f := strings.Split(string(rec), "\x1f")
		if len(f) != 5 {
			continue
		}
		unix, _ := strconv.ParseInt(f[3], 10, 64)
		commits = append(commits, Commit{Hash: f[0], Short: f[1], Author: f[2], When: time.Unix(unix, 0), Subject: f[4]})
	}
	return commits
}

func (s *Store) log(ctx context.Context, repo, ref string, limit int) ([]Commit, error) {
	out, err := runGit(ctx, s.repoPath(repo), nil,
		"log", "--format="+logFormat, "-n", strconv.Itoa(limit), ref, "--")
	if err != nil {
		return nil, err
	}
	return parseCommits(out), nil
}

func (s *Store) commit(ctx context.Context, repo, hash string) (*Commit, error) {
	out, err := runGit(ctx, s.repoPath(repo), nil, "show", "-s", "--format="+logFormat, hash, "--")
	if err != nil {
		return nil, err
	}
	commits := parseCommits(out)
	if len(commits) == 0 {
		return nil, fmt.Errorf("no such commit %q", hash)
	}
	return &commits[0], nil
}

const maxDiffBytes = 1 << 20 // 1 MiB of rendered patch per commit page

func (s *Store) patch(ctx context.Context, repo, hash string) (string, bool, error) {
	out, err := runGit(ctx, s.repoPath(repo), nil,
		"show", "--format=", "--stat", "--patch", "--no-color", hash, "--")
	if err != nil {
		return "", false, err
	}
	if len(out) > maxDiffBytes {
		return string(out[:maxDiffBytes]), true, nil
	}
	return string(out), false, nil
}

type Ref struct {
	Name    string    `json:"name"`
	Short   string    `json:"short"`
	When    time.Time `json:"when"`
	Subject string    `json:"subject"`
}

func (s *Store) refs(ctx context.Context, repo, kind string) ([]Ref, error) {
	out, err := runGit(ctx, s.repoPath(repo), nil,
		"for-each-ref", "--sort=-creatordate",
		"--format=%(refname:short)%1f%(objectname:short)%1f%(creatordate:unix)%1f%(subject)%1e", "refs/"+kind)
	if err != nil {
		return nil, err
	}
	var refs []Ref
	for _, rec := range bytes.Split(out, []byte{0x1e}) {
		rec = bytes.TrimSpace(rec)
		if len(rec) == 0 {
			continue
		}
		f := strings.Split(string(rec), "\x1f")
		if len(f) != 4 {
			continue
		}
		unix, _ := strconv.ParseInt(f[2], 10, 64)
		refs = append(refs, Ref{Name: f[0], Short: f[1], When: time.Unix(unix, 0), Subject: f[3]})
	}
	return refs, nil
}

// readme returns the first README-ish blob at the root of ref, if any.
func (s *Store) readme(ctx context.Context, repo, ref string) (name string, body []byte) {
	entries, err := s.lsTree(ctx, repo, ref, "")
	if err != nil {
		return "", nil
	}
	for _, e := range entries {
		if e.Type != "blob" {
			continue
		}
		switch strings.ToLower(e.Name) {
		case "readme.md", "readme", "readme.txt":
			if b, err := s.catBlob(ctx, repo, ref, e.Name); err == nil && len(b) <= maxBlobBytes {
				return e.Name, b
			}
		}
	}
	return "", nil
}