package server

import (
	"context"
	"errors"
	"net/http"
	"os"
	"strconv"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/ci"
	"gitlab.com/Timfa/bluegit/internal/diskusage"
	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/state"
	"gitlab.com/Timfa/bluegit/internal/store"
)

// forkReserveBytes: zoveel moet er naast de upstream-grootte vrij blijven.
const forkReserveBytes = 512 << 20

// canReadRepo: openbaar, of de gebruiker heeft minstens leesrechten.
func (s *Server) canReadRepo(ctx context.Context, userID int64, repo store.Repo) bool {
	if repo.Visibility == "public" {
		return true
	}
	if userID == 0 {
		return false
	}
	role, err := s.Store.EffectiveRole(ctx, userID, repo.ID)
	return err == nil && role.CanRead()
}

// ForkInfo is wat de repo-pagina over de fork-relatie toont.
type ForkInfo struct {
	IsFork   bool
	Upstream *store.Repo // nil als de kijker upstream niet mag zien
	Forks    int         // zichtbare forks van deze repo
}

func (s *Server) forkInfo(ctx context.Context, userID int64, repo store.Repo) ForkInfo {
	var fi ForkInfo
	if up, _ := s.Store.ForkOf(ctx, repo.ID); up != 0 {
		fi.IsFork = true
		if u, err := s.Store.RepoByID(ctx, up); err == nil && s.canReadRepo(ctx, userID, u) {
			fi.Upstream = &u
		}
	}
	fi.Forks = len(s.visibleForks(ctx, userID, repo))
	return fi
}

func (s *Server) visibleForks(ctx context.Context, userID int64, repo store.Repo) []store.Repo {
	ids, _ := s.Store.ForkIDs(ctx, repo.ID)
	if len(ids) == 0 {
		return nil
	}
	list, _ := s.Store.ReposByIDs(ctx, ids)
	var out []store.Repo
	for _, f := range list {
		if s.canReadRepo(ctx, userID, f) {
			out = append(out, f)
		}
	}
	return out
}

// ForkTarget is een plek waar de gebruiker een fork mag maken.
type ForkTarget struct {
	Value string // "" = eigen account, anders groepspad
	Label string
}

func (s *Server) forkTargets(ctx context.Context, user store.User) []ForkTarget {
	out := []ForkTarget{{Value: "", Label: user.Username}}
	groups, _ := s.Store.ListGroups(ctx, user.ID)
	for _, g := range groups {
		if role, err := s.Store.GroupRole(ctx, g.ID, user.ID); err == nil && role.CanWriteCode() {
			out = append(out, ForkTarget{Value: g.Path, Label: g.Path})
		}
	}
	return out
}

