package server

import (
	"crypto/rand"
	"crypto/subtle"
	"embed"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"html/template"
	"net"
	"net/http"
	"net/url"
	"strings"
	"time"

	"gitlab.com/Timfa/bluegit/internal/backupserver/archive"
)

//go:embed web/*
var webFS embed.FS

var uiTmpl = template.Must(template.New("").Funcs(template.FuncMap{
	"bytes": humanBytes,
	"when": func(t time.Time) string {
		if t.IsZero() {
			return "nog niet"
		}
		return t.Local().Format("2006-01-02 15:04:05")
	},
	"json": func(v any) string { b, _ := json.MarshalIndent(v, "", "  "); return string(b) },
}).ParseFS(webFS, "web/*.html"))

const (
	sessionCookie = "bbsession"
	sessionTTL    = 12 * time.Hour
)

type session struct {
	csrf    string
	expires time.Time
	flash   string
	isErr   bool
}

func randHex(n int) string {
	b := make([]byte, n)
	_, _ = rand.Read(b)
	return hex.EncodeToString(b)
}

func humanBytes(n int64) string {
	const unit = 1024
	if n < unit {
		return fmt.Sprintf("%d B", n)
	}
	div, exp := int64(unit), 0
	for m := n / unit; m >= unit; m /= unit {
		div *= unit
		exp++
	}
	return fmt.Sprintf("%.1f %ciB", float64(n)/float64(div), "KMGTPE"[exp])
}

func (s *Server) session(r *http.Request) (session, bool) {
	c, err := r.Cookie(sessionCookie)
	if err != nil || c.Value == "" {
		return session{}, false
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	sess, ok := s.sessions[c.Value]
	if !ok || s.now().After(sess.expires) {
		delete(s.sessions, c.Value)
		return session{}, false
	}
	return sess, true
}

func (s *Server) setFlash(r *http.Request, msg string, isErr bool) {
	c, err := r.Cookie(sessionCookie)
	if err != nil {
		return
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	if sess, ok := s.sessions[c.Value]; ok {
		sess.flash, sess.isErr = msg, isErr
		s.sessions[c.Value] = sess
	}
}

func (s *Server) takeFlash(r *http.Request) (string, bool) {
	c, err := r.Cookie(sessionCookie)
	if err != nil {
		return "", false
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	sess, ok := s.sessions[c.Value]
	if !ok {
		return "", false
	}
	msg, isErr := sess.flash, sess.isErr
	sess.flash, sess.isErr = "", false
	s.sessions[c.Value] = sess
	return msg, isErr
}

func clientIP(r *http.Request) string {
	h, _, err := net.SplitHostPort(r.RemoteAddr)
	if err != nil {
		return r.RemoteAddr
	}
	return h
}

// loginAllowed: hoogstens 5 foute pogingen per minuut per IP-adres.
func (s *Server) loginAllowed(ip string, failed bool) bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.loginFails == nil {
		s.loginFails = map[string][]time.Time{}
	}
	cut := s.now().Add(-time.Minute)
	keep := s.loginFails[ip][:0]
	for _, t := range s.loginFails[ip] {
		if t.After(cut) {
			keep = append(keep, t)
		}
	}
	if failed {
		keep = append(keep, s.now())
	}
	s.loginFails[ip] = keep
	return len(keep) < 5
}

func (s *Server) mountUI(mux *http.ServeMux) {
	mux.HandleFunc("GET /{$}", s.uiIndex)
	mux.HandleFunc("GET /login", s.uiLoginPage)
	mux.HandleFunc("POST /login", s.uiLogin)
	mux.HandleFunc("POST /logout", s.uiLogout)
	mux.HandleFunc("POST /ui/act/{name}", s.uiAct)
}

func (s *Server) render(w http.ResponseWriter, name string, data any) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Header().Set("Cache-Control", "no-store")
	w.Header().Set("Content-Security-Policy", "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'none'; frame-ancestors 'none'; form-action 'self'")
	w.Header().Set("X-Frame-Options", "DENY")
	if err := uiTmpl.ExecuteTemplate(w, name, data); err != nil {
		s.Log.Error("template", "name", name, "err", err)
	}
}

func (s *Server) uiLoginPage(w http.ResponseWriter, r *http.Request) {
	if _, ok := s.session(r); ok {
		http.Redirect(w, r, "/", http.StatusSeeOther)
		return
	}
	s.render(w, "login.html", map[string]any{"Error": r.URL.Query().Get("fout") != "", "Version": Version})
}

func (s *Server) uiLogin(w http.ResponseWriter, r *http.Request) {
	ip := clientIP(r)
	if !s.loginAllowed(ip, false) {
		http.Error(w, "te veel pogingen, wacht een minuut", http.StatusTooManyRequests)
		return
	}
	tok := strings.TrimSpace(r.PostFormValue("token"))
	if subtle.ConstantTimeCompare([]byte(tok), []byte(s.adminToken)) != 1 {
		s.loginAllowed(ip, true)
		http.Redirect(w, r, "/login?fout=1", http.StatusSeeOther)
		return
	}
	id := randHex(32)
	s.mu.Lock()
	for k, v := range s.sessions {
		if s.now().After(v.expires) {
			delete(s.sessions, k)
		}
	}
	s.sessions[id] = session{csrf: randHex(16), expires: s.now().Add(sessionTTL)}
	s.mu.Unlock()
	http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: id, Path: "/", HttpOnly: true,
		SameSite: http.SameSiteStrictMode, Secure: r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https",
		MaxAge: int(sessionTTL / time.Second)})
	http.Redirect(w, r, "/", http.StatusSeeOther)
}

