package main

import (
	"bytes"
	"context"
	"crypto/hmac"
	"crypto/rand"
	"crypto/sha256"
	"crypto/subtle"
	"encoding/hex"
	"errors"
	"html/template"
	"net"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"time"

	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/langpick"
	"gitlab.com/Timfa/bluegit/internal/runnercfg"
	"gitlab.com/Timfa/bluegit/internal/server/static"
)

// De webinterface van de runner. Standaard alleen op 127.0.0.1:8765
// (ui_listen); "off" zet hem uit. Toegang met een beheertoken dat lokaal
// in work_dir/ui-token staat (0600). Het token komt nooit in de logs;
// `bluegit-runner ui-token` toont het op de machine zelf.

const defaultUIListen = "127.0.0.1:8765"

func uiTokenPath(cfg Config) string { return filepath.Join(cfg.WorkDir, "ui-token") }

// ensureUIToken maakt het token bij de eerste start.
func ensureUIToken(cfg Config) (string, bool, error) {
	p := uiTokenPath(cfg)
	if b, err := os.ReadFile(p); err == nil && len(bytes.TrimSpace(b)) >= 32 {
		return string(bytes.TrimSpace(b)), false, nil
	}
	raw := make([]byte, 24)
	if _, err := rand.Read(raw); err != nil {
		return "", false, err
	}
	tok := "bgru_" + hex.EncodeToString(raw)
	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
		return "", false, err
	}
	if err := os.WriteFile(p, []byte(tok+"\n"), 0o600); err != nil {
		return "", false, err
	}
	return tok, true, nil
}

type webUI struct {
	cfg   Config
	token string
	h     *runnercfg.Handler
	mux   *http.ServeMux
}

func (u *webUI) mac(purpose string) string {
	m := hmac.New(sha256.New, []byte(u.token))
	m.Write([]byte(purpose))
	return hex.EncodeToString(m.Sum(nil))
}

func (u *webUI) authed(r *http.Request) bool {
	if a := r.Header.Get("Authorization"); strings.HasPrefix(a, "Bearer ") {
		return subtle.ConstantTimeCompare([]byte(strings.TrimPrefix(a, "Bearer ")), []byte(u.token)) == 1
	}
	c, err := r.Cookie("bgru_session")
	return err == nil && subtle.ConstantTimeCompare([]byte(c.Value), []byte(u.mac("session"))) == 1
}

func (u *webUI) lang(r *http.Request) i18n.Lang {
	if q := r.URL.Query().Get("lang"); q != "" {
		return i18n.Parse(q)
	}
	if c, err := r.Cookie("lang"); err == nil {
		return i18n.Parse(c.Value)
	}
	if u.cfg.Language != "" {
		return i18n.Parse(u.cfg.Language)
	}
	al := strings.ToLower(r.Header.Get("Accept-Language"))
	for _, l := range []i18n.Lang{i18n.NL, i18n.DE, i18n.FR, i18n.EN} {
		if strings.HasPrefix(al, string(l)) {
			return l
		}
	}
	return i18n.EN
}

func newWebUI(cfg Config, token string, h *runnercfg.Handler) *webUI {
	u := &webUI{cfg: cfg, token: token, h: h, mux: http.NewServeMux()}
	h.Lang = u.lang
	h.Auth = func(w http.ResponseWriter, r *http.Request, write bool) bool {
		if u.authed(r) {
			return true
		}
		if strings.HasPrefix(r.URL.Path, "/api/") {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusUnauthorized)
			_, _ = w.Write([]byte(`{"error":"unauthorized"}` + "\n"))
			return false
		}
		http.Redirect(w, r, "/login", http.StatusSeeOther)
		return false
	}
	h.CSRF = func(r *http.Request) (string, string) { return "csrf", u.mac("csrf") }
	h.CheckCSRF = func(r *http.Request) bool {
		if strings.HasPrefix(r.Header.Get("Authorization"), "Bearer ") {
			return true
		}
		return hmac.Equal([]byte(r.FormValue("csrf")), []byte(u.mac("csrf")))
	}
	h.Layout = u.layout
	h.DocsURL = "/docs"
	h.Mount(u.mux, true)
	u.mux.HandleFunc("GET /assets/style.css", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/css; charset=utf-8")
		_, _ = w.Write(static.StyleCSS)
	})
	u.mux.HandleFunc("GET /assets/logo.svg", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "image/svg+xml")
		_, _ = w.Write(static.LogoSVG)
	})
	for name, body := range map[string][]byte{"confirm.js": static.ConfirmJS, "tip.js": static.TipJS, "langpick.js": static.LangpickJS} {
		b := body
		u.mux.HandleFunc("GET /assets/"+name, func(w http.ResponseWriter, r *http.Request) {
			w.Header().Set("Content-Type", "text/javascript; charset=utf-8")
			_, _ = w.Write(b)
		})
	}
	u.mux.HandleFunc("POST /lang", u.switchLang)
	u.mux.HandleFunc("GET /docs", u.docs)
	u.mux.HandleFunc("GET /login", u.loginPage)
	u.mux.HandleFunc("POST /login", u.login)
	u.mux.HandleFunc("POST /logout", u.logout)
	u.mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
	return u
}

