package webhook

import (
	"encoding/json"
	"net/url"
	"strings"

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

// Extra presets. generic, discord en grok bestonden al.
const (
	PresetCustom     = "custom"
	PresetSlack      = "slack"
	PresetTeams      = "teams"
	PresetMattermost = "mattermost"
	PresetRocketChat = "rocketchat"
	PresetTelegram   = "telegram"
	PresetMatrix     = "matrix"
	PresetGoogleChat = "googlechat"
	PresetNtfy       = "ntfy"
	PresetGotify     = "gotify"
)

// PresetIDs is de volgorde in het formulier.
func PresetIDs() []string {
	return []string{
		PresetCustom, PresetGeneric, PresetDiscord, PresetSlack, PresetTeams,
		PresetMattermost, PresetRocketChat, PresetTelegram, PresetMatrix,
		PresetGoogleChat, PresetNtfy, PresetGotify, PresetGrok,
	}
}

// KnownPreset meldt of id een ondersteunde preset is.
func KnownPreset(id string) bool {
	for _, p := range PresetIDs() {
		if p == id {
			return true
		}
	}
	return false
}

// Input zijn de velden van het formulier. Prepare leest alleen wat bij de preset hoort.
type Input struct {
	URL, Username, Avatar, Icon, Alias string
	Token, Chat, Server, Topic         string
	Homeserver, Room                   string
	Method, ContentType, Headers, Body string
}

// Spec is wat er opgeslagen wordt. De body is een sjabloon; JSON-presets
// gebruiken {{event.summary_json}} zodat aanhalingstekens heel blijven.
type Spec struct {
	Method  string
	URL     string
	Headers map[string]string
	Body    string
}

// Prepare bouwt URL, methode, headers en body voor een preset.
func Prepare(preset string, in Input) (Spec, error) {
	if !KnownPreset(preset) {
		return Spec{}, i18n.E("err.preset")
	}
	switch preset {
	case PresetCustom:
		return prepareCustom(in)
	case PresetGeneric:
		return prepareJSONURL(in.URL)
	case PresetDiscord:
		return prepareMessage(in.URL, discordBody(in.Username, in.Avatar))
	case PresetSlack, PresetGoogleChat:
		return prepareMessage(in.URL, `{"text":{{event.summary_json}}}`)
	case PresetTeams:
		return prepareMessage(in.URL, `{"@type":"MessageCard","@context":"https://schema.org/extensions","summary":{{event.summary_json}},"text":{{event.summary_json}}}`)
	case PresetMattermost:
		return prepareMessage(in.URL, mattermostBody(in.Username, in.Icon))
	case PresetRocketChat:
		return prepareMessage(in.URL, rocketBody(in.Alias))
	case PresetTelegram:
		return prepareTelegram(in)
	case PresetMatrix:
		return prepareMatrix(in)
	case PresetNtfy:
		return prepareNtfy(in)
	case PresetGotify:
		return prepareGotify(in)
	case PresetGrok:
		return prepareGrok(in)
	default:
		return Spec{}, i18n.E("err.preset")
	}
}

func prepareJSONURL(raw string) (Spec, error) {
	u, err := plainURL(raw)
	if err != nil {
		return Spec{}, err
	}
	return Spec{
		Method:  "POST",
		URL:     u,
		Headers: map[string]string{"Content-Type": "application/json"},
	}, nil
}

func prepareMessage(raw, body string) (Spec, error) {
	spec, err := prepareJSONURL(raw)
	if err != nil {
		return Spec{}, err
	}
	spec.Body = body
	return spec, nil
}

func discordBody(username, avatar string) string {
	b := strings.Builder{}
	b.WriteString(`{"content":{{event.summary_json}}`)
	if username != "" {
		b.WriteString(`,"username":`)
		b.Write(mustJSON(username))
	}
	if avatar != "" {
		b.WriteString(`,"avatar_url":`)
		b.Write(mustJSON(avatar))
	}
	b.WriteByte('}')
	return b.String()
}

func mattermostBody(username, icon string) string {
	b := strings.Builder{}
	b.WriteString(`{"text":{{event.summary_json}}`)
	if username != "" {
		b.WriteString(`,"username":`)
		b.Write(mustJSON(username))
	}
	if icon != "" {
		b.WriteString(`,"icon_url":`)
		b.Write(mustJSON(icon))
	}
	b.WriteByte('}')
	return b.String()
}

func rocketBody(alias string) string {
	if alias == "" {
		return `{"text":{{event.summary_json}}}`
	}
	return `{"text":{{event.summary_json}},"alias":` + string(mustJSON(alias)) + `}`
}

func prepareTelegram(in Input) (Spec, error) {
	ref, err := secretRef(in.Token)
	if err != nil {
		return Spec{}, err
	}
	chat := strings.TrimSpace(in.Chat)
	if chat == "" || strings.ContainsAny(chat, "\r\n") {
		return Spec{}, i18n.E("err.whChat")
	}
	return Spec{
		Method:  "POST",
		URL:     "https://api.telegram.org/bot" + ref + "/sendMessage",
		Headers: map[string]string{"Content-Type": "application/json"},
		Body:    `{"chat_id":` + string(mustJSON(chat)) + `,"text":{{event.summary_json}}}`,
	}, nil
}

func prepareMatrix(in Input) (Spec, error) {
	home, err := plainURL(in.Homeserver)
	if err != nil {
		return Spec{}, err
	}
	room := strings.TrimSpace(in.Room)
	if room == "" || strings.ContainsAny(room, " \r\n") {
		return Spec{}, i18n.E("err.whRoom")
	}
	ref, err := secretRef(in.Token)
	if err != nil {
		return Spec{}, err
	}
	home = strings.TrimRight(home, "/")
	txn := "bluegit-{{event.type}}-{{event.commit}}-{{event.pipeline_id}}-{{event.release_tag}}"
	return Spec{
		Method: "PUT",
		URL:    home + "/_matrix/client/v3/rooms/" + url.QueryEscape(room) + "/send/m.room.message/" + txn,
		Headers: map[string]string{
			"Content-Type":  "application/json",
			"Authorization": "Bearer " + ref,
		},
		Body: `{"msgtype":"m.text","body":{{event.summary_json}}}`,
	}, nil
}

func prepareNtfy(in Input) (Spec, error) {
	server := strings.TrimSpace(in.Server)
	if server == "" {
		server = "https://ntfy.sh"
	}
	server, err := plainURL(server)
	if err != nil {
		return Spec{}, err
	}
	topic := strings.Trim(strings.TrimSpace(in.Topic), "/")
	if topic == "" || strings.ContainsAny(topic, " \r\n?#") {
		return Spec{}, i18n.E("err.whTopic")
	}
	headers := map[string]string{"Content-Type": "text/plain"}
	if strings.TrimSpace(in.Token) != "" {
		ref, err := secretRef(in.Token)
		if err != nil {
			return Spec{}, err
		}
		headers["Authorization"] = "Bearer " + ref
	}
	return Spec{
		Method:  "POST",
		URL:     strings.TrimRight(server, "/") + "/" + topic,
		Headers: headers,
		Body:    "{{event.summary}}",
	}, nil
}

func prepareGotify(in Input) (Spec, error) {
	if strings.TrimSpace(in.Server) == "" {
		return Spec{}, i18n.E("err.whServer")
	}
	server, err := plainURL(in.Server)
	if err != nil {
		return Spec{}, err
	}
	ref, err := secretRef(in.Token)
	if err != nil {
		return Spec{}, err
	}
	return Spec{
		Method: "POST",
		URL:    strings.TrimRight(server, "/") + "/message",
		Headers: map[string]string{
			"Content-Type": "application/json",
			"X-Gotify-Key": ref,
		},
		Body: `{"title":{{event.project_json}},"message":{{event.summary_json}}}`,
	}, nil
}

func prepareGrok(in Input) (Spec, error) {
	spec, err := prepareJSONURL(in.URL)
	if err != nil {
		return Spec{}, err
	}
	ref, err := secretRef(in.Token)
	if err != nil {
		return Spec{}, err
	}
	spec.Headers["Authorization"] = "Bearer " + ref
	return spec, nil
}

func prepareCustom(in Input) (Spec, error) {
	method := strings.ToUpper(strings.TrimSpace(in.Method))
	if method == "" {
		method = "POST"
	}
	switch method {
	case "GET", "POST", "PUT", "PATCH":
	default:
		return Spec{}, i18n.E("err.whMethod")
	}
	u, err := plainURL(in.URL)
	if err != nil {
		return Spec{}, err
	}
	ctype := strings.TrimSpace(in.ContentType)
	if ctype == "" {
		ctype = "application/json"
	}
	if strings.ContainsAny(ctype, "\r\n") {
		return Spec{}, i18n.E("err.header")
	}
	headers := map[string]string{"Content-Type": ctype}
	extra, err := parseHeaderLines(in.Headers)
	if err != nil {
		return Spec{}, err
	}
	for k, v := range extra {
		headers[k] = v
	}
	return Spec{Method: method, URL: u, Headers: headers, Body: in.Body}, nil
}

func parseHeaderLines(raw string) (map[string]string, error) {
	out := map[string]string{}
	for _, line := range strings.Split(raw, "\n") {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}
		if strings.ContainsAny(line, "\r") {
			return nil, i18n.E("err.header")
		}
		k, v, ok := strings.Cut(line, ":")
		k, v = strings.TrimSpace(k), strings.TrimSpace(v)
		if !ok || k == "" || strings.ContainsAny(k, " \r\n") || strings.ContainsAny(v, "\r\n") {
			return nil, i18n.E("err.header")
		}
		out[k] = v
	}
	return out, nil
}

func plainURL(raw string) (string, error) {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return "", i18n.E("err.whURL")
	}
	u, err := url.Parse(raw)
	if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") || u.User != nil {
		return "", i18n.E("err.whURL")
	}
	return raw, nil
}

func secretRef(name string) (string, error) {
	name = strings.TrimSpace(name)
	if err := access.ValidSecretName(name); err != nil {
		return "", err
	}
	return "{{secret." + name + "}}", nil
}

func mustJSON(s string) []byte {
	b, err := json.Marshal(s)
	if err != nil {
		return []byte(`""`)
	}
	return b
}
