package server

import (
	"errors"
	"net/http"
	"strconv"
	"strings"
	"time"

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

// Beheer > Gebruikers: elke sitebeheerder kan een ander beheerder maken of
// die rechten weer afnemen. Jezelf degraderen kan niet, en er blijft altijd
// minstens één beheerder (store.SetInstanceAdmin). Elke wijziging komt als
// auditregel in de log ("admin audit").

// AdminTab is één subtab onder Beheer.
type AdminTab struct {
	Key, Href string
	On        bool
}

func adminTabs(page string) []AdminTab {
	tabs := []AdminTab{
		{Key: "admin.tab.settings", Href: "/admin/settings"},
		{Key: "admin.tab.users", Href: "/admin/users"},
		{Key: "admin.tab.runner", Href: "/admin/runner"},
		{Key: "admin.tab.storage", Href: "/setup"},
		{Key: "admin.tab.pipelines", Href: "/admin/pipelines"},
		{Key: "admin.tab.backup", Href: "/admin/backup"},
	}
	on := map[string]string{
		"adminsettings":     "/admin/settings",
		"adminusers":        "/admin/users",
		"adminrunner":       "/admin/runner",
		"setup":             "/setup",
		"adminpipelines":    "/admin/pipelines",
		"adminbackup":       "/admin/backup",
		"adminbackupserver": "/admin/backup",
	}
	href := on[page]
	for i := range tabs {
		tabs[i].On = tabs[i].Href == href
	}
	return tabs
}

func isAdminPage(page string) bool {
	return page == "adminsettings" || page == "adminusers" || page == "adminrunner" || page == "setup" || page == "adminpipelines" || page == "adminbackup" || page == "adminbackupserver"
}

func (s *Server) mountAdmin(mux *http.ServeMux) {
	mux.HandleFunc("GET /admin", s.adminHome)
	mux.HandleFunc("GET /admin/{$}", s.adminHome)
	mux.HandleFunc("GET /admin/settings", s.adminSettings)
	mux.HandleFunc("POST /admin/settings", s.adminSettingsSave)
	mux.HandleFunc("GET /admin/users", s.adminUsers)
	mux.HandleFunc("POST /admin/users/role", s.adminUserRole)
	mux.HandleFunc("POST /admin/users/token", s.adminUserToken)
	mux.HandleFunc("GET /admin/pipelines", s.adminPipelines)
	mux.HandleFunc("POST /admin/pipelines", s.adminPipelinesSave)
	mux.HandleFunc("GET /admin/storage", func(w http.ResponseWriter, r *http.Request) {
		if ok, _ := s.adminOnly(w, r); ok {
			http.Redirect(w, r, "/setup", http.StatusFound)
		}
	})
}

func (s *Server) adminHome(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); ok {
		http.Redirect(w, r, "/admin/settings", http.StatusFound)
	}
}

// AdminUserRow is één rij in Beheer > Gebruikers.
type AdminUserRow struct {
	User store.User
	Self bool
}

func (s *Server) adminUsers(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok {
		return
	}
	users, err := s.Store.ListUsers(r.Context())
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	v := s.view(w, r, "title.admin")
	v.Page = "adminusers"
	v.NewAdminToken = cookieVal(r, "bluegit_admin_token_once")
	v.AdminTokenUser = cookieVal(r, "bluegit_admin_token_user")
	if v.NewAdminToken != "" {
		http.SetCookie(w, &http.Cookie{Name: "bluegit_admin_token_once", Value: "", Path: "/", MaxAge: -1})
		http.SetCookie(w, &http.Cookie{Name: "bluegit_admin_token_user", Value: "", Path: "/", MaxAge: -1})
	}
	me := s.who(r).User.ID
	for _, u := range users {
		v.AdminUsers = append(v.AdminUsers, AdminUserRow{User: u, Self: u.ID == me})
	}
	s.render(w, "adminusers", v)
}

func adminRoleErr(err error) error {
	switch {
	case errors.Is(err, store.ErrSelfDemote):
		return i18n.E("admin.err.self")
	case errors.Is(err, store.ErrLastAdmin):
		return i18n.E("admin.err.last")
	}
	return i18n.E("admin.err.user")
}

