package server

import (
	"net/http"
	"strings"
	"unicode/utf8"

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

// Zichtbaarheid van releases staat los van die van de code:
//
//   - inherit: releases volgen de repo.
//   - private: releases alleen voor leden, ook als de code publiek is.
//   - public: releases (pagina, notities, assets) voor iedereen, ook als
//     de code privé is. Niet-leden zien dan alleen naam, korte
//     beschrijving en de Releases-pagina. Code, archieven, clone, raw,
//     commits, issues, MR's, pipelines, logs en artefacten blijven privé:
//     die routes gebruiken guard/apiRepo, die alleen op repo.Visibility
//     en lidmaatschap letten.

// canSeeReleases: lid, of releases publiek.
func canSeeReleases(repo store.Repo, role access.Role) bool {
	return role.CanRead() || repo.ReleasesPublic()
}

// releaseOnly: de kijker ziet van deze repo alleen de releases.
func releaseOnly(repo store.Repo, role access.Role) bool {
	return !role.CanRead() && repo.Visibility != "public" && repo.ReleasesPublic()
}

// shortDesc kort de beschrijving in voor overzichten van release-only repo's.
func shortDesc(s string) string {
	s = strings.TrimSpace(strings.SplitN(s, "\n", 2)[0])
	if utf8.RuneCountInString(s) > 140 {
		s = string([]rune(s)[:139]) + "…"
	}
	return s
}

// releaseOnlyCard is wat een niet-lid van een privé repo met publieke
// releases in overzichten ziet: naam, korte beschrijving, verder niets.
func releaseOnlyCard(r store.Repo) store.Repo {
	return store.Repo{ID: r.ID, OwnerKind: r.OwnerKind, OwnerPath: r.OwnerPath, Name: r.Name,
		Description: shortDesc(r.Description), Visibility: r.Visibility, ReleaseVisibility: r.ReleaseVisibility, LogoMIME: r.LogoMIME}
}

func (s *Server) releaseOnlyRepos(r *http.Request, viewer int64) []store.Repo {
	ids, err := s.Store.ListReleaseOnlyRepoIDs(r.Context(), viewer)
	if err != nil {
		return nil
	}
	repos, err := s.Store.ReposByIDs(r.Context(), ids)
	if err != nil {
		return nil
	}
	out := make([]store.Repo, 0, len(repos))
	for _, repo := range repos {
		out = append(out, releaseOnlyCard(repo))
	}
	return out
}

// repoRoleOf geeft de rol van de kijker (web), met crawlers als anoniem.
func (s *Server) webRole(r *http.Request, repo store.Repo) (principal, access.Role, error) {
	p := s.who(r)
	var role access.Role
	if p.OK {
		var err error
		role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
		if err != nil {
			return p, role, err
		}
	}
	if isCrawler(r) {
		return principal{}, access.RoleNone, nil
	}
	return p, role, nil
}

// guardReleases is guard voor de Releases-pagina en assets.
func (s *Server) guardReleases(w http.ResponseWriter, r *http.Request) (store.User, store.Repo, access.Role, bool) {
	repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
	if err != nil {
		http.NotFound(w, r)
		return store.User{}, store.Repo{}, "", false
	}
	p, role, err := s.webRole(r, repo)
	if err != nil {
		http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
		return store.User{}, store.Repo{}, "", false
	}
	if !canSeeReleases(repo, role) {
		if isCrawler(r) {
			s.writeLockedCard(w, r)
		} else if p.OK {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		} else {
			http.NotFound(w, r)
		}
		return store.User{}, store.Repo{}, "", false
	}
	return p.User, repo, role, true
}

// apiRepoReleases is apiRepo voor de release-API (lijst en assets).
func (s *Server) apiRepoReleases(w http.ResponseWriter, r *http.Request) (store.Repo, access.Role, 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
	}
	role, err := s.Store.EffectiveRole(r.Context(), apiUser(r).ID, repo.ID)
	if err != nil {
		s.writeAPIErr(w, r, fail(500, err))
		return store.Repo{}, "", false
	}
	if !canSeeReleases(repo, role) {
		s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
		return store.Repo{}, "", false
	}
	return repo, role, true
}

// releasesSlash: /-/releases/ gaat naar /-/releases, met dezelfde toegang (anders 404).
func (s *Server) releasesSlash(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guardReleases(w, r)
	if !ok {
		return
	}
	http.Redirect(w, r, "/"+repo.FullPath()+"/-/releases", http.StatusSeeOther)
}
