package gitrepo

import (
	"context"
	"errors"
	"os"
	"path/filepath"
	"sort"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/i18n"
)

// SuggestionEdit vervangt de regels Start t/m End (1-based, inclusief)
// als die nog gelijk zijn aan Base.
type SuggestionEdit struct {
	Path, Base, Replacement string
	Start, End              int
}

// ParseSuggestion haalt de eerste ```suggestion-blok uit een reactie.
// De tekst is zonder de afsluitende newline van het blok.
func ParseSuggestion(body string) (string, bool) {
	body = strings.ReplaceAll(body, "\r\n", "\n")
	const open = "```suggestion"
	i := strings.Index(body, open)
	if i < 0 {
		return "", false
	}
	rest := body[i+len(open):]
	nl := strings.IndexByte(rest, '\n')
	if nl < 0 {
		return "", false
	}
	rest = rest[nl+1:]
	end := strings.Index(rest, "```")
	if end < 0 {
		return "", false
	}
	return strings.TrimSuffix(rest[:end], "\n"), true
}

// SplitLines splitst een bestand op newlines. Een afsluitende newline telt niet als lege regel.
func SplitLines(s string) []string {
	if s == "" {
		return nil
	}
	s = strings.TrimSuffix(s, "\n")
	return strings.Split(s, "\n")
}

// ApplySuggestions past alle edits toe. Bij een conflict of overlap verandert er niets.
func ApplySuggestions(files map[string]string, edits []SuggestionEdit) (map[string]string, error) {
	byPath := map[string][]SuggestionEdit{}
	for _, e := range edits {
		byPath[e.Path] = append(byPath[e.Path], e)
	}
	out := map[string]string{}
	changed := false
	for path, group := range byPath {
		raw, ok := files[path]
		if !ok {
			return nil, i18n.E("err.sugFile")
		}
		sort.Slice(group, func(i, j int) bool { return group[i].Start < group[j].Start })
		for i := 1; i < len(group); i++ {
			if group[i].Start <= group[i-1].End {
				return nil, i18n.E("err.sugOverlap", path)
			}
		}
		lines := SplitLines(raw)
		nl := strings.HasSuffix(raw, "\n") || raw == ""
		sort.Slice(group, func(i, j int) bool { return group[i].Start > group[j].Start })
		for _, e := range group {
			if e.Start < 1 || e.End < e.Start || e.End > len(lines) {
				return nil, i18n.E("err.sugConflict", path, e.Start, e.End)
			}
			base := strings.Join(lines[e.Start-1:e.End], "\n")
			if base != e.Base {
				return nil, i18n.E("err.sugConflict", path, e.Start, e.End)
			}
			var mid []string
			if e.Replacement != "" {
				mid = strings.Split(e.Replacement, "\n")
			}
			next := append([]string{}, lines[:e.Start-1]...)
			next = append(next, mid...)
			next = append(next, lines[e.End:]...)
			lines = next
		}
		next := ""
		if len(lines) > 0 {
			next = strings.Join(lines, "\n")
			if nl {
				next += "\n"
			}
		}
		if next != raw {
			changed = true
			out[path] = next
		}
	}
	if !changed {
		return nil, i18n.E("err.sugSame")
	}
	return out, nil
}

// CommitOnBranch schrijft files op branch en pusht één commit.
// De push loopt door de hook, met role en de beschermde patronen.
// Een repository zonder commits krijgt deze branch als eerste commit, zonder parent.
// Git draait met een eigen HOME en TMPDIR onder work, niet met die van het proces:
// ProtectHome maakt de homedirectory onleesbaar en /tmp is niet de werkmap.
func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, role access.Role, patterns []string) error {
	repo, env, err := prepareWork(work, author, email)
	if err != nil {
		return classifyGit(err)
	}
	if _, err := run(ctx, gitBin, env, "clone", bare, repo); err != nil {
		return classifyGit(err)
	}
	if _, err := run(ctx, gitBin, env, "-C", repo, "rev-parse", "--verify", "--quiet", "HEAD"); err != nil {
		if _, err := run(ctx, gitBin, env, "-C", repo, "symbolic-ref", "HEAD", "refs/heads/"+branch); err != nil {
			return classifyGit(err)
		}
	} else if _, err := run(ctx, gitBin, env, "-C", repo, "checkout", branch); err != nil {
		return classifyGit(err)
	}
	var paths []string
	for path, body := range files {
		if !safeWorkPath(path) {
			return i18n.E("err.sugFile")
		}
		dst := filepath.Join(repo, filepath.FromSlash(path))
		if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
			return classifyGit(err)
		}
		if err := os.WriteFile(dst, []byte(body), 0o644); err != nil {
			return classifyGit(err)
		}
		paths = append(paths, path)
	}
	sort.Strings(paths)
	args := append([]string{"-C", repo, "add", "--"}, paths...)
	if _, err := run(ctx, gitBin, env, args...); err != nil {
		return classifyGit(err)
	}
	commit := []string{"-C", repo, "-c", "commit.gpgsign=false", "commit", "-m", title}
	if strings.TrimSpace(description) != "" {
		commit = append(commit, "-m", description)
	}
	if _, err := run(ctx, gitBin, env, commit...); err != nil {
		return classifyGit(err)
	}
	pushEnv := append(append([]string{}, env...), PushEnv(role, patterns, nil)...)
	if _, err := run(ctx, gitBin, pushEnv, "-C", repo, "push", "origin", "HEAD:"+branch); err != nil {
		return classifyGit(err)
	}
	return nil
}

