package server

import (
	"context"
	"crypto/subtle"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"sort"
	"strconv"
	"strings"

	"git.timfalken.com/timfa/bluegit-backup/internal/archive"
	"git.timfalken.com/timfa/bluegit-backup/internal/config"
	"git.timfalken.com/timfa/bluegit-backup/internal/mirror"
	"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
)

// Input is de invoer van een actie: JSON-velden, querystring, formulier of
// padwaarden, allemaal als tekst.
type Input map[string]string

// Action is één beheerhandeling. De API, de webinterface en BlueGit lopen
// allemaal via deze lijst, zodat ze precies hetzelfde kunnen.
type Action struct {
	// Name is de naam in de webinterface (/ui/act/<name>).
	Name   string `json:"name"`
	Method string `json:"method"`
	Path   string `json:"path"`
	// Title is de knoptekst of beschrijving.
	Title string `json:"title"`
	// Signed: ook de gekoppelde BlueGit mag dit (ondertekend verzoek).
	Signed bool `json:"bluegit"`
	// Params zijn de padwaarden, bijvoorbeeld {name}.
	Params []string `json:"params,omitempty"`
	// Fields zijn de invoervelden (documentatie en de lijst in /api/v1/admin/actions).
	Fields []string                                       `json:"fields,omitempty"`
	Do     func(ctx context.Context, in Input) (int, any) `json:"-"`
}

// fileResult laat de API een bestand sturen in plaats van JSON.
type fileResult struct{ path, name string }

func errBody(err error) map[string]string { return map[string]string{"error": err.Error()} }

// Actions is de volledige lijst met beheerhandelingen.
func (s *Server) Actions() []Action {
	return []Action{
		{Name: "status", Method: "GET", Path: "/api/v1/admin/status", Title: "Status", Signed: true,
			Do: func(ctx context.Context, in Input) (int, any) { return 200, s.Status() }},
		{Name: "actions", Method: "GET", Path: "/api/v1/admin/actions", Title: "Alle acties", Signed: true,
			Do: func(ctx context.Context, in Input) (int, any) { return 200, map[string]any{"actions": s.Actions()} }},
		{Name: "config", Method: "GET", Path: "/api/v1/admin/config", Title: "Instellingen", Signed: true,
			Do: func(ctx context.Context, in Input) (int, any) { return 200, s.ConfigView() }},
		{Name: "config.update", Method: "PUT", Path: "/api/v1/admin/config", Title: "Instellingen opslaan", Signed: true,
			Fields: fieldKeys(), Do: s.actConfigUpdate},
		{Name: "connect", Method: "POST", Path: "/api/v1/admin/connect", Title: "Koppelen",
			Fields: []string{"url", "key", "on_conflict"}, Do: s.actConnect},
		{Name: "disconnect", Method: "POST", Path: "/api/v1/admin/disconnect", Title: "Ontkoppelen", Signed: true,
			Do: s.actDisconnect},
		{Name: "sync", Method: "POST", Path: "/api/v1/admin/sync", Title: "Nu synchroniseren", Signed: true,
			Fields: []string{"wait"}, Do: s.actSync},
		{Name: "archive", Method: "POST", Path: "/api/v1/admin/archive", Title: "Nu archiveren", Signed: true,
			Do: func(ctx context.Context, in Input) (int, any) {
				a, err := s.ArchiveNow()
				if err != nil {
					return 409, errBody(err)
				}
				return 201, a
			}},
		{Name: "prune", Method: "POST", Path: "/api/v1/admin/prune", Title: "Nu opruimen", Signed: true,
			Do: func(ctx context.Context, in Input) (int, any) {
				removed, err := s.Prune()
				if err != nil {
					return 500, errBody(err)
				}
				if removed == nil {
					removed = []string{}
				}
				return 200, map[string]any{"removed": removed}
			}},
		{Name: "archives", Method: "GET", Path: "/api/v1/admin/archives", Title: "Archieven", Signed: true,
			Do: func(ctx context.Context, in Input) (int, any) {
				list, err := s.archives.List()
				if err != nil {
					return 500, errBody(err)
				}
				return 200, map[string]any{"archives": list}
			}},
		{Name: "archive.download", Method: "GET", Path: "/api/v1/admin/archives/{name}/download", Title: "Downloaden",
			Params: []string{"name"}, Do: func(ctx context.Context, in Input) (int, any) {
				p, err := s.archives.Path(in["name"])
				if err != nil {
					return 404, errBody(err)
				}
				return 200, fileResult{path: p, name: in["name"]}
			}},
		{Name: "archive.delete", Method: "DELETE", Path: "/api/v1/admin/archives/{name}", Title: "Verwijderen", Signed: true,
			Params: []string{"name"}, Do: s.actArchiveDelete},
		{Name: "rollback", Method: "POST", Path: "/api/v1/admin/rollback", Title: "Rollback", Signed: true,
			Fields: []string{"archive", "confirm"}, Do: s.actRollback},
	}
}