// opForkRepo maakt een fork met alle branches en tags. Doel: eigen account
// of een groep waar de gebruiker minstens developer is. Een fork van een
// privé repo is privé.
func (s *Server) opForkRepo(ctx context.Context, user store.User, upstream store.Repo, groupPath, rawName string) (store.Repo, error) {
	if s.StoragePath() == "" {
		return store.Repo{}, fail(503, i18n.E("err.noStorage"))
	}
	if !s.canReadRepo(ctx, user.ID, upstream) {
		return store.Repo{}, fail(404, i18n.E("err.notFound"))
	}
	if strings.TrimSpace(rawName) == "" {
		rawName = upstream.Name
	}
	name, err := slugKind("repo", rawName)
	if err != nil {
		return store.Repo{}, fail(400, err)
	}
	ownerKind, ownerID, ownerPath := "user", user.ID, user.Username
	if gp := strings.TrimSpace(groupPath); gp != "" {
		g, err := s.Store.GroupByPath(ctx, gp)
		if err != nil {
			return store.Repo{}, fail(404, i18n.E("err.groupMissing"))
		}
		role, err := s.Store.GroupRole(ctx, g.ID, user.ID)
		if err != nil || !role.AtLeast(access.RoleDeveloper) {
			return store.Repo{}, fail(403, i18n.E("err.forbidden"))
		}
		ownerKind, ownerID, ownerPath = "group", g.ID, g.Path
	}
	if _, err := s.Store.RepoByPath(ctx, ownerPath, name); err == nil {
		return store.Repo{}, fail(409, i18n.E("err.forkExists", ownerPath+"/"+name))
	}
	src := gitrepo.Dir(s.StoragePath(), upstream.OwnerPath, upstream.Name)
	if size, err := state.DirSize(ctx, src); err == nil {
		if du, err := diskusage.Usage(s.StoragePath()); err == nil && du.Free < size+forkReserveBytes {
			return store.Repo{}, fail(507, i18n.E("err.forkDisk"))
		}
	}
	repo, err := s.Store.CreateRepo(ctx, ownerKind, ownerID, name, upstream.Description, upstream.DefaultBranch, upstream.Visibility)
	if err != nil {
		return store.Repo{}, fail(400, err)
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if err := gitrepo.Fork(s.Git, src, dir, s.HookBin); err != nil {
		_ = s.Store.DeleteRepo(ctx, repo.ID)
		_ = os.RemoveAll(dir)
		return store.Repo{}, fail(500, i18n.E("err.forkGit", err.Error()))
	}
	if err := s.Store.SetForkOf(ctx, repo.ID, upstream.ID); err != nil {
		return store.Repo{}, fail(500, err)
	}
	s.syncRepos(ctx, []int64{repo.ID})
	return repo, nil
}

// forkMustStayPrivate: een fork van een privé upstream mag niet openbaar.
func (s *Server) forkMustStayPrivate(ctx context.Context, repo store.Repo) bool {
	up, _ := s.Store.ForkOf(ctx, repo.ID)
	if up == 0 {
		return false
	}
	u, err := s.Store.RepoByID(ctx, up)
	return err == nil && u.Visibility != "public"
}

func (s *Server) forkPost(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if u.ID == 0 {
		http.Redirect(w, r, "/login", http.StatusSeeOther)
		return
	}
	fork, err := s.opForkRepo(r.Context(), u, repo, r.FormValue("namespace"), r.FormValue("name"))
	if !s.uiOK(w, r, repoURL(repo), err) {
		return
	}
	s.redirect(w, r, repoURL(fork), s.tr(r, "flash.forked"), "")
}

func (s *Server) forksPage(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, s.tr(r, "fork.listTitle"))
	v.ForkList = s.visibleForks(r.Context(), u.ID, repo)
	v.Fork = s.forkInfo(r.Context(), u.ID, repo)
	s.render(w, "forks", v)
}

func forkJSON(fork store.Repo, upstream store.Repo) map[string]any {
	out := projectJSON(fork)
	out["forked_from"] = upstream.FullPath()
	return out
}

func (s *Server) apiForkProject(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	var body struct {
		Namespace string `json:"namespace"`
		Name      string `json:"name"`
	}
	if err := readJSON(r, &body); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	fork, err := s.opForkRepo(r.Context(), apiUser(r), repo, body.Namespace, body.Name)
	if !s.apiOK(w, r, err) {
		return
	}
	writeJSON(w, http.StatusCreated, forkJSON(fork, repo))
}

func (s *Server) apiListForks(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	s.writeProjects(w, r, s.visibleForks(r.Context(), apiUser(r).ID, repo))
}

// SyncResult is de uitkomst van een upstream-synchronisatie.
type SyncResult struct {
	Branch   string `json:"branch"`
	Before   string `json:"before"`
	After    string `json:"after"`
	UpToDate bool   `json:"up_to_date"`
}

