package runnercfg

import (
	"bytes"
	"encoding/json"
	"errors"
	"html/template"
	"net/http"
	"strconv"
	"strings"
	"time"

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

// Status is de kop van het scherm.
type Status struct {
	Kind        string       `json:"kind"` // "standalone" of "builtin"
	Name        string       `json:"name"`
	Version     string       `json:"version"`
	ServerURL   string       `json:"server_url"`
	Online      bool         `json:"online"`
	LastContact time.Time    `json:"last_contact,omitempty"`
	ServerPause bool         `json:"server_paused"`
	Docker      DockerStatus `json:"docker"`
}

// Handler is de gedeelde webinterface en JSON-API voor runnerbeheer.
// Hij zit onder Prefix (bv. "" op de runner, "/admin/runner" in BlueGit).
// Auth en CSRF komen van de host.
type Handler struct {
	Prefix  string
	File    *File
	Default Settings
	Tracker *Tracker
	WorkDir string
	// BasePresets zijn presets uit de configuratie (alleen-lezen in de UI).
	BasePresets map[string]images.Override
	// Apply zet nieuwe instellingen live (na Save).
	Apply  func(Settings) error
	Status func() Status
	// Lang, Auth, CSRF en Layout komen van de host.
	Lang      func(r *http.Request) i18n.Lang
	Auth      func(w http.ResponseWriter, r *http.Request, write bool) bool
	CSRF      func(r *http.Request) (field, value string)
	CheckCSRF func(r *http.Request) bool
	Layout    func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML)
	DocsURL   string
	APIBase   string
}

// Current leest de opgeslagen instellingen.
func (h *Handler) Current() Settings {
	s, err := h.File.Load(h.Default)
	if err != nil {
		return h.Default
	}
	return s
}

func (h *Handler) save(s Settings) error {
	if err := s.Validate(); err != nil {
		return err
	}
	if err := h.File.Save(s); err != nil {
		return err
	}
	if h.Tracker != nil {
		h.Tracker.SetPaused(s.Paused)
	}
	if h.Apply != nil {
		return h.Apply(s)
	}
	return nil
}

// Mount hangt de routes aan mux.
func (h *Handler) Mount(mux *http.ServeMux, withAPI bool) {
	p := h.Prefix
	page := p
	if page == "" {
		page = "/{$}"
	}
	mux.HandleFunc("GET "+page, h.page)
	mux.HandleFunc("POST "+p+"/settings", h.form(h.postSettings))
	mux.HandleFunc("POST "+p+"/recommend", h.form(h.postRecommend))
	mux.HandleFunc("POST "+p+"/presets", h.form(h.postPreset))
	mux.HandleFunc("POST "+p+"/presets/delete", h.form(h.postPresetDelete))
	mux.HandleFunc("POST "+p+"/pause", h.form(func(r *http.Request, s *Settings) (string, error) { s.Paused = true; return "rui.ok.paused", nil }))
	mux.HandleFunc("POST "+p+"/resume", h.form(func(r *http.Request, s *Settings) (string, error) { s.Paused = false; return "rui.ok.resumed", nil }))
	if !withAPI {
		return
	}
	api := h.APIBase
	if api == "" {
		api = p + "/api"
	}
	mux.HandleFunc("GET "+api+"/status", h.APIStatus)
	mux.HandleFunc("GET "+api+"/settings", h.APISettings)
	mux.HandleFunc("PUT "+api+"/settings", h.APISettings)
	mux.HandleFunc("POST "+api+"/pause", h.APIPause(true))
	mux.HandleFunc("POST "+api+"/resume", h.APIPause(false))
	mux.HandleFunc("GET "+api+"/jobs", h.APIJobs)
}

func (h *Handler) lang(r *http.Request) i18n.Lang {
	if h.Lang != nil {
		return h.Lang(r)
	}
	return i18n.EN
}

func (h *Handler) back(w http.ResponseWriter, r *http.Request, ok, problem string) {
	q := ""
	if ok != "" {
		q = "?ok=" + ok
	} else if problem != "" {
		q = "?err=" + problem
	}
	target := h.Prefix
	if target == "" {
		target = "/"
	}
	http.Redirect(w, r, target+q, http.StatusSeeOther)
}

