// Package gitbootstrap creates and validates Kandev's local baseline for an
// authenticated remote that has no refs yet.
package gitbootstrap

import (
	"context"
	"errors"
	"fmt"
	"os"
	"strings"

	"github.com/kandev/kandev/internal/common/securityutil"
	"github.com/kandev/kandev/internal/common/subproc"
)

const (
	// EmptyTreeSHA is the empty tree object in the default SHA-1 Git object
	// format. Repositories using another object format still receive the
	// repository's own empty-tree object from git mktree.
	EmptyTreeSHA  = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
	markerPrefix  = "refs/kandev/empty-remote/"
	commitMessage = "Kandev empty remote baseline"
	identityName  = "Kandev"
	identityEmail = "kandev@localhost"
	commitDate    = "1970-01-01T00:00:00Z"
)

var (
	ErrInvalidBaseBranch = errors.New("invalid empty-remote base branch")
	ErrBaselineConflict  = errors.New("empty-remote baseline conflicts with local Git history")
)

// Baseline identifies the local commit and refs that represent an empty
// remote. The marker and base refs must always point at the same commit.
type Baseline struct {
	Commit    string
	BaseRef   string
	MarkerRef string
}

// MarkerRef returns the local marker ref for a validated base branch.
func MarkerRef(baseBranch string) (string, error) {
	branch, err := normalizeBranch(baseBranch)
	if err != nil {
		return "", err
	}
	return markerPrefix + branch, nil
}

// Ensure creates the deterministic local baseline when neither local ref
// exists. It never writes files or contacts the remote. A concurrent local
// history write is reported as a conflict and is never overwritten.
func Ensure(ctx context.Context, repoPath, baseBranch string) (Baseline, error) {
	baseRef, markerRef, err := refsForBranch(baseBranch)
	if err != nil {
		return Baseline{}, err
	}
	existing, present, err := readBaseline(ctx, repoPath, baseRef, markerRef)
	if err != nil {
		return Baseline{}, err
	}
	if present {
		return existing, nil
	}
	if basePresent, err := refPresent(ctx, repoPath, baseRef); err != nil {
		return Baseline{}, err
	} else if basePresent {
		return Baseline{}, ErrBaselineConflict
	}

	tree, err := createEmptyTree(ctx, repoPath)
	if err != nil {
		return Baseline{}, fmt.Errorf("create empty Git tree: %w", err)
	}
	commit, err := createCommit(ctx, repoPath, tree)
	if err != nil {
		return Baseline{}, fmt.Errorf("create empty-remote baseline commit: %w", err)
	}
	baseline := Baseline{Commit: commit, BaseRef: baseRef, MarkerRef: markerRef}
	if err := createRefs(ctx, repoPath, baseline); err != nil {
		verified, verifiedPresent, verifyErr := readBaseline(ctx, repoPath, baseRef, markerRef)
		if verifyErr == nil && verifiedPresent && verified.Commit == commit {
			return verified, nil
		}
		if verifyErr != nil {
			return Baseline{}, fmt.Errorf("publish local empty-remote refs: %w; verify race: %v", err, verifyErr)
		}
		if verifiedPresent {
			return Baseline{}, ErrBaselineConflict
		}
		return Baseline{}, fmt.Errorf("publish local empty-remote refs: %w", err)
	}
	return baseline, nil
}

// Validate reports whether the exact local baseline marker exists. A missing
// marker is not an error because it means this repository is not bootstrapped.
func Validate(ctx context.Context, repoPath, baseBranch string) (Baseline, bool, error) {
	baseRef, markerRef, err := refsForBranch(baseBranch)
	if err != nil {
		return Baseline{}, false, err
	}
	baseline, present, err := readBaseline(ctx, repoPath, baseRef, markerRef)
	return baseline, present, err
}

// Retire removes the local bootstrap marker after the baseline has been
// published. The expected commit protects a concurrent local ref change.
func Retire(ctx context.Context, repoPath string, baseline Baseline) error {
	if strings.TrimSpace(baseline.MarkerRef) == "" || strings.TrimSpace(baseline.Commit) == "" {
		return errors.New("invalid empty-remote baseline marker")
	}
	input := strings.Join([]string{
		"start",
		"delete " + baseline.MarkerRef + " " + baseline.Commit,
		"prepare",
		"commit",
		"",
	}, "\n")
	if _, err := runGitWithInput(ctx, repoPath, input, "update-ref", "--stdin"); err != nil {
		return fmt.Errorf("retire empty-remote baseline marker: %w", err)
	}
	return nil
}

func refsForBranch(baseBranch string) (string, string, error) {
	branch, err := normalizeBranch(baseBranch)
	if err != nil {
		return "", "", err
	}
	return "refs/heads/" + branch, markerPrefix + branch, nil
}

func normalizeBranch(baseBranch string) (string, error) {
	branch := strings.TrimPrefix(strings.TrimSpace(baseBranch), "origin/")
	if !securityutil.IsValidBaseBranchRef(branch) {
		return "", fmt.Errorf("%w: %q", ErrInvalidBaseBranch, baseBranch)
	}
	return branch, nil
}

