package server

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

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/names"
	"gitlab.com/Timfa/bluegit/internal/state"
	"gitlab.com/Timfa/bluegit/internal/store"
	"gitlab.com/Timfa/bluegit/internal/webhook"
)

func (s *Server) opCreateGroup(ctx context.Context, user store.User, display, description, defaultRole string) (store.Group, error) {
	display = strings.TrimSpace(display)
	path, err := slugKind("group", display)
	if err != nil {
		return store.Group{}, fail(400, err)
	}
	role := access.Role("")
	if strings.TrimSpace(defaultRole) != "" {
		role, err = access.ParseRole(defaultRole)
		if err != nil {
			return store.Group{}, fail(400, err)
		}
	}
	g, err := s.Store.CreateGroup(ctx, user.ID, display, path, description, role)
	if err != nil {
		return store.Group{}, fail(400, err)
	}
	return g, nil
}

func slugKind(kind, raw string) (string, error) {
	path, err := names.Slug(kind, raw)
	if err != nil {
		return "", i18n.E("slug.bad")
	}
	return path, nil
}

func (s *Server) opUpdateGroup(ctx context.Context, user store.User, g store.Group, description, visibility, defaultRole string) error {
	role, err := s.Store.GroupRole(ctx, g.ID, user.ID)
	if err != nil || !role.AtLeast(access.RoleMaintainer) {
		return fail(403, i18n.E("err.forbidden"))
	}
	if visibility != "public" {
		visibility = "private"
	}
	next := g.DefaultRole
	if strings.TrimSpace(defaultRole) != "" {
		next, err = access.ParseRole(defaultRole)
		if err != nil {
			return fail(400, err)
		}
	}
	if err := s.Store.UpdateGroup(ctx, g.ID, description, visibility, next); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opTransferGroup(ctx context.Context, user store.User, g store.Group, username, confirm string) error {
	if user.ID != g.OwnerID {
		return fail(403, i18n.E("err.ownerOnly"))
	}
	username = strings.ToLower(strings.TrimSpace(username))
	if username == "" || confirm != username {
		return fail(400, i18n.E("err.ownerConfirm"))
	}
	to, err := s.Store.UserByUsername(ctx, username)
	if err != nil {
		return fail(400, i18n.E("err.ownerMember"))
	}
	if err := s.Store.TransferGroupOwner(ctx, g.ID, user.ID, to.ID); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opCreateRepo(ctx context.Context, user store.User, rawName, description, groupPath, visibility string, readme bool) (store.Repo, error) {
	if s.StoragePath() == "" {
		return store.Repo{}, fail(503, i18n.E("err.noStorage"))
	}
	name, err := slugKind("repo", rawName)
	if err != nil {
		return store.Repo{}, fail(400, err)
	}
	ownerKind := "user"
	ownerID := user.ID
	if gpath := strings.TrimSpace(groupPath); gpath != "" {
		g, err := s.Store.GroupByPath(ctx, gpath)
		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.CanManageSettings() {
			return store.Repo{}, fail(403, i18n.E("err.forbidden"))
		}
		ownerKind, ownerID = "group", g.ID
	}
	if visibility != "public" {
		visibility = "private"
	}
	repo, err := s.Store.CreateRepo(ctx, ownerKind, ownerID, name, description, s.Cfg.Git.DefaultBranch, visibility)
	if err != nil {
		return store.Repo{}, fail(400, err)
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
		_ = s.Store.DeleteRepo(ctx, repo.ID)
		return store.Repo{}, fail(500, i18n.E("err.gitInit", err.Error()))
	}
	if readme {
		role, _ := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
		if _, err := s.opWriteFiles(ctx, user, repo, role, repo.DefaultBranch, "", "Initial commit", "", map[string]string{
			"README.md": "# " + repo.Name + "\n",
		}, nil); err != nil {
			_ = s.Store.DeleteRepo(ctx, repo.ID)
			_ = os.RemoveAll(dir)
			return store.Repo{}, err
		}
	}
	return repo, nil
}

func (s *Server) opUpdateRepo(ctx context.Context, user store.User, repo store.Repo, description, visibility string) error {
	role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
	if err != nil || !role.CanManageSettings() {
		return fail(403, i18n.E("err.forbidden"))
	}
	if visibility != "public" {
		visibility = "private"
	}
	if visibility == "public" && s.forkMustStayPrivate(ctx, repo) {
		return fail(400, i18n.E("err.forkPrivate"))
	}
	if err := s.Store.UpdateRepo(ctx, repo.ID, description, visibility); err != nil {
		return fail(400, err)
	}
	if visibility != repo.Visibility {
		s.ReadCache().DropRepo(repo.ID)
	}
	return nil
}

// opSetDefaultBranch zet HEAD en de metadata naar een bestaande branch.
func (s *Server) opSetDefaultBranch(ctx context.Context, user store.User, repo store.Repo, branch string) error {
	role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
	if err != nil || !role.CanManageSettings() {
		return fail(403, i18n.E("err.forbidden"))
	}
	branch = strings.TrimSpace(branch)
	if err := names.ValidBranch(branch); err != nil {
		return fail(400, err)
	}
	if branch == repo.DefaultBranch {
		return nil
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if !gitrepo.HasBranch(ctx, s.Git, dir, branch) {
		return fail(400, i18n.E("err.branchMissing"))
	}
	if err := gitrepo.SetHEAD(ctx, s.Git, dir, branch); err != nil {
		return err
	}
	return s.Store.SetDefaultBranch(ctx, repo.ID, branch)
}

// opSetRepoCIPaused zet of nieuwe pipelines mogen worden ingepland.
func (s *Server) opSetRepoCIPaused(ctx context.Context, user store.User, repo store.Repo, paused bool) error {
	role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
	if err != nil || !role.CanManageSettings() {
		return fail(403, i18n.E("err.forbidden"))
	}
	return s.Store.SetRepoCIPaused(ctx, repo.ID, paused)
}

// opSetReleaseVisibility zet inherit, private of public (alleen beheerders).
func (s *Server) opSetReleaseVisibility(ctx context.Context, user store.User, repo store.Repo, v string) error {
	role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
	if err != nil || !role.CanManageSettings() {
		return fail(403, i18n.E("err.forbidden"))
	}
	if err := s.Store.SetReleaseVisibility(ctx, repo.ID, v); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opDeleteRepo(ctx context.Context, user store.User, repo store.Repo, confirm string, force bool) error {
	role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
	if err != nil || !role.CanManageSettings() {
		return fail(403, i18n.E("err.forbidden"))
	}
	if confirm != repo.Name {
		return fail(400, i18n.E("err.confirmDelete"))
	}
	if prot, _ := s.Store.RunningProtectedJobs(ctx, repo.ID, 0); len(prot) > 0 && !force {
		return fail(409, i18n.E("err.dniRepoDelete", jobNames(prot)))
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if err := s.Store.DeleteRepo(ctx, repo.ID); err != nil {
		return fail(400, err)
	}
	_ = os.RemoveAll(dir)
	s.ReadCache().DropRepo(repo.ID)
	return nil
}

// opDeleteGroup verwijdert een lege groep. Alleen groepsbeheerders en
// admins; confirm is de groepsnaam of het pad. Een groep met repositories
// geeft 409 met het aantal; er is geen force.
func (s *Server) opDeleteGroup(ctx context.Context, user store.User, g store.Group, confirm string) error {
	if err := s.manageScope(ctx, user, "group", g.ID); err != nil {
		return err
	}
	if c := strings.TrimSpace(confirm); c == "" || (c != g.Name && c != g.Path) {
		return fail(400, i18n.E("err.confirmGroupDelete"))
	}
	if err := s.Store.DeleteGroup(ctx, g.ID); err != nil {
		var ne store.ErrGroupNotEmpty
		if errors.As(err, &ne) {
			return fail(409, i18n.E("err.groupNotEmpty", ne.Repos))
		}
		return fail(500, err)
	}
	return nil
}

func (s *Server) manageScope(ctx context.Context, user store.User, kind string, id int64) error {
	if kind == "group" {
		role, err := s.Store.GroupRole(ctx, id, user.ID)
		if err != nil || !role.AtLeast(access.RoleMaintainer) {
			return fail(403, i18n.E("err.forbidden"))
		}
		return nil
	}
	role, err := s.Store.EffectiveRole(ctx, user.ID, id)
	if err != nil || !role.CanManageSettings() {
		return fail(403, i18n.E("err.forbidden"))
	}
	return nil
}

func (s *Server) opSetMember(ctx context.Context, user store.User, kind string, id int64, username, roleName string) error {
	if err := s.manageScope(ctx, user, kind, id); err != nil {
		return err
	}
	role, err := access.ParseRole(roleName)
	if err != nil {
		return fail(400, err)
	}
	if err := s.Store.SetMember(ctx, kind, id, username, role); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opRemoveMember(ctx context.Context, user store.User, kind string, id int64, username string) error {
	if err := s.manageScope(ctx, user, kind, id); err != nil {
		return err
	}
	if err := s.Store.RemoveMember(ctx, kind, id, username); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opPutSecret(ctx context.Context, user store.User, kind string, id int64, name, value string, protected bool) error {
	if err := s.manageScope(ctx, user, kind, id); err != nil {
		return err
	}
	if err := s.Store.PutSecret(ctx, kind, id, strings.TrimSpace(name), value, protected); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opDeleteSecret(ctx context.Context, user store.User, kind string, id int64, name string) error {
	if err := s.manageScope(ctx, user, kind, id); err != nil {
		return err
	}
	_ = s.Store.DeleteSecret(ctx, kind, id, name)
	return nil
}

type hookIn struct {
	Name   string
	Preset string
	Filter string
	Events []string
	Fields webhook.Input
}

func (s *Server) opCreateWebhook(ctx context.Context, user store.User, kind string, id int64, in hookIn) (int64, error) {
	if err := s.manageScope(ctx, user, kind, id); err != nil {
		return 0, err
	}
	if !webhook.KnownPreset(in.Preset) {
		return 0, fail(400, i18n.E("err.preset"))
	}
	if _, err := webhook.MatchBranch(strings.TrimSpace(in.Filter), "main"); err != nil {
		return 0, fail(400, err)
	}
	if len(in.Events) == 0 {
		return 0, fail(400, i18n.E("err.pickEvent"))
	}
	spec, err := webhook.Prepare(in.Preset, in.Fields)
	if err != nil {
		return 0, fail(400, err)
	}
	wid, err := s.Store.CreateWebhook(ctx, store.Webhook{
		ScopeKind: kind, ScopeID: id, Name: strings.TrimSpace(in.Name),
		Preset: in.Preset, URLTemplate: spec.URL, Headers: spec.Headers,
		BodyTemplate: spec.Body, Events: in.Events, BranchFilter: strings.TrimSpace(in.Filter), Method: spec.Method,
	})
	if err != nil {
		return 0, fail(400, err)
	}
	return wid, nil
}

func (s *Server) opDeleteWebhook(ctx context.Context, user store.User, kind string, scopeID, id int64) error {
	if err := s.manageScope(ctx, user, kind, scopeID); err != nil {
		return err
	}
	_ = s.Store.DeleteWebhook(ctx, kind, scopeID, id)
	return nil
}

func (s *Server) opSaveRepoApproval(ctx context.Context, user store.User, repo store.Repo, pol store.ApprovalPolicy) error {
	if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {
		return err
	}
	_, groupPath, err := s.Store.EffectiveApproval(ctx, repo)
	if err != nil {
		return fail(400, err)
	}
	if groupPath != "" {
		return fail(400, i18n.E("appr.locked"))
	}
	if err := s.Store.SaveApproval(ctx, "repo", repo.ID, pol); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opSaveGroupApproval(ctx context.Context, user store.User, g store.Group, pol store.ApprovalPolicy) error {
	if err := s.manageScope(ctx, user, "group", g.ID); err != nil {
		return err
	}
	if err := s.Store.SaveApproval(ctx, "group", g.ID, pol); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opProtect(ctx context.Context, user store.User, repo store.Repo, pattern string, tag bool) error {
	if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {
		return err
	}
	var err error
	if tag {
		err = s.Store.AddProtectedTag(ctx, repo.ID, pattern)
	} else {
		err = s.Store.AddProtected(ctx, repo.ID, pattern)
	}
	if err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opUnprotect(ctx context.Context, user store.User, repo store.Repo, pattern string, tag bool) error {
	if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {
		return err
	}
	if tag {
		_ = s.Store.RemoveProtectedTag(ctx, repo.ID, pattern)
	} else {
		_ = s.Store.RemoveProtected(ctx, repo.ID, pattern)
	}
	return nil
}

func (s *Server) opToggleStar(ctx context.Context, user store.User, repo store.Repo) (bool, error) {
	role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
	if err != nil {
		return false, fail(500, err)
	}
	if user.ID == 0 || (!role.CanRead() && repo.Visibility != "public") {
		return false, fail(403, i18n.E("err.forbidden"))
	}
	_, mine, err := s.Store.StarInfo(ctx, user.ID, []int64{repo.ID})
	if err != nil {
		return false, fail(400, err)
	}
	on := !mine[repo.ID]
	if err := s.Store.SetStar(ctx, user.ID, repo.ID, on); err != nil {
		return false, fail(400, err)
	}
	return on, nil
}

func (s *Server) opSetStorage(path string) (state.Info, bool, error) {
	if s.StateDir == "" {
		return state.Info{}, false, fail(500, i18n.E("err.storageSave"))
	}
	info, err := state.Inspect(path)
	if err != nil {
		return state.Info{}, false, fail(400, err)
	}
	same, err := samePath(s.StateDir, info.Path)
	if err != nil {
		return state.Info{}, false, fail(400, err)
	}
	if same {
		return info, false, fail(400, i18n.E("err.storageSame"))
	}
	previous := s.StoragePath()
	if err := state.Write(s.StateDir, info.Path); err != nil {
		return state.Info{}, false, fail(500, err)
	}
	s.AdoptStorage(info.Path)
	s.RefreshHooks()
	return info, previous != "" && previous != info.Path, nil
}
