package server

import (
	"context"
	"net/http"
	"os"
	"strings"
	"syscall"

	"gitlab.com/Timfa/bluegit/internal/access"
	"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 {
		var st syscall.Statfs_t
		if syscall.Statfs(s.StoragePath(), &st) == nil && st.Bavail*uint64(st.Bsize) < 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))
}
