package server

import (
	"context"
	"encoding/json"
	"net/http"
	"regexp"
	"sort"
	"strconv"
	"strings"

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

// Webhooks aanpassen en kopiëren. Geheimen blijven server-side: het
// token-veld is de naam van een geheim, en bij kopiëren gaan ontbrekende
// geheimen versleuteld mee naar het doel. Waarden komen nooit in een respons.

func hookID(r *http.Request) (int64, error) {
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil || id <= 0 {
		return 0, fail(404, i18n.E("err.notFound"))
	}
	return id, nil
}

// inputOf geeft de opgeslagen invoer van een webhook terug.
func inputOf(h store.Webhook) webhook.Input {
	d := draftFrom(h)
	return webhook.Input{
		URL: d.URL, Username: d.Username, Avatar: d.Avatar, Icon: d.Icon, Alias: d.Alias,
		Token: d.Token, Chat: d.Chat, Server: d.Server, Topic: d.Topic,
		Homeserver: d.Home, Room: d.Room, Method: d.Method, ContentType: d.CType,
		Headers: d.Headers, Body: d.Body,
	}
}

// opPatchWebhook werkt alleen de meegestuurde velden bij. Een leeg of
// weggelaten token houdt het bestaande geheim.
func (s *Server) opPatchWebhook(ctx context.Context, user store.User, kind string, scopeID, id int64, raw map[string]json.RawMessage) (store.Webhook, error) {
	if err := s.manageScope(ctx, user, kind, scopeID); err != nil {
		return store.Webhook{}, err
	}
	h, err := s.Store.Webhook(ctx, kind, scopeID, id)
	if err != nil {
		return store.Webhook{}, fail(404, i18n.E("err.notFound"))
	}
	in := inputOf(h)
	name, preset, filter, events := h.Name, h.Preset, h.BranchFilter, h.Events
	str := func(key string, dst *string, keepEmpty bool) error {
		v, ok := raw[key]
		if !ok {
			return nil
		}
		var sv string
		if err := json.Unmarshal(v, &sv); err != nil {
			return fail(400, i18n.E("err.json"))
		}
		if keepEmpty && strings.TrimSpace(sv) == "" {
			return nil
		}
		*dst = sv
		return nil
	}
	fields := []struct {
		key  string
		dst  *string
		keep bool
	}{
		{"name", &name, true}, {"preset", &preset, true}, {"branch_filter", &filter, false},
		{"url", &in.URL, true}, {"username", &in.Username, false}, {"avatar", &in.Avatar, false},
		{"icon", &in.Icon, false}, {"alias", &in.Alias, false}, {"token", &in.Token, true},
		{"chat", &in.Chat, false}, {"server", &in.Server, false}, {"topic", &in.Topic, false},
		{"homeserver", &in.Homeserver, false}, {"room", &in.Room, false}, {"method", &in.Method, true},
		{"content_type", &in.ContentType, false}, {"headers", &in.Headers, true}, {"body", &in.Body, false},
	}
	for _, f := range fields {
		if err := str(f.key, f.dst, f.keep); err != nil {
			return store.Webhook{}, err
		}
	}
	if v, ok := raw["events"]; ok {
		var ev []string
		if err := json.Unmarshal(v, &ev); err != nil {
			return store.Webhook{}, fail(400, i18n.E("err.json"))
		}
		events = ev
	}
	if _, err := s.saveWebhookRecord(ctx, kind, scopeID, id, strings.TrimSpace(name), preset, filter, events, in); err != nil {
		if store.Missing(err) {
			return store.Webhook{}, fail(404, i18n.E("err.notFound"))
		}
		return store.Webhook{}, fail(400, err)
	}
	if v, ok := raw["active"]; ok {
		var on bool
		if json.Unmarshal(v, &on) == nil {
			_ = s.Store.SetWebhookActive(ctx, kind, scopeID, id, on)
		}
	}
	return s.Store.Webhook(ctx, kind, scopeID, id)
}

var secretRefRe = regexp.MustCompile(`\{\{\s*secret\.([A-Za-z_][A-Za-z0-9_]*)\s*\}\}`)

// hookSecretRefs geeft de geheimnamen die een webhook gebruikt.
func hookSecretRefs(h store.Webhook) []string {
	seen := map[string]bool{}
	add := func(s string) {
		for _, m := range secretRefRe.FindAllStringSubmatch(s, -1) {
			seen[m[1]] = true
		}
	}
	add(h.URLTemplate)
	add(h.BodyTemplate)
	for k, v := range h.Headers {
		add(k)
		add(v)
	}
	out := make([]string, 0, len(seen))
	for k := range seen {
		out = append(out, k)
	}
	sort.Strings(out)
	return out
}

type scopeRef struct {
	Kind string
	ID   int64
}

// secretScopes geeft de scopes waaruit een webhook geheimen leest, eigen scope eerst.
func (s *Server) secretScopes(ctx context.Context, kind string, id int64) []scopeRef {
	out := []scopeRef{{kind, id}}
	if kind == "repo" {
		if repo, err := s.Store.RepoByID(ctx, id); err == nil && repo.OwnerKind == "group" {
			out = append(out, scopeRef{"group", repo.OwnerID})
		}
	}
	return out
}

func (s *Server) secretNames(ctx context.Context, sc scopeRef) map[string]bool {
	out := map[string]bool{}
	list, _ := s.Store.ListSecrets(ctx, sc.Kind, sc.ID)
	for _, m := range list {
		out[m.Name] = true
	}
	return out
}

// CopyTarget is het doel van een kopie.
type CopyTarget struct {
	Type   string   `json:"target_type"` // project of group
	Target string   `json:"target"`      // eigenaar/project of groepspad
	Name   string   `json:"name"`
	Events []string `json:"events"`
}

// HookCopyResult vertelt wat er gekopieerd is, zonder waarden.
type HookCopyResult struct {
	Hook           store.Webhook
	CopiedSecrets  []string
	MissingSecrets []string
}

func (s *Server) resolveTarget(ctx context.Context, t CopyTarget) (string, int64, error) {
	path := strings.Trim(strings.TrimSpace(t.Target), "/")
	switch strings.ToLower(strings.TrimSpace(t.Type)) {
	case "project", "repo":
		i := strings.LastIndex(path, "/")
		if i <= 0 {
			return "", 0, fail(404, i18n.E("err.notFound"))
		}
		repo, err := s.Store.RepoByPath(ctx, path[:i], path[i+1:])
		if err != nil {
			return "", 0, fail(404, i18n.E("err.notFound"))
		}
		return "repo", repo.ID, nil
	case "group":
		g, err := s.Store.GroupByPath(ctx, path)
		if err != nil {
			return "", 0, fail(404, i18n.E("err.notFound"))
		}
		return "group", g.ID, nil
	}
	return "", 0, fail(400, i18n.E("err.scope"))
}

// opCopyWebhook kopieert een webhook met geheimen naar een ander project of
// een andere groep. Beide scopes vragen beheerrechten.
func (s *Server) opCopyWebhook(ctx context.Context, user store.User, kind string, scopeID, id int64, t CopyTarget) (HookCopyResult, error) {
	if err := s.manageScope(ctx, user, kind, scopeID); err != nil {
		return HookCopyResult{}, err
	}
	h, err := s.Store.Webhook(ctx, kind, scopeID, id)
	if err != nil {
		return HookCopyResult{}, fail(404, i18n.E("err.notFound"))
	}
	tKind, tID, err := s.resolveTarget(ctx, t)
	if err != nil {
		return HookCopyResult{}, err
	}
	if err := s.manageScope(ctx, user, tKind, tID); err != nil {
		if oe, ok := err.(*opError); ok && oe.status == 403 {
			return HookCopyResult{}, fail(404, i18n.E("err.notFound"))
		}
		return HookCopyResult{}, err
	}
	if tKind == kind && tID == scopeID && strings.TrimSpace(t.Name) == "" {
		t.Name = h.Name + " (2)"
	}
	nh := h
	nh.ID, nh.ScopeKind, nh.ScopeID = 0, tKind, tID
	if n := strings.TrimSpace(t.Name); n != "" {
		nh.Name = n
	}
	if t.Events != nil {
		if len(t.Events) == 0 {
			return HookCopyResult{}, fail(400, i18n.E("err.pickEvent"))
		}
		nh.Events = t.Events
	}
	var res HookCopyResult
	src := s.secretScopes(ctx, kind, scopeID)
	dst := s.secretScopes(ctx, tKind, tID)
	srcNames := make([]map[string]bool, len(src))
	for i, sc := range src {
		srcNames[i] = s.secretNames(ctx, sc)
	}
	dstNames := map[string]bool{}
	for _, sc := range dst {
		for k := range s.secretNames(ctx, sc) {
			dstNames[k] = true
		}
	}
	type plan struct {
		from scopeRef
		name string
	}
	var todo []plan
	for _, name := range hookSecretRefs(h) {
		if dstNames[name] {
			continue
		}
		found := false
		for i, sc := range src {
			if srcNames[i][name] {
				todo = append(todo, plan{sc, name})
				found = true
				break
			}
		}
		if !found {
			res.MissingSecrets = append(res.MissingSecrets, name)
		}
	}
	for _, p := range todo {
		if err := s.Store.CopySecret(ctx, p.from.Kind, p.from.ID, p.name, tKind, tID); err != nil {
			return HookCopyResult{}, fail(400, err)
		}
		res.CopiedSecrets = append(res.CopiedSecrets, p.name)
	}
	nid, err := s.Store.CreateWebhook(ctx, nh)
	if err != nil {
		return HookCopyResult{}, fail(400, err)
	}
	if !h.Active {
		_ = s.Store.SetWebhookActive(ctx, tKind, tID, nid, false)
	}
	res.Hook, err = s.Store.Webhook(ctx, tKind, tID, nid)
	if err != nil {
		return HookCopyResult{}, fail(500, err)
	}
	return res, nil
}

// --- API ---

func (s *Server) apiPatchHook(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) {
	id, err := hookID(r)
	if !s.apiOK(w, r, err) {
		return
	}
	raw := map[string]json.RawMessage{}
	if err := readJSON(r, &raw); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	h, err := s.opPatchWebhook(r.Context(), apiUser(r), kind, scopeID, id, raw)
	if !s.apiOK(w, r, err) {
		return
	}
	writeJSON(w, http.StatusOK, hookJSON(h))
}

func (s *Server) apiCopyHook(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) {
	id, err := hookID(r)
	if !s.apiOK(w, r, err) {
		return
	}
	var t CopyTarget
	if err := readJSON(r, &t); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	res, err := s.opCopyWebhook(r.Context(), apiUser(r), kind, scopeID, id, t)
	if !s.apiOK(w, r, err) {
		return
	}
	out := hookJSON(res.Hook)
	out["scope"] = res.Hook.ScopeKind
	out["copied_secrets"] = hookNames(res.CopiedSecrets)
	out["missing_secrets"] = hookNames(res.MissingSecrets)
	writeJSON(w, http.StatusCreated, out)
}

func hookNames(in []string) []string {
	if in == nil {
		return []string{}
	}
	return in
}

func (s *Server) apiPatchGroupHook(w http.ResponseWriter, r *http.Request) {
	g, ok := s.apiGroup(w, r, access.RoleMaintainer)
	if !ok {
		return
	}
	s.apiPatchHook(w, r, "group", g.ID)
}

func (s *Server) apiPatchProjectHook(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
	if !ok {
		return
	}
	s.apiPatchHook(w, r, "repo", repo.ID)
}

func (s *Server) apiCopyGroupHook(w http.ResponseWriter, r *http.Request) {
	g, ok := s.apiGroup(w, r, access.RoleMaintainer)
	if !ok {
		return
	}
	s.apiCopyHook(w, r, "group", g.ID)
}

func (s *Server) apiCopyProjectHook(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
	if !ok {
		return
	}
	s.apiCopyHook(w, r, "repo", repo.ID)
}

// --- UI ---

// HookTarget is een keuze in het kopieervenster.
type HookTarget struct {
	Value string
	Label string
	Group bool
}

// hookTargets geeft projecten en groepen die deze gebruiker beheert.
func (s *Server) hookTargets(r *http.Request) []HookTarget {
	p := s.who(r)
	if !p.OK {
		return nil
	}
	ctx := r.Context()
	var out []HookTarget
	groups, _ := s.Store.ListGroups(ctx, p.User.ID)
	for _, g := range groups {
		if s.manageScope(ctx, p.User, "group", g.ID) == nil {
			out = append(out, HookTarget{Value: "group:" + g.Path, Label: g.Path, Group: true})
		}
	}
	ids, _ := s.Store.ListRepoIDs(ctx, p.User.ID)
	var repos []HookTarget
	for _, id := range ids {
		if s.manageScope(ctx, p.User, "repo", id) != nil {
			continue
		}
		repo, err := s.Store.RepoByID(ctx, id)
		if err != nil {
			continue
		}
		repos = append(repos, HookTarget{Value: "project:" + repo.FullPath(), Label: repo.FullPath()})
	}
	sort.Slice(repos, func(i, j int) bool { return repos[i].Label < repos[j].Label })
	return append(out, repos...)
}

func (s *Server) repoWebhookCopy(w http.ResponseWriter, r *http.Request) { s.webhookCopy(w, r, "repo") }
func (s *Server) groupWebhookCopy(w http.ResponseWriter, r *http.Request) {
	s.webhookCopy(w, r, "group")
}

func (s *Server) webhookCopy(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] + scopeTab(kind, "webhooks")
	if kind == "group" {
		back += "#webhooks"
	}
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	typ, target, _ := strings.Cut(r.FormValue("target"), ":")
	res, err := s.opCopyWebhook(r.Context(), s.who(r).User, kind, scopeID, id, CopyTarget{Type: typ, Target: target, Name: r.FormValue("name")})
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	msg := s.tr(r, "flash.webhookCopied", target)
	if len(res.MissingSecrets) > 0 {
		msg += " " + s.tr(r, "wh.copyMissing", strings.Join(res.MissingSecrets, ", "))
	}
	s.redirect(w, r, back, msg, "")
}