func (u *webUI) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("X-Frame-Options", "DENY")
	w.Header().Set("X-Content-Type-Options", "nosniff")
	w.Header().Set("Referrer-Policy", "same-origin")
	w.Header().Set("Content-Security-Policy", "default-src 'self'; img-src 'self' data:; style-src 'self'; script-src 'self'; form-action 'self'; frame-ancestors 'none'")
	if q := r.URL.Query().Get("lang"); q != "" && r.Method == http.MethodGet {
		http.SetCookie(w, &http.Cookie{Name: "lang", Value: string(i18n.Parse(q)), Path: "/", MaxAge: 365 * 86400, SameSite: http.SameSiteStrictMode})
	}
	u.mux.ServeHTTP(w, r)
}

// switchLang komt van de taalkiezer: taal in een cookie, terug naar back.
func (u *webUI) switchLang(w http.ResponseWriter, r *http.Request) {
	l := i18n.Parse(r.FormValue("lang"))
	http.SetCookie(w, &http.Cookie{Name: "lang", Value: string(l), Path: "/", MaxAge: 365 * 86400, SameSite: http.SameSiteStrictMode, HttpOnly: true})
	http.Redirect(w, r, langpick.SafeBack(r.FormValue("back")), http.StatusSeeOther)
}

func (u *webUI) loginPage(w http.ResponseWriter, r *http.Request) {
	lang := u.lang(r)
	var b bytes.Buffer
	_ = loginTmpl.Execute(&b, map[string]any{"Lang": lang, "Bad": r.URL.Query().Get("bad") != "", "T": tfunc(lang)})
	u.layout(w, r, lang, i18n.T(lang, "rui.login"), template.HTML(b.String()))
}

func tfunc(lang i18n.Lang) func(string, ...any) string {
	return func(k string, a ...any) string { return i18n.T(lang, k, a...) }
}

func (u *webUI) login(w http.ResponseWriter, r *http.Request) {
	tok := strings.TrimSpace(r.FormValue("token"))
	if subtle.ConstantTimeCompare([]byte(tok), []byte(u.token)) != 1 {
		time.Sleep(500 * time.Millisecond)
		http.Redirect(w, r, "/login?bad=1", http.StatusSeeOther)
		return
	}
	http.SetCookie(w, &http.Cookie{Name: "bgru_session", Value: u.mac("session"), Path: "/", HttpOnly: true, SameSite: http.SameSiteStrictMode, Secure: r.TLS != nil, MaxAge: 30 * 86400})
	http.Redirect(w, r, "/", http.StatusSeeOther)
}

func (u *webUI) logout(w http.ResponseWriter, r *http.Request) {
	if !hmac.Equal([]byte(r.FormValue("csrf")), []byte(u.mac("csrf"))) {
		http.Error(w, "csrf", http.StatusForbidden)
		return
	}
	http.SetCookie(w, &http.Cookie{Name: "bgru_session", Value: "", Path: "/", MaxAge: -1})
	http.Redirect(w, r, "/login", http.StatusSeeOther)
}

func (u *webUI) docs(w http.ResponseWriter, r *http.Request) {
	lang := u.lang(r)
	var b bytes.Buffer
	_ = docsTmpl.Execute(&b, map[string]any{"T": tfunc(lang), "Sections": docSections, "Listen": u.cfg.UIListen, "Server": u.cfg.URL})
	u.layout(w, r, lang, i18n.T(lang, "rdoc.title"), template.HTML(b.String()))
}