func (s *Server) setAdmin(r *http.Request, target int64, admin bool) (store.User, error) {
	by := s.who(r).User
	if by.ID == 0 {
		by = apiUser(r)
	}
	u, err := s.Store.SetInstanceAdmin(r.Context(), by.ID, target, admin)
	if err != nil {
		return u, err
	}
	if s.Log != nil {
		s.Log.Info("admin audit", "action", map[bool]string{true: "grant_admin", false: "revoke_admin"}[admin], "by", by.Username, "target", u.Username)
	}
	return u, nil
}

func (s *Server) adminUserRole(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	u, err := s.setAdmin(r, id, r.FormValue("admin") == "1")
	if err != nil {
		s.redirect(w, r, "/admin/users", "", s.trErr(r, adminRoleErr(err)))
		return
	}
	key := "admin.ok.granted"
	if !u.InstanceAdmin {
		key = "admin.ok.revoked"
	}
	s.redirect(w, r, "/admin/users", s.tr(r, key, u.Username), "")
}

func adminUserJSON(u store.User) map[string]any {
	return map[string]any{"id": u.ID, "username": u.Username, "admin": u.InstanceAdmin, "created_at": rfcTime(u.CreatedAt)}
}

func (s *Server) apiAdminUsers(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	users, err := s.Store.ListUsers(r.Context())
	if err != nil {
		s.writeAPIErr(w, r, err)
		return
	}
	out := []map[string]any{}
	for _, u := range users {
		out = append(out, adminUserJSON(u))
	}
	writeJSON(w, http.StatusOK, out)
}

func (s *Server) apiAdminUserRole(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	var in struct {
		Admin *bool `json:"admin"`
	}
	if err := readJSON(r, &in); err != nil || in.Admin == nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("admin.err.body")))
		return
	}
	target, err := s.Store.UserByUsername(r.Context(), strings.TrimSpace(r.PathValue("username")))
	if err != nil {
		s.writeAPIErr(w, r, fail(404, i18n.E("admin.err.user")))
		return
	}
	u, err := s.setAdmin(r, target.ID, *in.Admin)
	if err != nil {
		code := 409
		if errors.Is(err, store.ErrSelfDemote) {
			code = 403
		}
		s.writeAPIErr(w, r, fail(code, adminRoleErr(err)))
		return
	}
	writeJSON(w, http.StatusOK, adminUserJSON(u))
}

func (s *Server) issueTokenForUser(r *http.Request, u store.User, name string) (string, store.TokenInfo, error) {
	plain, info, err := s.opIssueToken(r.Context(), u, name, nil, time.Time{})
	if err != nil {
		return "", info, err
	}
	if s.Log != nil {
		s.Log.Info("admin audit", "action", "create_token", "by", s.who(r).User.Username, "target", u.Username, "name", info.Name)
	}
	return plain, info, nil
}

func (s *Server) adminUserToken(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	u, err := s.Store.UserByID(r.Context(), id)
	if err != nil {
		s.redirect(w, r, "/admin/users", "", s.trErr(r, i18n.E("admin.err.user")))
		return
	}
	plain, _, err := s.issueTokenForUser(r, u, r.FormValue("name"))
	if err != nil {
		s.redirect(w, r, "/admin/users", "", s.trErr(r, err))
		return
	}
	secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
	http.SetCookie(w, &http.Cookie{Name: "bluegit_admin_token_once", Value: plain, Path: "/", MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode})
	http.SetCookie(w, &http.Cookie{Name: "bluegit_admin_token_user", Value: u.Username, Path: "/", MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode})
	s.redirect(w, r, "/admin/users", s.tr(r, "admin.token.created", u.Username), "")
}

func (s *Server) apiAdminUserToken(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	var in struct {
		Name string `json:"name"`
	}
	if err := readJSON(r, &in); err != nil {
		s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
		return
	}
	u, err := s.Store.UserByUsername(r.Context(), strings.TrimSpace(r.PathValue("username")))
	if err != nil {
		s.writeAPIErr(w, r, fail(404, i18n.E("admin.err.user")))
		return
	}
	plain, info, err := s.issueTokenForUser(r, u, in.Name)
	if !s.apiOK(w, r, err) {
		return
	}
	writeJSON(w, http.StatusCreated, tokenJSON(info, plain))
}
