package server

import (
	"context"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"strings"

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

// releaseAdmin: alleen eigenaar/maintainer van de repo of een instance-admin
// mag releases en assets verwijderen.
func (s *Server) releaseAdmin(ctx context.Context, user store.User, repo store.Repo) error {
	if user.ID == 0 {
		return fail(401, i18n.E("err.apiAuth"))
	}
	if user.InstanceAdmin {
		return nil
	}
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return err
	}
	if !canSeeReleases(repo, role) {
		return fail(404, i18n.E("err.notFound"))
	}
	if !role.AtLeast(access.RoleMaintainer) {
		return fail(403, i18n.E("err.forbidden"))
	}
	return nil
}

// removeAssetFile ruimt een assetbestand op, alleen binnen de opslag, en
// daarna de lege map erboven.
func (s *Server) removeAssetFile(path string) {
	root := s.StoragePath()
	if path == "" || root == "" {
		return
	}
	abs, err := filepath.Abs(path)
	if err != nil {
		return
	}
	rootAbs, _ := filepath.Abs(root)
	if !strings.HasPrefix(abs, rootAbs+string(os.PathSeparator)) {
		return
	}
	_ = os.Remove(abs)
	_ = os.Remove(filepath.Dir(abs)) // alleen als leeg
}

func (s *Server) opDeleteReleaseAsset(ctx context.Context, user store.User, repo store.Repo, tag, name string) error {
	if err := s.releaseAdmin(ctx, user, repo); err != nil {
		return err
	}
	rel, err := s.Store.ReleaseByTag(ctx, repo.ID, tag)
	if err != nil {
		return notFound(err)
	}
	path, err := s.Store.DeleteReleaseAsset(ctx, rel.ID, name)
	if err != nil {
		return notFound(err)
	}
	s.removeAssetFile(path)
	return nil
}

func (s *Server) opDeleteRelease(ctx context.Context, user store.User, repo store.Repo, tag string, deleteTag bool) error {
	if err := s.releaseAdmin(ctx, user, repo); err != nil {
		return err
	}
	rel, err := s.Store.ReleaseByTag(ctx, repo.ID, tag)
	if err != nil {
		return notFound(err)
	}
	paths, err := s.Store.DeleteRelease(ctx, rel.ID)
	if err != nil {
		return fail(500, err)
	}
	for _, p := range paths {
		s.removeAssetFile(p)
	}
	if deleteTag {
		return s.opDeleteTag(ctx, user, repo, tag)
	}
	return nil
}

func (s *Server) apiRepoForDelete(w http.ResponseWriter, r *http.Request) (store.Repo, bool) {
	repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
	if err != nil {
		s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
		return store.Repo{}, false
	}
	return repo, true
}

func (s *Server) apiDeleteReleaseAsset(w http.ResponseWriter, r *http.Request) {
	repo, ok := s.apiRepoForDelete(w, r)
	if !ok {
		return
	}
	if !s.apiOK(w, r, s.opDeleteReleaseAsset(r.Context(), apiUser(r), repo, r.PathValue("tag"), r.PathValue("name"))) {
		return
	}
	writeJSON(w, http.StatusNoContent, nil)
}

func (s *Server) apiDeleteRelease(w http.ResponseWriter, r *http.Request) {
	repo, ok := s.apiRepoForDelete(w, r)
	if !ok {
		return
	}
	del := r.URL.Query().Get("delete_tag") == "true"
	if !s.apiOK(w, r, s.opDeleteRelease(r.Context(), apiUser(r), repo, r.PathValue("tag"), del)) {
		return
	}
	writeJSON(w, http.StatusNoContent, nil)
}

// UI: POST-formulieren met eigen bevestigingsmodal (data-confirm).
func (s *Server) uiDeleteReleaseAsset(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guardReleases(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back := repoURL(repo) + "/-/releases"
	if !s.uiOK(w, r, back, s.opDeleteReleaseAsset(r.Context(), u, repo, r.PathValue("tag"), r.PathValue("name"))) {
		return
	}
	s.redirect(w, r, back+"#"+url.PathEscape(r.PathValue("tag")), s.tr(r, "rel.assetDeleted"), "")
}

func (s *Server) uiDeleteRelease(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guardReleases(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back := repoURL(repo) + "/-/releases"
	if !s.uiOK(w, r, back, s.opDeleteRelease(r.Context(), u, repo, r.PathValue("tag"), r.FormValue("delete_tag") == "1")) {
		return
	}
	s.redirect(w, r, back, s.tr(r, "rel.deleted"), "")
}