func (u *webUI) layout(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Header().Set("Cache-Control", "no-store")
	back := r.URL.Path
	if q := r.URL.Query(); len(q) > 0 {
		q.Del("lang")
		if e := q.Encode(); e != "" {
			back += "?" + e
		}
	}
	_ = layoutTmpl.Execute(w, map[string]any{
		"Title": title, "Body": body, "T": tfunc(lang), "Lang": string(lang), "LangPick": langpick.HTML(lang, "/lang", back, "", ""),
		"Authed": u.authed(r), "CSRF": u.mac("csrf"),
	})
}

// serveUI start de webinterface; fouten komen in de log, niet fataal.
func serveUI(ctx context.Context, u *webUI, listen string, logf func(string, ...any)) error {
	ln, err := net.Listen("tcp", listen)
	if err != nil {
		return err
	}
	srv := &http.Server{Handler: u, ReadHeaderTimeout: 10 * time.Second}
	go func() {
		<-ctx.Done()
		sc, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		_ = srv.Shutdown(sc)
	}()
	go func() {
		if err := srv.Serve(ln); err != nil && !errors.Is(err, http.ErrServerClosed) {
			logf("web UI", "err", err)
		}
	}()
	return nil
}

var layoutTmpl = template.Must(template.New("layout").Parse(`<!DOCTYPE html>
<html lang="{{.Lang}}">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>{{.Title}} · BlueGit runner</title>
  <link rel="icon" href="/assets/logo.svg" type="image/svg+xml">
  <link rel="stylesheet" href="/assets/style.css">
</head>
<body data-modal-title="{{call .T "modal.title"}}" data-modal-ok="{{call .T "modal.ok"}}" data-modal-cancel="{{call .T "modal.cancel"}}">
<header class="top">
  <a class="brand" href="/"><img src="/assets/logo.svg" alt=""> {{call .T "rui.brand"}}</a>
  <nav class="rui-nav">
    {{if .Authed}}<a href="/">{{call .T "rui.nav.overview"}}</a>{{end}}
    <a href="/docs">{{call .T "rui.nav.docs"}}</a>
    {{.LangPick}}
    {{if .Authed}}<form method="post" action="/logout"><input type="hidden" name="csrf" value="{{.CSRF}}"><button type="submit">{{call .T "rui.nav.logout"}}</button></form>{{end}}
  </nav>
</header>
<div class="frame"><div class="content"><main class="wide">
{{.Body}}
</main></div></div>
<script src="/assets/confirm.js"></script>
<script src="/assets/tip.js"></script>
<script src="/assets/langpick.js"></script>
</body>
</html>`))

var loginTmpl = template.Must(template.New("login").Parse(`<section class="panel rui-login">
  <h1>{{call .T "rui.login"}}</h1>
  <p class="muted">{{call .T "rui.loginLead"}}</p>
  <pre class="code">sudo bluegit-runner ui-token</pre>
  {{if .Bad}}<p class="flash bad">{{call .T "rui.loginBad"}}</p>{{end}}
  <form method="post" action="/login">
    <label>{{call .T "rui.token"}}<input type="password" name="token" autocomplete="current-password" required autofocus></label>
    <button type="submit">{{call .T "rui.loginBtn"}}</button>
  </form>
</section>`))

// docSections zijn de koppen van de docs-pagina op de runner; tekst uit de catalogus.
var docSections = []string{"intro", "network", "ui", "settings", "presets", "pause", "upgrade", "api", "trouble"}

var docsTmpl = template.Must(template.New("docs").Parse(`<article class="panel rui-doc readme">
<div class="mdbody">
  <h1>{{call .T "rdoc.title"}}</h1>
  {{range .Sections}}
  <h2 id="{{.}}">{{call $.T (printf "rdoc.%s.h" .)}}</h2>
  <p>{{call $.T (printf "rdoc.%s.p" .)}}</p>
  {{end}}
  <h2 id="commands">{{call .T "rdoc.cmd.h"}}</h2>
  <pre><code>sudo bluegit-runner ui-token
journalctl -u bluegit-runner -f
sudo -u bluegit-runner docker info
curl -H "Authorization: Bearer $(sudo cat /var/lib/bluegit-runner/ui-token)" http://{{.Listen}}/api/status
curl -X POST -H "Authorization: Bearer …" http://{{.Listen}}/api/pause</code></pre>
  <p>{{call .T "rdoc.more"}} <a href="{{.Server}}/help/runners">{{.Server}}/help/runners</a></p>
</div>
</article>`))