// errKey maakt van een fout een catalogussleutel plus argumenten in de URL.
func errKey(err error) string {
	var e Error
	if errors.As(err, &e) {
		parts := []string{e.Key}
		for _, a := range e.Args {
			parts = append(parts, strings.ReplaceAll(toString(a), "|", "/"))
		}
		return template.URLQueryEscaper(strings.Join(parts, "|"))
	}
	return "rui.err.save"
}

func toString(a any) string {
	switch v := a.(type) {
	case string:
		return v
	default:
		b, _ := json.Marshal(v)
		return string(b)
	}
}

func (h *Handler) form(fn func(r *http.Request, s *Settings) (string, error)) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if !h.Auth(w, r, true) {
			return
		}
		if h.CheckCSRF != nil && !h.CheckCSRF(r) {
			http.Error(w, "csrf", http.StatusForbidden)
			return
		}
		_ = r.ParseForm()
		s := h.Current()
		ok, err := fn(r, &s)
		if err == nil {
			err = h.save(s)
		}
		if err != nil {
			h.back(w, r, "", errKey(err))
			return
		}
		h.back(w, r, ok, "")
	}
}

func atoi(r *http.Request, k string, def int) int {
	v := strings.TrimSpace(r.FormValue(k))
	if v == "" {
		return def
	}
	n, err := strconv.Atoi(v)
	if err != nil {
		return -1
	}
	return n
}

func (h *Handler) postSettings(r *http.Request, s *Settings) (string, error) {
	s.Name = r.FormValue("name")
	s.Concurrency = atoi(r, "concurrency", 1)
	s.MaxImages = atoi(r, "max_images", 20)
	cpus := strings.TrimSpace(strings.ReplaceAll(r.FormValue("cpus"), ",", "."))
	if cpus == "" {
		s.CPUs = 0
	} else if f, err := strconv.ParseFloat(cpus, 64); err == nil {
		s.CPUs = f
	} else {
		s.CPUs = -1
	}
	s.MemoryMB = atoi(r, "memory_mb", 0)
	s.PidsLimit = atoi(r, "pids_limit", 0)
	s.MaxDiskGB = atoi(r, "max_disk_gb", 0)
	s.PruneCacheGB = atoi(r, "prune_cache_gb", 0)
	s.JobTimeoutMin = atoi(r, "job_timeout_min", 0)
	s.PullPolicy = r.FormValue("pull_policy")
	s.CleanupWork = r.FormValue("cleanup_work") != ""
	s.PruneDangling = r.FormValue("prune_dangling") != ""
	s.Labels = strings.FieldsFunc(r.FormValue("labels"), func(c rune) bool { return c == ',' || c == ' ' || c == '\n' })
	return "rui.ok.saved", nil
}

func (h *Handler) postRecommend(r *http.Request, s *Settings) (string, error) {
	rec := Recommend(Detect(h.WorkDir))
	s.Concurrency, s.MaxImages, s.CPUs, s.MemoryMB, s.PidsLimit = rec.Concurrency, rec.MaxImages, rec.CPUs, rec.MemoryMB, rec.PidsLimit
	s.MaxDiskGB, s.PruneCacheGB = rec.MaxDiskGB, rec.PruneCacheGB
	return "rui.ok.recommended", nil
}

func (h *Handler) postPreset(r *http.Request, s *Settings) (string, error) {
	p := Preset{Name: r.FormValue("name"), Image: r.FormValue("image"), From: r.FormValue("from"), Dockerfile: r.FormValue("dockerfile"), Note: strings.TrimSpace(r.FormValue("note"))}
	if err := p.Validate(); err != nil {
		return "", err
	}
	replaced := false
	for i := range s.Presets {
		if s.Presets[i].Name == p.Name {
			s.Presets[i], replaced = p, true
		}
	}
	if !replaced {
		s.Presets = append(s.Presets, p)
	}
	return "rui.ok.preset", nil
}

func (h *Handler) postPresetDelete(r *http.Request, s *Settings) (string, error) {
	name := r.FormValue("name")
	out := s.Presets[:0]
	for _, p := range s.Presets {
		if p.Name != name {
			out = append(out, p)
		}
	}
	s.Presets = out
	return "rui.ok.presetDeleted", nil
}

// View is alles wat het fragment toont.
type View struct {
	Lang      i18n.Lang
	Prefix    string
	CSRFField string
	CSRF      string
	Status    Status
	S         Settings
	Rec       Settings
	HW        Hardware
	WorkGB    int
	Builtin   []images.Preset
	Config    []string
	Active    []JobInfo
	Recent    []JobInfo
	Safe      bool
	Notice    string
	Problem   string
	DocsURL   string
	APIBase   string
}

