package server

import (
	"encoding/json"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"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/store"
	"gitlab.com/Timfa/bluegit/internal/webhook"
)

type releaseRequest struct {
	Tag    string `json:"tag"`
	Commit string `json:"commit"`
	Name   string `json:"name"`
	Body   string `json:"body"`
	Assets []struct {
		Job  string `json:"job"`
		Path string `json:"path"`
		Name string `json:"name"`
	} `json:"assets"`
}

func (s *Server) createRelease(w http.ResponseWriter, r *http.Request) {
	if s.StoragePath() == "" {
		http.Error(w, s.noStorageText(r), http.StatusServiceUnavailable)
		return
	}
	repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
	if err != nil {
		http.NotFound(w, r)
		return
	}
	token := bearer(r)
	var job store.Job
	var author int64
	var actor store.User
	if strings.HasPrefix(token, "bgj_") {
		job, err = s.Store.JobByToken(r.Context(), token)
		if err != nil || job.RepoID != repo.ID || job.Status != "running" {
			http.Error(w, s.tr(r, "err.jobToken"), http.StatusUnauthorized)
			return
		}
	} else if strings.HasPrefix(token, "bg_") {
		u, err := s.Store.UserByToken(r.Context(), token)
		if err != nil {
			http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
			return
		}
		role, err := s.Store.EffectiveRole(r.Context(), u.ID, repo.ID)
		if err != nil || !role.AtLeast(access.RoleMaintainer) {
			http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
			return
		}
		author = u.ID
		actor = u
	} else {
		http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized)
		return
	}
	var req releaseRequest
	if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&req); err != nil {
		http.Error(w, s.tr(r, "err.json"), http.StatusBadRequest)
		return
	}
	if err := names.ValidTag(req.Tag); err != nil {
		http.Error(w, s.trErr(r, err), http.StatusBadRequest)
		return
	}
	if !safeSHA(req.Commit) {
		http.Error(w, s.tr(r, "err.commitAbsent"), http.StatusBadRequest)
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if !gitrepo.HasCommit(r.Context(), s.Git, dir, req.Commit) {
		http.Error(w, s.tr(r, "err.commitMissing"), http.StatusBadRequest)
		return
	}
	if req.Name == "" {
		req.Name = req.Tag
	}
	if job.ID == 0 && len(req.Assets) > 0 {
		http.Error(w, s.tr(r, "err.assetsJob"), http.StatusBadRequest)
		return
	}
	var assets []store.ReleaseAsset
	for _, a := range req.Assets {
		if a.Name == "" {
			a.Name = filepath.Base(a.Path)
		}
		if err := names.ValidRepoName(strings.ReplaceAll(a.Name, ".", "x")); err != nil && strings.Contains(a.Name, "..") {
			http.Error(w, s.tr(r, "err.assetName"), http.StatusBadRequest)
			return
		}
		if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" {
			http.Error(w, s.tr(r, "err.assetName"), http.StatusBadRequest)
			return
		}
		src, err := s.Store.ArtifactPath(r.Context(), job.PipelineID, a.Job, a.Path)
		if err != nil {
			http.Error(w, s.tr(r, "err.artifactMissing", a.Job, a.Path), http.StatusBadRequest)
			return
		}
		info, err := os.Stat(src)
		if err != nil {
			http.Error(w, s.tr(r, "err.assetDisk"), http.StatusBadRequest)
			return
		}
		dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name)
		if err := copyRelease(src, dst); err != nil {
			http.Error(w, s.tr(r, "err.assetCopy"), http.StatusInternalServerError)
			return
		}
		assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: info.Size()})
	}
	if err := s.postReceive(r.Context(), repo, actor, dir, func() error {
		return gitrepo.Tag(r.Context(), s.Git, dir, req.Tag, req.Commit, req.Name)
	}); err != nil {
		http.Error(w, s.tr(r, "err.tagFail", err.Error()), http.StatusBadRequest)
		return
	}
	id, err := s.Store.CreateRelease(r.Context(), repo.ID, req.Tag, req.Commit, req.Name, req.Body, author, job.ID, assets)
	if err != nil {
		http.Error(w, s.trErr(r, err), http.StatusBadRequest)
		return
	}
	s.Dispatch(repo.ID, webhook.Event{
		Type: webhook.EventRelease, Project: repo.FullPath(), Commit: req.Commit,
		ReleaseTag: req.Tag, Summary: i18n.T(i18n.EN, "hook.release", req.Tag, repo.FullPath()),
		URL: strings.TrimRight(s.Cfg.BaseURL, "/") + repoURL(repo) + "/-/releases",
	})
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	_ = json.NewEncoder(w).Encode(map[string]any{"id": id, "tag": req.Tag, "commit": req.Commit})
}

func (s *Server) releaseAsset(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	rel, err := s.Store.ReleaseByTag(r.Context(), repo.ID, r.PathValue("tag"))
	if err != nil {
		http.NotFound(w, r)
		return
	}
	name := r.PathValue("name")
	for _, a := range rel.Assets {
		if a.Name == name {
			w.Header().Set("Content-Disposition", "attachment; filename=\""+strings.ReplaceAll(name, "\"", "")+"\"")
			http.ServeFile(w, r, a.StoragePath)
			return
		}
	}
	http.NotFound(w, r)
}

func bearer(r *http.Request) string {
	h := r.Header.Get("Authorization")
	if strings.HasPrefix(strings.ToLower(h), "bearer ") {
		return strings.TrimSpace(h[7:])
	}
	return ""
}

func copyRelease(src, dst string) error {
	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
		return err
	}
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()
	out, err := os.OpenFile(dst, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
	if err != nil {
		return err
	}
	defer out.Close()
	_, err = io.Copy(out, in)
	return err
}