func (s *Server) uiLogout(w http.ResponseWriter, r *http.Request) {
	if sess, ok := s.session(r); ok && r.PostFormValue("csrf") == sess.csrf {
		c, _ := r.Cookie(sessionCookie)
		s.mu.Lock()
		delete(s.sessions, c.Value)
		s.mu.Unlock()
	}
	http.SetCookie(w, &http.Cookie{Name: sessionCookie, Value: "", Path: "/", MaxAge: -1, HttpOnly: true})
	http.Redirect(w, r, "/login", http.StatusSeeOther)
}

// pageData is wat de webinterface toont: precies de uitkomst van de
// GET-acties uit Actions.
type pageData struct {
	CSRF     string
	Flash    string
	FlashErr bool
	Status   Status
	Config   ConfigView
	Archives []archive.Archive
	Actions  []Action
	Version  string
}

func (s *Server) uiIndex(w http.ResponseWriter, r *http.Request) {
	sess, ok := s.session(r)
	if !ok {
		http.Redirect(w, r, "/login", http.StatusSeeOther)
		return
	}
	d := pageData{CSRF: sess.csrf, Status: s.Status(), Config: s.ConfigView(), Actions: s.Actions(), Version: Version}
	d.Archives, _ = s.archives.List()
	d.Flash, d.FlashErr = s.takeFlash(r)
	s.render(w, "index.html", d)
}

// uiAct voert een actie uit vanuit een formulier, via dezelfde code als de API.
func (s *Server) uiAct(w http.ResponseWriter, r *http.Request) {
	sess, ok := s.session(r)
	if !ok {
		http.Redirect(w, r, "/login", http.StatusSeeOther)
		return
	}
	if err := r.ParseForm(); err != nil {
		http.Error(w, "formulier", 400)
		return
	}
	if subtle.ConstantTimeCompare([]byte(r.PostFormValue("csrf")), []byte(sess.csrf)) != 1 {
		http.Error(w, "CSRF-token klopt niet; laad de pagina opnieuw", http.StatusForbidden)
		return
	}
	a, ok := s.action(r.PathValue("name"))
	if !ok || a.Method == http.MethodGet {
		http.NotFound(w, r)
		return
	}
	in := Input{}
	for k, v := range r.PostForm {
		if k == "csrf" || k == "understood" || len(v) == 0 {
			continue
		}
		in[k] = v[0]
	}
	anchor := "#" + strings.SplitN(a.Name, ".", 2)[0]
	if a.Name == "rollback" && r.PostFormValue("understood") == "" {
		s.setFlash(r, "Vink aan dat je begrijpt dat een rollback niet ongedaan kan worden gemaakt.", true)
		http.Redirect(w, r, "/#archives", http.StatusSeeOther)
		return
	}
	if a.Name == "sync" {
		in["wait"] = "false"
	}
	code, out := a.Do(r.Context(), in)
	msg, isErr := describe(a, code, out)
	s.setFlash(r, msg, isErr)
	http.Redirect(w, r, "/"+anchor, http.StatusSeeOther)
}

func describe(a Action, code int, out any) (string, bool) {
	if code >= 400 {
		switch v := out.(type) {
		case *ConflictError:
			return fmt.Sprintf("%s (vorige: %s, %d archieven). Kies hieronder ‘oude backups wissen’ of ‘nieuwe BlueGit herstellen’ en koppel opnieuw.", v.Error, v.PreviousURL, v.Archives), true
		case map[string]string:
			return a.Title + " mislukt: " + v["error"], true
		}
		return fmt.Sprintf("%s mislukt (HTTP %d)", a.Title, code), true
	}
	switch a.Name {
	case "sync":
		return "Synchronisatie gestart.", false
	case "archive":
		if v, ok := out.(archive.Archive); ok {
			return "Archief gemaakt: " + v.Name, false
		}
	case "prune":
		if v, ok := out.(map[string]any); ok {
			return fmt.Sprintf("Opgeruimd: %d archieven.", len(v["removed"].([]string))), false
		}
	case "rollback":
		return "Rollback gestart. BlueGit herstart zodra de data er staat.", false
	case "config.update":
		if v, ok := out.(ConfigView); ok && v.Restart {
			return "Instellingen opgeslagen. Een deel geldt pas na een herstart.", false
		}
		return "Instellingen opgeslagen.", false
	}
	return a.Title + ": gelukt.", false
}

// UIPath is het formulieradres van een actie in de webinterface.
func UIPath(a Action) string { return "/ui/act/" + url.PathEscape(a.Name) }
