package server

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

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

// userShort stuurt /<username> door naar /users/<username>.
// Het eerste paddeel is de gedeelde namespace van gebruikers en groepen
// (repositories staan op /<owner>/<repo>, groepen op /groups/<pad>).
// Vaste routes zoals /login blijven specifieker. Alleen een bestaande
// gebruiker krijgt een redirect; een groepsnaam of onbekende naam niet.
func (s *Server) userShort(w http.ResponseWriter, r *http.Request) {
	name := strings.ToLower(strings.TrimSpace(r.PathValue("name")))
	if names.ValidUsername(name) != nil {
		http.NotFound(w, r)
		return
	}
	if _, err := s.Store.UserByUsername(r.Context(), name); err != nil {
		http.NotFound(w, r)
		return
	}
	http.Redirect(w, r, "/users/"+name, http.StatusFound)
}

func (s *Server) profile(w http.ResponseWriter, r *http.Request) {
	name := strings.ToLower(strings.TrimSpace(r.PathValue("username")))
	u, err := s.Store.UserByUsername(r.Context(), name)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	v := s.view(w, r, u.Username)
	v.Profile = &u
	viewer := int64(0)
	if v.User != nil {
		viewer = v.User.ID
	}
	ids, err := s.Store.ListRepoIDs(r.Context(), viewer)
	if err != nil {
		ids = nil
	}
	v.Heat = s.heatmap(r.Context(), u.ID, ids, s.langOf(r))
	total := 0
	if v.Heat != nil {
		total = v.Heat.Total
	}
	card, repos, groups := s.profileCard(r, u, viewer, total)
	card.Heading = "h1"
	v.Card = &card
	v.Repos = repos
	v.Cards = s.repoCards(r.Context(), viewer, repos, s.langOf(r))
	v.Groups = groups
	s.render(w, "profile", v)
}

// profileCard bouwt het blok en de lijsten van iemands eigen repositories
// en groepen, beperkt tot wat de kijker mag zien.
func (s *Server) profileCard(r *http.Request, person store.User, viewer int64, contrib int) (ProfileCard, []store.Repo, []store.Group) {
	repos := s.ownedReposVisible(r.Context(), person.ID, viewer)
	groups := s.groupsVisible(r.Context(), person.ID, viewer)
	name := strings.TrimSpace(person.DisplayName)
	if name == "" {
		name = person.Username
	}
	card := ProfileCard{
		User: person, Name: name, Since: i18n.FormatDate(s.langOf(r), person.CreatedAt),
		Bio: strings.TrimSpace(person.Bio), URL: s.absURL("/users/" + person.Username),
		Repos: len(repos), Groups: len(groups), Contrib: contrib,
		Own: viewer != 0 && viewer == person.ID,
	}
	return card, repos, groups
}

func (s *Server) ownedReposVisible(ctx context.Context, owner, viewer int64) []store.Repo {
	all, err := s.Store.ReposByOwner(ctx, owner)
	if err != nil {
		return nil
	}
	allowed, err := s.Store.ListRepoIDs(ctx, viewer)
	if err != nil {
		return nil
	}
	set := map[int64]bool{}
	for _, id := range allowed {
		set[id] = true
	}
	var out []store.Repo
	for _, repo := range all {
		if set[repo.ID] {
			out = append(out, repo)
		}
	}
	return out
}

func (s *Server) groupsVisible(ctx context.Context, member, viewer int64) []store.Group {
	all, err := s.Store.ListGroups(ctx, member)
	if err != nil {
		return nil
	}
	var out []store.Group
	for _, g := range all {
		if g.Visibility == "public" {
			out = append(out, g)
			continue
		}
		if viewer == 0 {
			continue
		}
		role, err := s.Store.GroupRole(ctx, g.ID, viewer)
		if err == nil && role.CanRead() {
			out = append(out, g)
		}
	}
	return out
}

func (s *Server) presentCommits(ctx context.Context, repoID int64, in []gitrepo.Commit, lang i18n.Lang) []CommitRow {
	shas := make([]string, 0, len(in))
	for _, c := range in {
		if c.SHA != "" {
			shas = append(shas, c.SHA)
		}
	}
	pushers := map[string]store.Pusher{}
	if s.Store != nil && repoID != 0 && len(shas) > 0 {
		if got, err := s.Store.PushersBySHA(ctx, repoID, shas); err == nil {
			pushers = got
		}
	}
	cache := map[string]store.User{}
	miss := map[string]bool{}
	var rows []CommitRow
	for _, c := range in {
		rows = append(rows, s.oneCommit(ctx, c, pushers[c.SHA], lang, cache, miss))
	}
	return rows
}

func (s *Server) oneCommit(ctx context.Context, c gitrepo.Commit, pusher store.Pusher, lang i18n.Lang, cache map[string]store.User, miss map[string]bool) CommitRow {
	row := CommitRow{
		SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date,
		Subject: c.Subject, Body: c.Body, When: i18n.Ago(lang, c.Unix),
		Initial: initialOf(c.Author),
	}
	if u, ok := s.userForEmail(ctx, c.Email, cache, miss); ok {
		row.Author = u.Username
		row.Who = strings.TrimSpace(u.DisplayName)
		if row.Who == "" {
			row.Who = u.Username
		}
		row.WhoURL = "/users/" + u.Username
		row.UserURL = row.WhoURL
		row.Avatar = u.AvatarURL
		row.Initial = initialOf(u.Username)
		return finishCommit(row, c.Email, c.Author)
	}
	if pusher.UserID != 0 && pusher.Username != "" {
		row.Author = pusher.Username
		row.UserURL = "/users/" + pusher.Username
		row.Avatar = pusher.AvatarURL
		row.Initial = initialOf(pusher.Username)
		raw := strings.TrimSpace(c.Author)
		if raw != "" && !strings.EqualFold(raw, pusher.Username) {
			row.RawName = raw
			row.PushedBy = pusher.Username
		}
	}
	return finishCommit(row, c.Email, c.Author)
}

func (s *Server) userForEmail(ctx context.Context, email string, cache map[string]store.User, miss map[string]bool) (store.User, bool) {
	if s.Store == nil {
		return store.User{}, false
	}
	key := strings.ToLower(strings.TrimSpace(email))
	if u, ok := cache[key]; ok {
		return u, true
	}
	if miss[key] {
		return store.User{}, false
	}
	u, ok := s.Store.UserByGitEmail(ctx, email)
	if !ok {
		miss[key] = true
		return store.User{}, false
	}
	cache[key] = u
	return u, true
}

// tileHue kiest een vaste kleurklasse bij een naam, zodat dezelfde
// repo of groep steeds hetzelfde vierkantje krijgt.
func tileHue(name string) string {
	n := 0
	for _, r := range strings.ToLower(strings.TrimSpace(name)) {
		n = n*33 + int(r)
	}
	if n < 0 {
		n = -n
	}
	return "hue" + string(rune('0'+(n%8)))
}

func initialOf(s string) string {
	s = strings.TrimSpace(s)
	if s == "" {
		return "?"
	}
	r, _ := utf8.DecodeRuneInString(s)
	return strings.ToUpper(string(r))
}

// trimSlash stuurt een pagina-URL met afsluitende slash permanent door naar
// dezelfde URL zonder slash (querystring blijft behouden).
func (s *Server) trimSlash(w http.ResponseWriter, r *http.Request) {
	target := strings.TrimRight(r.URL.Path, "/")
	if target == "" {
		target = "/"
	}
	if r.URL.RawQuery != "" {
		target += "?" + r.URL.RawQuery
	}
	http.Redirect(w, r, target, http.StatusMovedPermanently)
}
