package server

import (
	"encoding/json"
	"io"
	"net/http"
	"strconv"
	"strings"

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

func (s *Server) repoWebhookSecrets(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.webhookAPIRepo(w, r)
	if !ok {
		return
	}
	s.writeSecretChoices(w, s.repoSecretChoices(r, repo))
}

func (s *Server) groupWebhookSecrets(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.webhookAPIGroup(w, r)
	if !ok {
		return
	}
	s.writeSecretChoices(w, s.groupSecretChoices(r, g))
}

func (s *Server) repoWebhookAPI(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.webhookAPIRepo(w, r)
	if !ok {
		return
	}
	s.writeWebhookSave(w, r, "repo", repo.ID, 0)
}

func (s *Server) groupWebhookAPI(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.webhookAPIGroup(w, r)
	if !ok {
		return
	}
	s.writeWebhookSave(w, r, "group", g.ID, 0)
}

func (s *Server) repoWebhookUpdate(w http.ResponseWriter, r *http.Request) {
	repo, _, ok := s.webhookAPIRepo(w, r)
	if !ok {
		return
	}
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil || id <= 0 {
		http.Error(w, s.tr(r, "err.notFound"), http.StatusNotFound)
		return
	}
	s.writeWebhookSave(w, r, "repo", repo.ID, id)
}

func (s *Server) groupWebhookUpdate(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.webhookAPIGroup(w, r)
	if !ok {
		return
	}
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil || id <= 0 {
		http.Error(w, s.tr(r, "err.notFound"), http.StatusNotFound)
		return
	}
	s.writeWebhookSave(w, r, "group", g.ID, id)
}

func (s *Server) writeSecretChoices(w http.ResponseWriter, choices []SecretChoice) {
	if choices == nil {
		choices = []SecretChoice{}
	}
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(map[string]any{"secrets": choices})
}

func (s *Server) writeWebhookSave(w http.ResponseWriter, r *http.Request, kind string, scopeID, id int64) {
	var body struct {
		Name         string   `json:"name"`
		Preset       string   `json:"preset"`
		BranchFilter string   `json:"branch_filter"`
		Events       []string `json:"events"`
		URL          string   `json:"url"`
		Username     string   `json:"username"`
		Avatar       string   `json:"avatar"`
		Icon         string   `json:"icon"`
		Alias        string   `json:"alias"`
		Token        string   `json:"token"`
		Chat         string   `json:"chat"`
		Server       string   `json:"server"`
		Topic        string   `json:"topic"`
		Homeserver   string   `json:"homeserver"`
		Room         string   `json:"room"`
		Method       string   `json:"method"`
		ContentType  string   `json:"content_type"`
		Headers      string   `json:"headers"`
		Body         string   `json:"body"`
	}
	if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body); err != nil {
		http.Error(w, s.tr(r, "err.json"), http.StatusBadRequest)
		return
	}
	saved, err := s.saveWebhookRecord(r.Context(), kind, scopeID, id, strings.TrimSpace(body.Name), body.Preset, body.BranchFilter, body.Events, webhook.Input{
		URL: body.URL, Username: body.Username, Avatar: body.Avatar, Icon: body.Icon, Alias: body.Alias,
		Token: body.Token, Chat: body.Chat, Server: body.Server, Topic: body.Topic,
		Homeserver: body.Homeserver, Room: body.Room, Method: body.Method, ContentType: body.ContentType,
		Headers: body.Headers, Body: body.Body,
	})
	if err != nil {
		status := http.StatusBadRequest
		if store.Missing(err) {
			status = http.StatusNotFound
		}
		http.Error(w, s.trErr(r, err), status)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	if id == 0 {
		w.WriteHeader(http.StatusCreated)
	}
	_ = json.NewEncoder(w).Encode(map[string]any{"id": saved})
}

func (s *Server) webhookAPIRepo(w http.ResponseWriter, r *http.Request) (store.Repo, store.User, bool) {
	u, ok := s.webhookAPIUser(w, r)
	if !ok {
		return store.Repo{}, store.User{}, false
	}
	repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
	if err != nil {
		http.NotFound(w, r)
		return store.Repo{}, store.User{}, false
	}
	role, err := s.Store.EffectiveRole(r.Context(), u.ID, repo.ID)
	if err != nil || !role.CanManageSettings() {
		http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
		return store.Repo{}, store.User{}, false
	}
	return repo, u, true
}

func (s *Server) webhookAPIGroup(w http.ResponseWriter, r *http.Request) (store.Group, store.User, bool) {
	u, ok := s.webhookAPIUser(w, r)
	if !ok {
		return store.Group{}, store.User{}, false
	}
	g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
	if err != nil {
		http.NotFound(w, r)
		return store.Group{}, store.User{}, false
	}
	role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
	if err != nil || !role.CanManageSettings() {
		http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
		return store.Group{}, store.User{}, false
	}
	return g, u, true
}

func (s *Server) webhookAPIUser(w http.ResponseWriter, r *http.Request) (store.User, bool) {
	token := bearer(r)
	if token == "" {
		token = strings.TrimSpace(r.Header.Get("PRIVATE-TOKEN"))
	}
	if !strings.HasPrefix(token, "bg_") {
		http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized)
		return store.User{}, false
	}
	u, err := s.Store.UserByToken(r.Context(), token)
	if err != nil {
		http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
		return store.User{}, false
	}
	return u, true
}