func fieldKeys() []string {
	out := make([]string, 0, len(config.Fields))
	for _, f := range config.Fields {
		out = append(out, f.Key)
	}
	return out
}

func (s *Server) action(name string) (Action, bool) {
	for _, a := range s.Actions() {
		if a.Name == name {
			return a, true
		}
	}
	return Action{}, false
}

// ConfigView is GET /api/v1/admin/config.
type ConfigView struct {
	Fields  []ConfigField `json:"fields"`
	DataDir string        `json:"data_dir"`
	// Restart: er staat een wijziging klaar die pas na een herstart geldt.
	Restart bool `json:"restart_pending"`
}

// ConfigField is een veld met zijn waarde.
type ConfigField struct {
	config.Field
	Value string `json:"value"`
}

// ConfigView geeft alle instellingen met hun huidige waarde.
func (s *Server) ConfigView() ConfigView {
	s.mu.Lock()
	defer s.mu.Unlock()
	v := ConfigView{DataDir: s.Cfg.DataDir, Restart: s.restartPending}
	for _, f := range config.Fields {
		val := s.Cfg.Get(f.Key)
		if f.Restart {
			if p, ok := s.settings[f.Key]; ok {
				val = p
			}
		}
		v.Fields = append(v.Fields, ConfigField{Field: f, Value: val})
	}
	return v
}

