package gitrepo

import (
	"bytes"
	"context"
	"errors"
	"io"
	"os"
	"os/exec"
	"strings"
	"sync"
	"syscall"
	"time"

	"gitlab.com/Timfa/bluegit/internal/names"
)

// Fouten bij het lezen of vasthouden van refs/tags/<naam>.
// De tekst bevat geen pad en geen git-stderr; die staat apart in TagRefError.
var (
	ErrTagMissing   = errors.New("tag missing")
	ErrTagSymbolic  = errors.New("symbolic tag")
	ErrTagNotCommit = errors.New("tag is not a commit")
	ErrTagMoved     = errors.New("tag ref changed")
	ErrTagBusy      = errors.New("tag ref busy")
	ErrTagLock      = errors.New("tag ref lock failed")
)

// TagRefError is een lockfout. Detail is alleen voor het serverlog.
type TagRefError struct {
	Kind   error
	Detail string
}

func (e *TagRefError) Error() string {
	if e == nil || e.Kind == nil {
		return ""
	}
	return e.Kind.Error()
}

func (e *TagRefError) Unwrap() error {
	if e == nil {
		return nil
	}
	return e.Kind
}

// TagPoint is een directe tagref. ObjectOID is het object in de ref
// (commit bij lightweight, tag-object bij annotated). CommitOID is gepeeld.
type TagPoint struct {
	Name      string
	Ref       string
	ObjectOID string
	CommitOID string
}

// refHoldReplyTimeout begrenst één antwoord van git update-ref en het wachten
// op een lock die een andere publicatie vasthoudt. Tests zetten hem lager.
var refHoldReplyTimeout = 5 * time.Second

// ResolveTag leest refs/tags/<name> zonder een ambigue revisie.
// Een symbolic ref of een tag die niet naar een commit peelt wordt geweigerd.
func ResolveTag(ctx context.Context, gitBin, dir, name string) (TagPoint, error) {
	if err := names.ValidTag(name); err != nil {
		return TagPoint{}, err
	}
	ref := "refs/tags/" + name
	if gitBin == "" {
		gitBin = "git"
	}
	sym := exec.CommandContext(ctx, gitBin, "-C", dir, "symbolic-ref", "-q", ref)
	sym.Env = gitExecEnv()
	if err := sym.Run(); err == nil {
		return TagPoint{}, ErrTagSymbolic
	}
	if ctx.Err() != nil {
		return TagPoint{}, ctx.Err()
	}
	object, err := gitLine(ctx, gitBin, dir, "rev-parse", "--verify", "--end-of-options", ref)
	if err != nil {
		if ctx.Err() != nil {
			return TagPoint{}, ctx.Err()
		}
		return TagPoint{}, ErrTagMissing
	}
	object, ok := normalizeOID(object)
	if !ok {
		return TagPoint{}, ErrTagMissing
	}
	commit, err := gitLine(ctx, gitBin, dir, "rev-parse", "--verify", "--end-of-options", ref+"^{commit}")
	if err != nil {
		if ctx.Err() != nil {
			return TagPoint{}, ctx.Err()
		}
		return TagPoint{}, ErrTagNotCommit
	}
	commit, ok = normalizeOID(commit)
	if !ok {
		return TagPoint{}, ErrTagNotCommit
	}
	return TagPoint{Name: name, Ref: ref, ObjectOID: object, CommitOID: commit}, nil
}

// RefHold houdt refs/tags/<naam> vast via git update-ref --stdin.
// De transactie verifieert alleen. Release stuurt abort, zodat de tag
// niet verandert en git zelf de lock vrijgeeft.
type RefHold struct {
	inner *refProc
}

// HoldTagRef neemt de ref-lock pas als git "prepare: ok" heeft geantwoord.
// Een lock die een andere git-proces vasthoudt, wordt begrensd afgewacht.
// Een andere OID is ErrTagMoved. Dit proces verwijdert nooit zelf een .lock-bestand.
func HoldTagRef(ctx context.Context, gitBin, dir, name, objectOID string) (*RefHold, error) {
	if err := names.ValidTag(name); err != nil {
		return nil, err
	}
	objectOID, ok := normalizeOID(objectOID)
	if !ok {
		return nil, ErrTagLock
	}
	if gitBin == "" {
		gitBin = "git"
	}
	deadline := time.Now().Add(refHoldReplyTimeout)
	for {
		if err := ctx.Err(); err != nil {
			return nil, err
		}
		hold, err := acquireTagRef(ctx, gitBin, dir, "refs/tags/"+name, objectOID)
		if err == nil {
			return hold, nil
		}
		if !errors.Is(err, ErrTagBusy) || !time.Now().Before(deadline) {
			if errors.Is(err, ErrTagBusy) {
				return nil, &TagRefError{Kind: ErrTagLock, Detail: detailOf(err)}
			}
			return nil, err
		}
		timer := time.NewTimer(20 * time.Millisecond)
		select {
		case <-ctx.Done():
			timer.Stop()
			return nil, ctx.Err()
		case <-timer.C:
		}
	}
}

// Release breekt de verify-transactie af. De tag blijft gelijk.
// Een tweede aanroep doet niets. Bij een vastgelopen proces gaat er
// SIGTERM heen. SIGKILL blijft achterwege: die laat een git-lockfile staan,
// en die ruimen we niet zelf op.
func (h *RefHold) Release() error {
	if h == nil || h.inner == nil {
		return nil
	}
	return h.inner.finish(true)
}

type refProc struct {
	cmd      *exec.Cmd
	stdin    io.WriteCloser
	out      *os.File
	errBuf   bytes.Buffer
	wg       sync.WaitGroup
	finished bool
	detail   string
	abortOK  bool
}