func (h *Handler) view(r *http.Request) View {
	lang := h.lang(r)
	v := View{Lang: lang, Prefix: h.Prefix, S: h.Current(), DocsURL: h.DocsURL}
	v.APIBase = h.APIBase
	if v.APIBase == "" {
		v.APIBase = h.Prefix + "/api"
	}
	if h.CSRF != nil {
		v.CSRFField, v.CSRF = h.CSRF(r)
	}
	if h.Status != nil {
		v.Status = h.Status()
	}
	v.HW = Detect(h.WorkDir)
	v.Rec = Recommend(v.HW)
	v.Builtin = images.Builtin()
	for k := range h.BasePresets {
		v.Config = append(v.Config, k)
	}
	if h.Tracker != nil {
		v.Active, v.Recent, v.Safe = h.Tracker.Active(), h.Tracker.Recent(), h.Tracker.SafeToUpgrade()
	}
	if k := r.URL.Query().Get("ok"); strings.HasPrefix(k, "rui.ok.") {
		v.Notice = i18n.T(lang, k)
	}
	if k := r.URL.Query().Get("err"); strings.HasPrefix(k, "rui.err.") {
		parts := strings.Split(k, "|")
		args := make([]any, 0, len(parts)-1)
		for _, a := range parts[1:] {
			args = append(args, a)
		}
		v.Problem = i18n.T(lang, parts[0], args...)
	}
	return v
}

func (h *Handler) page(w http.ResponseWriter, r *http.Request) {
	if !h.Auth(w, r, false) {
		return
	}
	v := h.view(r)
	h.Layout(w, r, v.Lang, i18n.T(v.Lang, "rui.title"), Render(v))
}

// Render maakt het HTML-fragment.
func Render(v View) template.HTML {
	var b bytes.Buffer
	if err := uiTmpl(v.Lang).ExecuteTemplate(&b, "runnerui", v); err != nil {
		return template.HTML(template.HTMLEscapeString(err.Error()))
	}
	return template.HTML(b.String())
}

func (h *Handler) APIStatus(w http.ResponseWriter, r *http.Request) {
	if !h.Auth(w, r, false) {
		return
	}
	st := Status{}
	if h.Status != nil {
		st = h.Status()
	}
	s := h.Current()
	hw := Detect(h.WorkDir)
	writeJSON(w, http.StatusOK, map[string]any{
		"status": st, "paused": s.Paused, "active_jobs": len(h.Tracker.Active()),
		"safe_to_upgrade": h.Tracker.SafeToUpgrade(), "hardware": hw, "recommended": Recommend(hw),
	})
}

func (h *Handler) APIJobs(w http.ResponseWriter, r *http.Request) {
	if !h.Auth(w, r, false) {
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"active": nonNil(h.Tracker.Active()), "recent": nonNil(h.Tracker.Recent()), "safe_to_upgrade": h.Tracker.SafeToUpgrade()})
}

func nonNil(j []JobInfo) []JobInfo {
	if j == nil {
		return []JobInfo{}
	}
	return j
}

func (h *Handler) APISettings(w http.ResponseWriter, r *http.Request) {
	if !h.Auth(w, r, r.Method != http.MethodGet) {
		return
	}
	if r.Method == http.MethodPut {
		s := h.Current()
		dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20))
		if err := dec.Decode(&s); err != nil {
			writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON"})
			return
		}
		if err := h.save(s); err != nil {
			msg := err.Error()
			var e Error
			if errors.As(err, &e) {
				msg = i18n.T(i18n.EN, e.Key, e.Args...)
			}
			writeJSON(w, http.StatusUnprocessableEntity, map[string]string{"error": msg})
			return
		}
	}
	writeJSON(w, http.StatusOK, h.Current())
}

func (h *Handler) APIPause(on bool) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if !h.Auth(w, r, true) {
			return
		}
		s := h.Current()
		s.Paused = on
		if err := h.save(s); err != nil {
			writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
			return
		}
		writeJSON(w, http.StatusOK, map[string]any{"paused": on, "active_jobs": len(h.Tracker.Active()), "safe_to_upgrade": h.Tracker.SafeToUpgrade()})
	}
}

func writeJSON(w http.ResponseWriter, code int, v any) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Header().Set("Cache-Control", "no-store")
	w.WriteHeader(code)
	_ = json.NewEncoder(w).Encode(v)
}