// CommandEnv is de omgeving voor elke git-aanroep die een commit maakt.
// HOME en TMPDIR wijzen naar mappen die het proces zelf mag schrijven.
// Naam en e-mail staan expliciet, zodat een lege of afgeschermde identiteit niet meetelt.
func CommandEnv(author, email, home, tmp string) []string {
	env := make([]string, 0, len(os.Environ())+8)
	for _, e := range os.Environ() {
		if strings.HasPrefix(e, "GIT_AUTHOR_") || strings.HasPrefix(e, "GIT_COMMITTER_") || strings.HasPrefix(e, "GIT_CONFIG") {
			continue
		}
		if strings.HasPrefix(e, "HOME=") || strings.HasPrefix(e, "TMPDIR=") {
			continue
		}
		env = append(env, e)
	}
	return append(env,
		"HOME="+home,
		"TMPDIR="+tmp,
		"GIT_CONFIG_GLOBAL=/dev/null",
		"GIT_CONFIG_SYSTEM=/dev/null",
		"GIT_AUTHOR_NAME="+author,
		"GIT_AUTHOR_EMAIL="+email,
		"GIT_COMMITTER_NAME="+author,
		"GIT_COMMITTER_EMAIL="+email,
	)
}

// prepareWork maakt work leeg en zet er een eigen home en tmp in.
// De kloon komt in work/repo, zodat die mappen geen deel van de tree zijn.
func prepareWork(work, author, email string) (string, []string, error) {
	if err := os.RemoveAll(work); err != nil {
		return "", nil, err
	}
	if err := os.MkdirAll(work, 0o755); err != nil {
		return "", nil, err
	}
	home := filepath.Join(work, "home")
	tmp := filepath.Join(work, "tmp")
	if err := os.MkdirAll(home, 0o700); err != nil {
		return "", nil, err
	}
	if err := os.MkdirAll(tmp, 0o700); err != nil {
		return "", nil, err
	}
	return filepath.Join(work, "repo"), CommandEnv(author, email, home, tmp), nil
}

// Cause koppelt een vertaalbare melding aan de ruwe git-tekst.
// Error() is de git-tekst voor het journal. Unwrap levert de vertaling.
func Cause(key, git string, args ...any) error {
	return gitCause{git: git, err: i18n.E(key, args...)}
}

type gitCause struct {
	git string
	err error
}

func (g gitCause) Error() string { return g.git }
func (g gitCause) Unwrap() error { return g.err }

func classifyGit(err error) error {
	if err == nil {
		return nil
	}
	var ie i18n.Error
	if errors.As(err, &ie) {
		return err
	}
	low := strings.ToLower(err.Error())
	switch {
	case strings.Contains(low, "nothing to commit") || strings.Contains(low, "nothing added"):
		return Cause("edit.same", err.Error())
	case strings.Contains(low, "protected") || strings.Contains(low, "beschermd") || strings.Contains(low, "geschützt") || strings.Contains(low, "protégée"):
		return Cause("edit.protected", err.Error())
	case strings.Contains(low, "author identity") || strings.Contains(low, "user.email") || strings.Contains(low, "user.name") || strings.Contains(low, "tell me who you are"):
		return Cause("edit.failIdentity", err.Error())
	case strings.Contains(low, "permission denied") || strings.Contains(low, "read-only") || strings.Contains(low, "unable to access") || strings.Contains(low, "operation not permitted"):
		return Cause("edit.failWrite", err.Error())
	default:
		return Cause("edit.failGit", err.Error())
	}
}

func safeWorkPath(p string) bool {
	if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, `\`) || strings.Contains(p, "..") {
		return false
	}
	return true
}