func acquireTagRef(ctx context.Context, gitBin, dir, ref, objectOID string) (*RefHold, error) {
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	cmd := exec.Command(gitBin, "-C", dir, "update-ref", "--stdin")
	cmd.Env = gitExecEnv()
	stdin, err := cmd.StdinPipe()
	if err != nil {
		return nil, err
	}
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		_ = stdin.Close()
		return nil, err
	}
	out, ok := stdout.(*os.File)
	if !ok {
		_ = stdin.Close()
		_ = stdout.Close()
		return nil, ErrTagLock
	}
	stderr, err := cmd.StderrPipe()
	if err != nil {
		_ = stdin.Close()
		_ = stdout.Close()
		return nil, err
	}
	if err := cmd.Start(); err != nil {
		_ = stdin.Close()
		_ = stdout.Close()
		_ = stderr.Close()
		return nil, err
	}
	p := &refProc{cmd: cmd, stdin: stdin, out: out}
	p.wg.Add(1)
	go func() {
		defer p.wg.Done()
		_, _ = io.Copy(&p.errBuf, stderr)
	}()
	fail := func(kind error) (*RefHold, error) {
		_ = p.finish(false)
		return nil, &TagRefError{Kind: kind, Detail: strings.TrimSpace(p.detail)}
	}
	if err := p.write("option no-deref"); err != nil {
		return fail(ErrTagLock)
	}
	if err := p.write("start"); err != nil {
		return fail(ErrTagLock)
	}
	line, err := p.readLine()
	if err != nil || line != "start: ok" {
		return fail(ErrTagLock)
	}
	if err := p.write("verify " + ref + " " + objectOID); err != nil {
		return fail(ErrTagLock)
	}
	if err := p.write("prepare"); err != nil {
		return fail(ErrTagLock)
	}
	line, err = p.readLine()
	if err != nil || line != "prepare: ok" {
		_ = p.finish(false)
		return nil, classifyPrepare(strings.TrimSpace(p.detail))
	}
	return &RefHold{inner: p}, nil
}

func classifyPrepare(detail string) error {
	low := strings.ToLower(detail)
	kind := ErrTagMoved
	if strings.Contains(low, "file exists") || strings.Contains(low, "unable to create") {
		kind = ErrTagBusy
	}
	return &TagRefError{Kind: kind, Detail: detail}
}

func (p *refProc) write(line string) error {
	if strings.ContainsAny(line, "\r\n") {
		return ErrTagLock
	}
	_, err := io.WriteString(p.stdin, line+"\n")
	return err
}

func (p *refProc) readLine() (string, error) {
	_ = p.out.SetReadDeadline(time.Now().Add(refHoldReplyTimeout))
	var b strings.Builder
	tmp := make([]byte, 1)
	for b.Len() <= 1024 {
		n, err := p.out.Read(tmp)
		if n == 1 {
			if tmp[0] == '\n' {
				return strings.TrimSpace(b.String()), nil
			}
			b.WriteByte(tmp[0])
			continue
		}
		if err != nil {
			return b.String(), err
		}
	}
	return b.String(), ErrTagLock
}

func (p *refProc) finish(tryAbort bool) error {
	if p == nil || p.finished {
		return nil
	}
	p.finished = true
	if tryAbort && p.cmd.Process != nil {
		_ = p.write("abort")
		line, err := p.readLine()
		p.abortOK = err == nil && line == "abort: ok"
	}
	_ = p.stdin.Close()
	err := p.reap()
	p.detail = strings.TrimSpace(p.errBuf.String())
	if p.abortOK {
		return nil
	}
	return err
}

func (p *refProc) reap() error {
	if p.cmd.Process == nil {
		p.wg.Wait()
		return nil
	}
	done := make(chan error, 1)
	go func() { done <- p.cmd.Wait() }()
	select {
	case err := <-done:
		p.wg.Wait()
		return err
	case <-time.After(refHoldReplyTimeout):
		_ = p.cmd.Process.Signal(syscall.SIGTERM)
	}
	select {
	case err := <-done:
		p.wg.Wait()
		return err
	case <-time.After(refHoldReplyTimeout):
		// Niet wg.Wait(): stderr kan open blijven als SIGTERM niets deed.
		// Geen SIGKILL en geen Remove van *.lock: een stale lock is van git.
		return ErrTagLock
	}
}

func detailOf(err error) string {
	var te *TagRefError
	if errors.As(err, &te) {
		return te.Detail
	}
	return ""
}

func gitLine(ctx context.Context, gitBin, dir string, args ...string) (string, error) {
	cmd := exec.CommandContext(ctx, gitBin, append([]string{"-C", dir}, args...)...)
	cmd.Env = gitExecEnv()
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	if err := cmd.Run(); err != nil {
		return "", err
	}
	return strings.TrimSpace(stdout.String()), nil
}

func gitExecEnv() []string {
	env := []string{"LC_ALL=C", "GIT_TERMINAL_PROMPT=0"}
	if path := os.Getenv("PATH"); path != "" {
		env = append(env, "PATH="+path)
	} else {
		env = append(env, "PATH=/usr/bin:/bin")
	}
	if home := os.Getenv("HOME"); home != "" {
		env = append(env, "HOME="+home)
	}
	return env
}

func normalizeOID(s string) (string, bool) {
	if len(s) != 40 && len(s) != 64 {
		return "", false
	}
	s = strings.ToLower(s)
	for _, c := range s {
		if (c < '0' || c > '9') && (c < 'a' || c > 'f') {
			return "", false
		}
	}
	return s, true
}