// UpdateConfig past instellingen toe en bewaart ze in settings.yml. Velden
// met Restart gelden pas na een herstart.
func (s *Server) UpdateConfig(set map[string]string) (ConfigView, error) {
	s.mu.Lock()
	next := s.Cfg
	if err := next.Apply(set); err != nil {
		s.mu.Unlock()
		return ConfigView{}, err
	}
	merged := map[string]string{}
	for k, v := range s.settings {
		merged[k] = v
	}
	for k := range set {
		merged[k] = next.Get(k)
	}
	if err := config.SaveSettings(next.DataDir, merged); err != nil {
		s.mu.Unlock()
		return ConfigView{}, err
	}
	for _, f := range config.Fields {
		if f.Restart {
			if _, ok := set[f.Key]; ok && next.Get(f.Key) != s.Cfg.Get(f.Key) {
				s.restartPending = true
			}
			// De draaiende waarde blijft tot de herstart.
			_ = next.Set(f.Key, s.Cfg.Get(f.Key))
		}
	}
	s.settings = merged
	s.Cfg = next
	s.mu.Unlock()
	s.limiter.SetRate(next.RateLimitKiB << 10)
	keys := make([]string, 0, len(set))
	for k := range set {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	s.Log.Info("instellingen gewijzigd", "keys", strings.Join(keys, ","))
	// Kortere intervallen meteen laten gelden.
	s.Kick()
	return s.ConfigView(), nil
}

func (s *Server) actConfigUpdate(ctx context.Context, in Input) (int, any) {
	set := map[string]string{}
	for k, v := range in {
		set[k] = v
	}
	if len(set) == 0 {
		return 400, errBody(errors.New("geen instellingen meegegeven"))
	}
	v, err := s.UpdateConfig(set)
	if err != nil {
		return 400, errBody(err)
	}
	return 200, v
}

func (s *Server) actConnect(ctx context.Context, in Input) (int, any) {
	res, conflict, err := s.Connect(ctx, ConnectRequest{URL: in["url"], Key: in["key"], OnConflict: in["on_conflict"]})
	if conflict != nil {
		return http.StatusConflict, conflict
	}
	if err != nil {
		var he *mirror.HTTPError
		code := 502
		if errors.As(err, &he) && he.Status == 401 {
			code = 401
		}
		if errors.Is(err, errBadRequest) {
			code = 400
		}
		return code, errBody(err)
	}
	return 200, res
}

// Disconnect vergeet de gekoppelde BlueGit. De kopie en de archieven blijven
// staan; een volgende koppeling met een andere BlueGit vraagt dan weer om
// wissen of herstellen.
func (s *Server) Disconnect() error {
	s.work.Lock()
	defer s.work.Unlock()
	st := s.getState()
	keep := State{InstanceID: st.InstanceID, BlueGitURL: st.BlueGitURL}
	if err := saveState(s.Cfg.DataDir, keep); err != nil {
		return err
	}
	s.mu.Lock()
	s.state = keep
	s.mu.Unlock()
	s.Log.Warn("ontkoppeld", "bluegit", st.BlueGitURL)
	return nil
}

func (s *Server) actDisconnect(ctx context.Context, in Input) (int, any) {
	if !s.getState().Connected() {
		return 409, errBody(errors.New("er is geen BlueGit gekoppeld"))
	}
	if err := s.Disconnect(); err != nil {
		return 500, errBody(err)
	}
	return 200, map[string]any{"connected": false}
}

func (s *Server) actSync(ctx context.Context, in Input) (int, any) {
	if !s.getState().Connected() {
		return 409, errBody(errors.New("geen BlueGit gekoppeld"))
	}
	if in["wait"] == "false" || in["wait"] == "0" {
		s.Kick()
		return 202, map[string]string{"state": "started"}
	}
	stats, err := s.SyncNow(ctx)
	if err != nil {
		return 502, errBody(err)
	}
	return 200, stats
}

func (s *Server) actArchiveDelete(ctx context.Context, in Input) (int, any) {
	name := in["name"]
	if !archive.ValidName(name) {
		return 400, errBody(errors.New("ongeldige archiefnaam"))
	}
	s.work.Lock()
	err := s.archives.Delete(name)
	s.work.Unlock()
	if err != nil {
		return 404, errBody(err)
	}
	s.Log.Info("archief verwijderd met de hand", "archive", name)
	return 200, map[string]string{"deleted": name}
}

func (s *Server) actRollback(ctx context.Context, in Input) (int, any) {
	name := in["archive"]
	if !archive.ValidName(name) {
		return 400, errBody(errors.New("ongeldige archiefnaam"))
	}
	if in["confirm"] != name {
		return 400, errBody(errors.New("bevestig met de archiefnaam in confirm; een rollback kan niet ongedaan worden gemaakt"))
	}
	return s.startRollback(name)
}

// startRollback start een rollback op de achtergrond.
func (s *Server) startRollback(name string) (int, any) {
	if _, err := s.archives.Path(name); err != nil {
		return 404, errBody(err)
	}
	if !s.getState().Connected() {
		return 409, errBody(errors.New("geen BlueGit gekoppeld"))
	}
	s.mu.Lock()
	busy := s.rollback.State == "running"
	if !busy {
		s.rollback = RollbackStatus{State: "running", Archive: name, At: s.now().UTC()}
	}
	s.mu.Unlock()
	if busy {
		return 409, errBody(errors.New("er loopt al een rollback"))
	}
	s.Log.Warn("rollback gestart", "archive", name)
	go func() {
		if err := s.Rollback(context.Background(), name); err != nil {
			s.Log.Error("rollback mislukt", "archive", name, "err", err)
		}
	}()
	return http.StatusAccepted, map[string]string{"state": "running", "archive": name}
}

// ---------- HTTP ----------

// Handler is de webinterface en de HTTP-API.
func (s *Server) Handler() http.Handler {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok\n")) })
	// Van BlueGit, ondertekend (vaste protocolroutes).
	mux.HandleFunc("POST /api/v1/notify", s.signed(s.apiNotify))
	mux.HandleFunc("GET /api/v1/archives", s.signed(s.apiArchives))
	mux.HandleFunc("GET /api/v1/status", s.signed(s.apiStatus))
	mux.HandleFunc("POST /api/v1/rollback", s.signed(s.apiRollback))
	// Beheer: admin.token, een sessie van de webinterface, of BlueGit.
	for _, a := range s.Actions() {
		mux.HandleFunc(a.Method+" "+a.Path, s.apiAction(a))
	}
	mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)
	s.mountUI(mux)
	return securityHeaders(mux)
}

