package server

import (
	"net/http"
	"os"
	"strconv"
	"strings"

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

func (s *Server) settings(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "Instellingen")
	v.Tab = r.URL.Query().Get("tab")
	if v.Tab == "" {
		v.Tab = "algemeen"
	}
	if role.CanManageSettings() {
		v.Members, _ = s.Store.ListMembers(r.Context(), "repo", repo.ID)
		if repo.OwnerKind == "user" {
			owner, err := s.Store.UserByID(r.Context(), repo.OwnerID)
			if err == nil {
				v.Members = append([]store.Member{{UserID: owner.ID, Username: owner.Username, Role: access.RoleMaintainer}}, v.Members...)
			}
		}
		v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID)
		v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID)
		v.Hooks = s.hookViews(r, "repo", repo.ID)
	}
	s.render(w, "settings", v)
}

func (s *Server) hookViews(r *http.Request, kind string, id int64) []HookView {
	hooks, err := s.Store.ListWebhooks(r.Context(), kind, id)
	if err != nil {
		return nil
	}
	var out []HookView
	for _, h := range hooks {
		d, _ := s.Store.RecentDeliveries(r.Context(), h.ID)
		out = append(out, HookView{
			ID: h.ID, Name: h.Name, Preset: h.Preset, URL: h.URLTemplate,
			Filter: h.BranchFilter, Events: strings.Join(h.Events, ", "), Deliveries: d,
		})
	}
	return out
}

func (s *Server) updateRepo(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	vis := r.FormValue("visibility")
	if vis != "public" {
		vis = "private"
	}
	if err := s.Store.UpdateRepo(r.Context(), repo.ID, r.FormValue("description"), vis); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings", "", err.Error())
		return
	}
	s.redirect(w, r, repoURL(repo)+"/-/settings", "Opgeslagen", "")
}

func (s *Server) repoMember(w http.ResponseWriter, r *http.Request) {
	s.memberPost(w, r, "repo")
}

func (s *Server) repoMemberRemove(w http.ResponseWriter, r *http.Request) {
	s.memberRemove(w, r, "repo")
}

func (s *Server) groupMember(w http.ResponseWriter, r *http.Request) {
	s.memberPost(w, r, "group")
}

func (s *Server) groupMemberRemove(w http.ResponseWriter, r *http.Request) {
	s.memberRemove(w, r, "group")
}

func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	role, err := access.ParseRole(r.FormValue("role"))
	if err != nil {
		s.redirect(w, r, back, "", err.Error())
		return
	}
	if err := s.Store.SetMember(r.Context(), kind, scopeID, r.FormValue("username"), role); err != nil {
		s.redirect(w, r, back, "", err.Error())
		return
	}
	s.redirect(w, r, back, "Lid opgeslagen", "")
}

func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.Store.RemoveMember(r.Context(), kind, scopeID, r.FormValue("username")); err != nil {
		s.redirect(w, r, back, "", err.Error())
		return
	}
	s.redirect(w, r, back, "Lid verwijderd", "")
}

func (s *Server) adminScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) {
	if kind == "group" {
		g, role, ok := s.guardGroup(w, r, access.RoleMaintainer)
		if !ok {
			return 0, "", false
		}
		_ = role
		return g.ID, "/groups/" + g.Path, true
	}
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok {
		return 0, "", false
	}
	return repo.ID, repoURL(repo) + "/-/settings?tab=leden", true
}

func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if err := s.Store.AddProtected(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {
		s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", err.Error())
		return
	}
	s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "Branch beschermd", "")
}

func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	_ = s.Store.RemoveProtected(r.Context(), repo.ID, r.FormValue("pattern"))
	s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "Patroon verwijderd", "")
}

func (s *Server) repoSecret(w http.ResponseWriter, r *http.Request) {
	s.secretPost(w, r, "repo")
}
func (s *Server) repoSecretDelete(w http.ResponseWriter, r *http.Request) {
	s.secretDelete(w, r, "repo")
}
func (s *Server) groupSecret(w http.ResponseWriter, r *http.Request) {
	s.secretPost(w, r, "group")
}
func (s *Server) groupSecretDelete(w http.ResponseWriter, r *http.Request) {
	s.secretDelete(w, r, "group")
}

func (s *Server) secretPost(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back = strings.Split(back, "?")[0]
	if kind == "repo" {
		back += "?tab=geheimen"
	}
	if err := s.Store.PutSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.FormValue("name")), r.FormValue("value"), r.FormValue("protected") == "1"); err != nil {
		s.redirect(w, r, back, "", err.Error())
		return
	}
	s.redirect(w, r, back, "Geheim opgeslagen", "")
}

func (s *Server) secretDelete(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back = strings.Split(back, "?")[0]
	if kind == "repo" {
		back += "?tab=geheimen"
	}
	_ = s.Store.DeleteSecret(r.Context(), kind, scopeID, r.FormValue("name"))
	s.redirect(w, r, back, "Geheim verwijderd", "")
}