func readBaseline(ctx context.Context, repoPath, baseRef, markerRef string) (Baseline, bool, error) {
	baseCommit, basePresent, err := readRef(ctx, repoPath, baseRef)
	if err != nil {
		return Baseline{}, false, err
	}
	markerCommit, markerPresent, err := readRef(ctx, repoPath, markerRef)
	if err != nil {
		return Baseline{}, false, err
	}
	if !markerPresent {
		return Baseline{}, false, nil
	}
	if !basePresent || !markerPresent || baseCommit != markerCommit {
		return Baseline{}, false, ErrBaselineConflict
	}
	return Baseline{Commit: baseCommit, BaseRef: baseRef, MarkerRef: markerRef}, true, nil
}

func refPresent(ctx context.Context, repoPath, ref string) (bool, error) {
	_, present, err := readRef(ctx, repoPath, ref)
	return present, err
}

func readRef(ctx context.Context, repoPath, ref string) (string, bool, error) {
	output, err := runGit(ctx, repoPath, "rev-parse", "--verify", "--quiet", ref+"^{commit}")
	if err != nil {
		if strings.TrimSpace(output) == "" {
			return "", false, nil
		}
		return "", false, fmt.Errorf("read local Git ref %q: %w", ref, err)
	}
	commit := strings.TrimSpace(output)
	if commit == "" {
		return "", false, nil
	}
	return commit, true, nil
}

func createEmptyTree(ctx context.Context, repoPath string) (string, error) {
	output, err := runGitWithInput(ctx, repoPath, "", "mktree")
	if err != nil {
		return "", err
	}
	tree := strings.TrimSpace(output)
	if tree == "" {
		return "", errors.New("git mktree returned no object ID")
	}
	return tree, nil
}

func createCommit(ctx context.Context, repoPath, tree string) (string, error) {
	cmd := subproc.NewGitCommand(ctx,
		"-C", repoPath,
		"-c", "user.name="+identityName,
		"-c", "user.email="+identityEmail,
		"-c", "commit.gpgSign=false",
		"commit-tree", tree, "-m", commitMessage,
	)
	cmd.Env = baselineGitEnvironment()
	output, err := subproc.RunGitCombinedOutputClass(ctx, subproc.GitLifecycle, cmd)
	if err != nil {
		return "", fmt.Errorf("%s: %w", strings.TrimSpace(string(output)), err)
	}
	commit := strings.TrimSpace(string(output))
	if commit == "" {
		return "", errors.New("git commit-tree returned no object ID")
	}
	return commit, nil
}

func baselineGitEnvironment() []string {
	const (
		authorName     = "GIT_AUTHOR_NAME="
		authorEmail    = "GIT_AUTHOR_EMAIL="
		committerName  = "GIT_COMMITTER_NAME="
		committerEmail = "GIT_COMMITTER_EMAIL="
	)
	env := make([]string, 0, len(os.Environ())+6)
	for _, entry := range os.Environ() {
		if strings.HasPrefix(entry, authorName) || strings.HasPrefix(entry, authorEmail) ||
			strings.HasPrefix(entry, committerName) || strings.HasPrefix(entry, committerEmail) {
			continue
		}
		env = append(env, entry)
	}
	return append(env,
		"GIT_AUTHOR_DATE="+commitDate,
		"GIT_COMMITTER_DATE="+commitDate,
		"GIT_AUTHOR_NAME="+identityName,
		"GIT_AUTHOR_EMAIL="+identityEmail,
		"GIT_COMMITTER_NAME="+identityName,
		"GIT_COMMITTER_EMAIL="+identityEmail,
		"GIT_CONFIG_NOSYSTEM=1",
		"GIT_TERMINAL_PROMPT=0",
	)
}

func createRefs(ctx context.Context, repoPath string, baseline Baseline) error {
	input := strings.Join([]string{
		"start",
		"create " + baseline.BaseRef + " " + baseline.Commit,
		"create " + baseline.MarkerRef + " " + baseline.Commit,
		"prepare",
		"commit",
		"",
	}, "\n")
	_, err := runGitWithInput(ctx, repoPath, input, "update-ref", "--stdin")
	return err
}

func runGitWithInput(ctx context.Context, repoPath, input string, args ...string) (string, error) {
	cmd := subproc.NewGitCommand(ctx, append([]string{"-C", repoPath}, args...)...)
	cmd.Stdin = strings.NewReader(input)
	cmd.Env = append(os.Environ(), "GIT_CONFIG_NOSYSTEM=1", "GIT_TERMINAL_PROMPT=0")
	output, err := subproc.RunGitCombinedOutputClass(ctx, subproc.GitLifecycle, cmd)
	if err != nil {
		return string(output), fmt.Errorf("git %v: %s: %w", args, strings.TrimSpace(string(output)), err)
	}
	return string(output), nil
}

func runGit(ctx context.Context, repoPath string, args ...string) (string, error) {
	return runGitWithInput(ctx, repoPath, "", args...)
}