func securityHeaders(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("X-Content-Type-Options", "nosniff")
		w.Header().Set("Referrer-Policy", "same-origin")
		h.ServeHTTP(w, r)
	})
}

// apiAction voert een actie uit voor de API.
func (s *Server) apiAction(a Action) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
		if err != nil {
			writeErr(w, 400, "body")
			return
		}
		if code, msg := s.authorize(r, a, body); code != 0 {
			writeErr(w, code, msg)
			return
		}
		in, err := parseInput(r, body)
		if err != nil {
			writeErr(w, 400, err.Error())
			return
		}
		for _, p := range a.Params {
			in[p] = r.PathValue(p)
		}
		code, out := a.Do(r.Context(), in)
		if f, ok := out.(fileResult); ok {
			w.Header().Set("Content-Type", "application/gzip")
			w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", f.name))
			http.ServeFile(w, r, f.path)
			return
		}
		writeJSON(w, code, out)
	}
}

// authorize: 0 is toegestaan, anders de foutcode.
func (s *Server) authorize(r *http.Request, a Action, body []byte) (int, string) {
	if tok, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer "); ok {
		if subtle.ConstantTimeCompare([]byte(strings.TrimSpace(tok)), []byte(s.adminToken)) == 1 {
			return 0, ""
		}
		return 401, "ongeldig token"
	}
	if r.Header.Get(protocol.HeaderSignature) != "" {
		if !a.Signed {
			return 403, "BlueGit mag dit niet"
		}
		st := s.getState()
		if !st.Connected() {
			return 401, "niet gekoppeld"
		}
		if r.Header.Get(protocol.HeaderInstance) != st.InstanceID {
			return 401, "andere BlueGit-instantie"
		}
		if err := protocol.Verify(r, protocol.SigningSecret(st.Key), body, s.now()); err != nil {
			return 401, err.Error()
		}
		return 0, ""
	}
	if sess, ok := s.session(r); ok {
		if r.Method != http.MethodGet && r.Method != http.MethodHead {
			if subtle.ConstantTimeCompare([]byte(r.Header.Get("X-CSRF-Token")), []byte(sess.csrf)) != 1 {
				return 403, "X-CSRF-Token ontbreekt of klopt niet"
			}
		}
		return 0, ""
	}
	return 401, "admin.token, sessie of BlueGit-handtekening nodig"
}

// parseInput leest de querystring en een JSON-object (waarden als tekst).
func parseInput(r *http.Request, body []byte) (Input, error) {
	in := Input{}
	for k, v := range r.URL.Query() {
		if len(v) > 0 {
			in[k] = v[0]
		}
	}
	if len(strings.TrimSpace(string(body))) == 0 {
		return in, nil
	}
	var raw map[string]any
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, errors.New("ongeldige JSON: verwacht een object")
	}
	for k, v := range raw {
		switch t := v.(type) {
		case string:
			in[k] = t
		case float64:
			in[k] = strconv.FormatFloat(t, 'f', -1, 64)
		case bool:
			in[k] = strconv.FormatBool(t)
		case nil:
			in[k] = ""
		default:
			return nil, fmt.Errorf("veld %s: verwacht tekst, getal of boolean", k)
		}
	}
	return in, nil
}
