// Package sshx allows git's three verbs out of SSH_ORIGINAL_COMMAND and never uses a shell. 41.3.
package sshx

import (
	"errors"
	"fmt"
	"strings"

	"github.com/barerepo/server/internal/gitx"
)

// Request is a parsed SSH_ORIGINAL_COMMAND.
type Request struct {
	Verb  string // git-upload-pack, git-receive-pack, git-upload-archive
	Owner string
	Name  string
}

func (r Request) Write() bool { return r.Verb == "git-receive-pack" }

// allowed is a list, not a pattern, because a pattern admits a fourth verb nobody decided on.
var allowed = map[string]bool{
	"git-upload-pack":    true,
	"git-receive-pack":   true,
	"git-upload-archive": true,
}

var errRefused = errors.New("barerepo accepts git over this connection and nothing else")

// Parse accepts a verb, a space and a quoted path, where `;` and `&&` are only bad names.
func Parse(cmd string) (Request, error) {
	cmd = strings.TrimSpace(cmd)
	if cmd == "" {
		return Request{}, fmt.Errorf("this account has no shell. %w", errRefused)
	}
	verb, rest, ok := strings.Cut(cmd, " ")
	if !ok || !allowed[verb] {
		return Request{}, fmt.Errorf("%q is not a git command. %w", firstWord(cmd), errRefused)
	}
	path, err := unquote(strings.TrimSpace(rest))
	if err != nil {
		return Request{}, err
	}
	owner, name, err := splitPath(path)
	if err != nil {
		return Request{}, err
	}
	return Request{Verb: verb, Owner: owner, Name: name}, nil
}

// unquote refuses an unquoted argument, because git always quotes the path it sends.
func unquote(s string) (string, error) {
	if len(s) < 2 || s[0] != '\'' || s[len(s)-1] != '\'' {
		return "", fmt.Errorf("malformed repository argument")
	}
	s = s[1 : len(s)-1]
	if strings.Contains(s, "'") {
		return "", fmt.Errorf("malformed repository argument")
	}
	return s, nil
}

// splitPath takes an owner and a name from git's four spellings, and builds no filesystem path.
func splitPath(p string) (owner, name string, err error) {
	p = strings.TrimPrefix(p, "~")
	p = strings.TrimPrefix(p, "/")
	p = strings.TrimSuffix(p, "/")
	p = strings.TrimSuffix(p, ".git")

	owner, name, ok := strings.Cut(p, "/")
	if !ok || strings.Contains(name, "/") {
		return "", "", fmt.Errorf("a repository is <account>/<name>, got %q", p)
	}
	if !gitx.ValidName(owner) || !gitx.ValidRepoName(name) {
		return "", "", fmt.Errorf("no such repository")
	}
	return owner, name, nil
}

func firstWord(s string) string {
	if w, _, ok := strings.Cut(s, " "); ok {
		return w
	}
	return s
}