// Package webhook filtert gebeurtenissen en vult URL, headers en body.
package webhook

import (
	"encoding/json"
	"regexp"
	"strings"

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

// Soorten gebeurtenissen.
const (
	EventPush            = "push"
	EventMergeRequest    = "merge_request"
	EventPipelineSuccess = "pipeline_success"
	EventPipelineFailure = "pipeline_failure"
	EventRelease         = "release_published"
	EventIssue           = "issue"

	// Fijnere events. Een hook met "issue" of "merge_request" krijgt ze ook.
	EventIssueOpened   = "issue_opened"
	EventIssueClosed   = "issue_closed"
	EventIssueReopened = "issue_reopened"
	EventIssueUpdated  = "issue_updated"
	EventIssueComment  = "issue_comment"
	EventMRComment     = "merge_request_comment"
)

// AllEvents is de vaste lijst die een webhook mag aanvinken.
func AllEvents() []string {
	return []string{EventPush, EventMergeRequest, EventPipelineSuccess, EventPipelineFailure, EventRelease, EventIssue,
		EventIssueOpened, EventIssueClosed, EventIssueReopened, EventIssueUpdated, EventIssueComment, EventMRComment}
}

// SpecificEvents zijn de fijnere events die bij issue en merge_request horen.
func SpecificEvents() []string {
	return []string{EventIssueOpened, EventIssueClosed, EventIssueReopened, EventIssueUpdated, EventIssueComment, EventMRComment}
}

// Specific geeft de fijnere eventnaam van ev, of "" als die er niet is.
func Specific(ev Event) string {
	switch ev.Type {
	case EventIssue:
		if ev.Issue == nil {
			return ""
		}
		switch ev.Issue.Action {
		case "opened":
			return EventIssueOpened
		case "closed":
			return EventIssueClosed
		case "reopened":
			return EventIssueReopened
		case "updated":
			return EventIssueUpdated
		case "commented":
			return EventIssueComment
		}
	case EventMergeRequest:
		if ev.MergeRequest != nil && ev.MergeRequest.Action == "commented" {
			return EventMRComment
		}
	}
	return ""
}

// KnownEvent meldt of name een ondersteunde gebeurtenis is.
func KnownEvent(name string) bool {
	for _, e := range AllEvents() {
		if e == name {
			return true
		}
	}
	return false
}

// Presets.
const (
	PresetDiscord = "discord"
	PresetGrok    = "grok"
	PresetGeneric = "generic"
)

// Event is de gegevensset die een webhook te zien krijgt.
// De platte velden blijven beschikbaar als {{event.veld}}.
// Pipeline, Jobs, Ref/Before/After/Commits, MergeRequest en Release
// vullen de JSON-body als het sjabloon leeg is.
type Event struct {
	Type       string
	Project    string
	Group      string
	Branch     string
	Commit     string
	Summary    string
	URL        string
	PipelineID string
	ReleaseTag string
	Actor      string

	Pipeline     *PipelineInfo
	Jobs         []JobInfo
	Ref          string
	Before       string
	After        string
	Commits      []CommitInfo
	MergeRequest *MRInfo
	Comment      string
	Release      *ReleaseInfo
	Issue        *IssueInfo
}

// Hook is de opgeslagen configuratie, zonder geheimen al ingevuld.
type Hook struct {
	Preset       string
	Events       []string
	BranchFilter string
}

// Allows meldt of deze hook de gebeurtenis wil ontvangen.
// Het branchfilter geldt alleen voor push. Leeg betekent alle branches.
// "re:" gevolgd door een reguliere expressie, anders een exacte branchnaam.
func Allows(h Hook, ev Event) (bool, error) {
	if !KnownEvent(ev.Type) {
		return false, i18n.E("err.whEvent", ev.Type)
	}
	found := false
	specific := Specific(ev)
	for _, e := range h.Events {
		if e == ev.Type || (specific != "" && e == specific) {
			found = true
			break
		}
	}
	if !found {
		return false, nil
	}
	if ev.Type != EventPush {
		return true, nil
	}
	return MatchBranch(h.BranchFilter, ev.Branch)
}

// MatchBranch past een push-filter toe.
func MatchBranch(filter, branch string) (bool, error) {
	filter = strings.TrimSpace(filter)
	if filter == "" {
		return true, nil
	}
	if strings.HasPrefix(filter, "re:") {
		re, err := regexp.Compile(strings.TrimPrefix(filter, "re:"))
		if err != nil {
			return false, i18n.E("err.whFilter", err.Error())
		}
		return re.MatchString(branch), nil
	}
	return filter == branch, nil
}

// Expand vult {{event.veld}} en {{secret.NAAM}}.
// Een onbekend geheim of veld is een fout, zodat een webhook niet
// per ongeluk met een leeg token vertrekt.
func Expand(s string, ev Event, secrets map[string]string) (string, error) {
	var b strings.Builder
	for {
		start := strings.Index(s, "{{")
		if start < 0 {
			b.WriteString(s)
			break
		}
		b.WriteString(s[:start])
		rest := s[start+2:]
		end := strings.Index(rest, "}}")
		if end < 0 {
			return "", i18n.E("err.whTemplate")
		}
		key := strings.TrimSpace(rest[:end])
		val, err := lookup(key, ev, secrets)
		if err != nil {
			return "", err
		}
		b.WriteString(val)
		s = rest[end+2:]
	}
	return b.String(), nil
}

func lookup(key string, ev Event, secrets map[string]string) (string, error) {
	switch {
	case strings.HasPrefix(key, "secret."):
		name := strings.TrimPrefix(key, "secret.")
		v, ok := secrets[name]
		if !ok {
			return "", i18n.E("err.whSecret", name)
		}
		return v, nil
	case strings.HasPrefix(key, "event."):
		field := strings.TrimPrefix(key, "event.")
		v, ok := eventField(ev, field)
		if !ok {
			return "", i18n.E("err.whField", field)
		}
		return v, nil
	default:
		return "", i18n.E("err.whPlaceholder", key)
	}
}

func eventField(ev Event, field string) (string, bool) {
	if base, ok := strings.CutSuffix(field, "_json"); ok && base != "" {
		v, ok := eventField(ev, base)
		if !ok {
			return "", false
		}
		b, err := json.Marshal(v)
		if err != nil {
			return "", false
		}
		return string(b), true
	}
	switch field {
	case "type":
		return ev.Type, true
	case "event_name":
		if n := Specific(ev); n != "" {
			return n, true
		}
		return ev.Type, true
	case "project":
		return ev.Project, true
	case "group":
		return ev.Group, true
	case "branch":
		return ev.Branch, true
	case "commit":
		return ev.Commit, true
	case "summary":
		return ev.Summary, true
	case "url":
		return ev.URL, true
	case "pipeline_id":
		return ev.PipelineID, true
	case "release_tag":
		return ev.ReleaseTag, true
	case "actor":
		return ev.Actor, true
	case "payload":
		b, err := json.Marshal(ev.Document())
		if err != nil {
			return "", false
		}
		return string(b), true
	default:
		return "", false
	}
}

// PresetDefaults vult URL-headers en body als de gebruiker een preset kiest
// en een veld leeg laat.
func PresetDefaults(preset string) (headers map[string]string, body string) {
	switch preset {
	case PresetDiscord:
		return map[string]string{"Content-Type": "application/json"}, `{"content":"{{event.summary}}"}`
	case PresetGrok:
		return map[string]string{
			"Content-Type":  "application/json",
			"Authorization": "Bearer {{secret.GROK_TOKEN}}",
		}, ""
	default:
		return map[string]string{"Content-Type": "application/json"}, ""
	}
}

// RenderBody maakt de HTTP-body. Een lege sjabloon wordt de gebeurtenis als JSON.
func RenderBody(bodyTemplate string, ev Event, secrets map[string]string) ([]byte, error) {
	if strings.TrimSpace(bodyTemplate) == "" {
		return json.Marshal(ev.Document())
	}
	s, err := Expand(bodyTemplate, ev, secrets)
	if err != nil {
		return nil, err
	}
	return []byte(s), nil
}

// RenderHeaders vult geheimen in headers. Preset-headers vullen alleen
// ontbrekende sleutels aan.
func RenderHeaders(preset string, configured map[string]string, ev Event, secrets map[string]string) (map[string]string, error) {
	base, _ := PresetDefaults(preset)
	if base == nil {
		base = map[string]string{}
	}
	for k, v := range configured {
		base[k] = v
	}
	out := map[string]string{}
	for k, v := range base {
		ek, err := Expand(k, ev, secrets)
		if err != nil {
			return nil, err
		}
		evv, err := Expand(v, ev, secrets)
		if err != nil {
			return nil, err
		}
		out[ek] = evv
	}
	return out, nil
}