// opSyncUpstream zet branch (standaard de standaardbranch) van upstream
// fast-forward door naar de fork. Geen force: bij afwijking 409. Vereist
// schrijfrechten op de fork en leesrechten op upstream; zonder leesrechten
// noemt de fout de upstream niet.
func (s *Server) opSyncUpstream(ctx context.Context, user store.User, fork store.Repo, branch string) (SyncResult, error) {
	role, err := s.Store.EffectiveRole(ctx, user.ID, fork.ID)
	if err != nil || !role.CanWriteCode() {
		return SyncResult{}, fail(403, i18n.E("err.forbidden"))
	}
	upID, _ := s.Store.ForkOf(ctx, fork.ID)
	if upID == 0 {
		return SyncResult{}, fail(400, i18n.E("err.notFork"))
	}
	up, err := s.Store.RepoByID(ctx, upID)
	if err != nil || !s.canReadRepo(ctx, user.ID, up) {
		return SyncResult{}, fail(403, i18n.E("err.upstreamNoAccess"))
	}
	branch = strings.TrimSpace(branch)
	if branch == "" {
		branch = fork.DefaultBranch
	}
	if !safeBranchName(branch) {
		return SyncResult{}, fail(400, i18n.E("err.upstreamBranch", branch))
	}
	updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name)
	dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name)
	upSHA := gitOne(ctx, s.Git, updir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch)
	if !shaLike(upSHA) {
		return SyncResult{}, fail(404, i18n.E("err.upstreamBranch", branch))
	}
	res := SyncResult{Branch: branch, Before: gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch)}
	if res.Before == upSHA {
		res.After, res.UpToDate = upSHA, true
		return res, nil
	}
	patterns, _ := s.Store.ProtectedPatterns(ctx, fork.ID)
	env := append(os.Environ(), gitrepo.PushEnv(role, patterns, nil)...)
	if err := s.postReceive(ctx, fork, user, dir, func() error {
		return gitrepo.PushBranch(ctx, s.Git, updir, dir, branch, env)
	}); err != nil {
		if errors.Is(err, gitrepo.ErrNotFastForward) {
			return res, fail(409, i18n.E("err.syncNotFF", branch))
		}
		return res, fail(400, err)
	}
	res.After = gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch)
	return res, nil
}

func safeBranchName(b string) bool {
	return b != "" && !strings.HasPrefix(b, "-") && !strings.Contains(b, "..") && !strings.ContainsAny(b, " ~^:?*[\\")
}

func (s *Server) syncUpstreamPost(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	res, err := s.opSyncUpstream(r.Context(), u, repo, r.FormValue("branch"))
	if !s.uiOK(w, r, repoURL(repo), err) {
		return
	}
	msg := "flash.synced"
	if res.UpToDate {
		msg = "flash.syncUpToDate"
	}
	s.redirect(w, r, repoURL(repo), s.tr(r, msg, res.Branch), "")
}

func (s *Server) apiSyncUpstream(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)
	if !ok {
		return
	}
	var body struct {
		Branch string `json:"branch"`
	}
	if err := readJSON(r, &body); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	res, err := s.opSyncUpstream(r.Context(), apiUser(r), repo, body.Branch)
	if !s.apiOK(w, r, err) {
		return
	}
	writeJSON(w, http.StatusOK, res)
}

// forkMirror is de branch in upstream die een fork-branch spiegelt.
// Pipelines op forks/... krijgen nooit geheimen (zie runner).
func forkMirror(forkID int64, branch string) string {
	return ci.ForkBranchPrefix + strconv.FormatInt(forkID, 10) + "/" + branch
}