func (s *Server) repoWebhook(w http.ResponseWriter, r *http.Request) { s.webhookPost(w, r, "repo") }
func (s *Server) repoWebhookDelete(w http.ResponseWriter, r *http.Request) {
	s.webhookDelete(w, r, "repo")
}
func (s *Server) groupWebhook(w http.ResponseWriter, r *http.Request) {
	s.webhookPost(w, r, "group")
}
func (s *Server) groupWebhookDelete(w http.ResponseWriter, r *http.Request) {
	s.webhookDelete(w, r, "group")
}

func (s *Server) webhookPost(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if kind == "repo" {
		back = strings.Split(back, "?")[0] + "?tab=webhooks"
	}
	preset := r.FormValue("preset")
	if preset != webhook.PresetDiscord && preset != webhook.PresetGrok && preset != webhook.PresetGeneric {
		s.redirect(w, r, back, "", "onbekende preset")
		return
	}
	filter := strings.TrimSpace(r.FormValue("branch_filter"))
	if _, err := webhook.MatchBranch(filter, "main"); err != nil {
		s.redirect(w, r, back, "", err.Error())
		return
	}
	var events []string
	for _, e := range webhook.AllEvents() {
		if r.FormValue("event_"+e) == "1" {
			events = append(events, e)
		}
	}
	if len(events) == 0 {
		s.redirect(w, r, back, "", "kies minstens één gebeurtenis")
		return
	}
	headers := map[string]string{}
	for _, line := range strings.Split(r.FormValue("headers"), "\n") {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}
		k, v, ok := strings.Cut(line, ":")
		if !ok || strings.TrimSpace(k) == "" {
			s.redirect(w, r, back, "", "header moet 'Naam: waarde' zijn")
			return
		}
		headers[strings.TrimSpace(k)] = strings.TrimSpace(v)
	}
	_, err := s.Store.CreateWebhook(r.Context(), store.Webhook{
		ScopeKind: kind, ScopeID: scopeID, Name: strings.TrimSpace(r.FormValue("name")),
		Preset: preset, URLTemplate: strings.TrimSpace(r.FormValue("url")),
		Headers: headers, BodyTemplate: r.FormValue("body"), Events: events, BranchFilter: filter,
	})
	if err != nil {
		s.redirect(w, r, back, "", err.Error())
		return
	}
	s.redirect(w, r, back, "Webhook opgeslagen", "")
}

func (s *Server) webhookDelete(w http.ResponseWriter, r *http.Request, kind string) {
	scopeID, back, ok := s.adminScope(w, r, kind)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if kind == "repo" {
		back = strings.Split(back, "?")[0] + "?tab=webhooks"
	}
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	_ = s.Store.DeleteWebhook(r.Context(), kind, scopeID, id)
	s.redirect(w, r, back, "Webhook verwijderd", "")
}

func (s *Server) deleteRepo(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if r.FormValue("confirm") != repo.Name {
		s.redirect(w, r, repoURL(repo)+"/-/settings", "", "typ de repositorynaam om te verwijderen")
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	_ = s.Store.DeleteRepo(r.Context(), repo.ID)
	_ = os.RemoveAll(dir)
	s.redirect(w, r, "/", "Repository verwijderd", "")
}

func (s *Server) guardGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, access.Role, bool) {
	g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
	if err != nil {
		http.NotFound(w, r)
		return store.Group{}, "", false
	}
	p := s.who(r)
	if !p.OK {
		http.Redirect(w, r, "/login", http.StatusFound)
		return store.Group{}, "", false
	}
	role, err := s.Store.GroupRole(r.Context(), g.ID, p.User.ID)
	if err != nil {
		http.Error(w, "rechten", http.StatusInternalServerError)
		return store.Group{}, "", false
	}
	if !role.AtLeast(min) && min != access.RoleReadonly {
		http.Error(w, "geen toegang", http.StatusForbidden)
		return store.Group{}, "", false
	}
	if min == access.RoleReadonly && !role.CanRead() {
		http.Error(w, "geen toegang", http.StatusForbidden)
		return store.Group{}, "", false
	}
	return g, role, true
}

func (s *Server) groupPage(w http.ResponseWriter, r *http.Request) {
	g, role, ok := s.guardGroup(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.view(w, r, g.Name)
	v.Group = &g
	v.Role = role
	v.CanAdmin = role.CanManageSettings()
	v.Repos, _ = s.Store.ReposByGroup(r.Context(), g.ID)
	if role.CanManageSettings() {
		v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID)
		v.Secrets, _ = s.Store.ListSecrets(r.Context(), "group", g.ID)
		v.Hooks = s.hookViews(r, "group", g.ID)
	}
	s.render(w, "group", v)
}
