package gitrepo

import (
	"bufio"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/exec"
	"strconv"
	"strings"
)

// ServeSmartHTTP voert git http-backend uit voor één repository.
// pathInfo is het PATH_INFO vanaf de repository, bijvoorbeeld
// /tim/bluegit.git/info/refs. extraEnv gaat naar het kindproces en
// daarmee naar de pre-receive-hook.
func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot, pathInfo string, extraEnv []string) error {
	if gitBin == "" {
		gitBin = "git"
	}
	cmd := exec.CommandContext(r.Context(), gitBin, "http-backend")
	cmd.Env = append(os.Environ(),
		"GIT_PROJECT_ROOT="+projectRoot,
		"GIT_HTTP_EXPORT_ALL=1",
		"PATH_INFO="+pathInfo,
		"REQUEST_METHOD="+r.Method,
		"QUERY_STRING="+r.URL.RawQuery,
		"CONTENT_TYPE="+r.Header.Get("Content-Type"),
		"REMOTE_ADDR="+r.RemoteAddr,
	)
	if r.ContentLength >= 0 {
		cmd.Env = append(cmd.Env, "CONTENT_LENGTH="+strconv.FormatInt(r.ContentLength, 10))
	}
	// Git comprimeert een smart-HTTP-POST met gzip zodra die groter is dan
	// 1024 bytes en zet dan Content-Encoding: gzip. http-backend pakt de
	// body alleen uit als de CGI-variabele HTTP_CONTENT_ENCODING gezet is.
	// Zonder die variabele leest hij de gzip-bytes als pkt-lines en komt er
	// een lege 200 terug. CONTENT_LENGTH blijft de gecomprimeerde lengte:
	// daar leest inflate_request precies zoveel bytes van.
	if enc := gzipContentEncoding(r.Header.Get("Content-Encoding")); enc != "" {
		cmd.Env = append(cmd.Env, "HTTP_CONTENT_ENCODING="+enc)
	}
	cmd.Env = append(cmd.Env, extraEnv...)
	cmd.Stdin = r.Body
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return err
	}
	var stderr strings.Builder
	cmd.Stderr = &stderr
	if err := cmd.Start(); err != nil {
		return err
	}
	br := bufio.NewReader(stdout)
	status := 200
	for {
		line, err := br.ReadString('\n')
		if err != nil {
			_ = cmd.Wait()
			return fmt.Errorf("git http-backend: %v (%s)", err, strings.TrimSpace(stderr.String()))
		}
		line = strings.TrimRight(line, "\r\n")
		if line == "" {
			break
		}
		name, value, ok := strings.Cut(line, ":")
		if !ok {
			continue
		}
		name = strings.TrimSpace(name)
		value = strings.TrimSpace(value)
		if strings.EqualFold(name, "Status") {
			fmt.Sscanf(value, "%d", &status)
			continue
		}
		w.Header().Add(name, value)
	}
	w.WriteHeader(status)
	_, _ = io.Copy(w, br)
	if err := cmd.Wait(); err != nil {
		return fmt.Errorf("git http-backend: %v (%s)", err, strings.TrimSpace(stderr.String()))
	}
	return nil
}

// gzipContentEncoding is de waarde voor HTTP_CONTENT_ENCODING.
// git http-backend herkent alleen "gzip" en "x-gzip", hoofdlettergevoelig.
func gzipContentEncoding(v string) string {
	v = strings.TrimSpace(v)
	if v == "" {
		return ""
	}
	if i := strings.IndexByte(v, ','); i >= 0 {
		v = strings.TrimSpace(v[:i])
	}
	switch strings.ToLower(v) {
	case "gzip", "x-gzip":
		return strings.ToLower(v)
	default:
		return ""
	}
}

// ProjectRoot is de map waarin owner/naam.git staat.
func ProjectRoot(storage string) string {
	return storage + "/repos"
}

// PathInfo bouwt het CGI-pad.
func PathInfo(owner, repoWithGit, rest string) string {
	p := "/" + owner + "/" + repoWithGit
	if rest != "" {
		p += "/" + strings.TrimPrefix(rest, "/")
	}
	return p
}