// opCreateForkMR maakt in upstream een MR met als bron een branch uit de
// fork. De bron wordt gespiegeld naar forks/<forkid>/<branch> in upstream
// (geen push-hook, dus geen push-pipeline). Vereist leesrechten op de fork
// en de rol die in upstream MR's mag maken.
func (s *Server) opCreateForkMR(ctx context.Context, user store.User, fork store.Repo, source, target, title, description string, draft bool) (store.Repo, store.MergeRequest, error) {
	if !s.canReadRepo(ctx, user.ID, fork) {
		return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.notFound"))
	}
	upID, _ := s.Store.ForkOf(ctx, fork.ID)
	if upID == 0 {
		return store.Repo{}, store.MergeRequest{}, fail(400, i18n.E("err.notFork"))
	}
	up, err := s.Store.RepoByID(ctx, upID)
	if err != nil || !s.canReadRepo(ctx, user.ID, up) {
		return store.Repo{}, store.MergeRequest{}, fail(403, i18n.E("err.upstreamNoAccess"))
	}
	role, err := s.Store.EffectiveRole(ctx, user.ID, up.ID)
	if err != nil || !role.CanWriteCode() {
		return store.Repo{}, store.MergeRequest{}, fail(403, i18n.E("err.upstreamMRRole"))
	}
	source = strings.TrimSpace(source)
	target = strings.TrimSpace(target)
	if target == "" {
		target = up.DefaultBranch
	}
	if !safeBranchName(source) || !safeBranchName(target) {
		return store.Repo{}, store.MergeRequest{}, fail(400, i18n.E("err.branches"))
	}
	dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name)
	updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name)
	if !shaLike(gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+source)) {
		return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.upstreamBranch", source))
	}
	if !shaLike(gitOne(ctx, s.Git, updir, "rev-parse", "--verify", "--quiet", "refs/heads/"+target)) {
		return store.Repo{}, store.MergeRequest{}, fail(404, i18n.E("err.upstreamBranch", target))
	}
	mirror := forkMirror(fork.ID, source)
	if err := gitrepo.FetchBranch(ctx, s.Git, dir, updir, source, mirror); err != nil {
		return store.Repo{}, store.MergeRequest{}, fail(500, err)
	}
	s.refsChanged(up)
	mr, err := s.opCreateMR(ctx, user, up, title, description, mirror, target, draft)
	if err != nil {
		return store.Repo{}, store.MergeRequest{}, err
	}
	_ = s.Store.SetMRForkSource(ctx, mr.ID, fork.ID, source)
	return up, mr, nil
}

// refreshForkMRs: na een push in een fork de gespiegelde branches in
// upstream bijwerken; AfterPush van upstream start de MR-pipelines.
func (s *Server) refreshForkMRs(fork store.Repo, user store.User, branch string) {
	ctx := context.Background()
	list, err := s.Store.OpenForkMRs(ctx, fork.ID, branch)
	if err != nil || len(list) == 0 {
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), fork.OwnerPath, fork.Name)
	for _, m := range list {
		up, err := s.Store.RepoByID(ctx, m.UpstreamID)
		if err != nil || !s.canReadRepo(ctx, user.ID, up) {
			continue
		}
		updir := gitrepo.Dir(s.StoragePath(), up.OwnerPath, up.Name)
		_ = s.postReceive(ctx, up, user, updir, func() error {
			return gitrepo.FetchBranch(ctx, s.Git, dir, updir, branch, m.Mirror)
		})
	}
}

func (s *Server) forkMRPost(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	up, mr, err := s.opCreateForkMR(r.Context(), u, repo, r.FormValue("source"), r.FormValue("target"), r.FormValue("title"), r.FormValue("description"), r.FormValue("draft") == "1")
	if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests/new", err) {
		return
	}
	s.redirect(w, r, repoURL(up)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.mrOpened"), "")
}

func (s *Server) apiForkMR(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	var body struct {
		Source      string `json:"source_branch"`
		Target      string `json:"target_branch"`
		Title       string `json:"title"`
		Description string `json:"description"`
		Draft       bool   `json:"draft"`
	}
	if err := readJSON(r, &body); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	up, mr, err := s.opCreateForkMR(r.Context(), apiUser(r), repo, body.Source, body.Target, body.Title, body.Description, body.Draft)
	if !s.apiOK(w, r, err) {
		return
	}
	out := s.mrJSON(up, mr)
	out["source_project"] = repo.FullPath()
	out["source_project_branch"] = body.Source
	writeJSON(w, http.StatusCreated, out)
}
