package server

import (
	"context"
	"gitlab.com/Timfa/bluegit/internal/store"
	"html/template"
	"net/http"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/runnercfg"
	"gitlab.com/Timfa/bluegit/internal/update"
)

// Beheer van de ingebouwde runner (Steve) door de sitebeheerder: dezelfde
// instellingen en hetzelfde scherm als de webinterface van bluegit-runner.
// UI op /admin/runner, API op /api/v1/admin/runner/... (beheerder-token).
// Pauze is een drain: lopende jobs lopen af, nieuwe blijven queued (of
// gaan naar een andere runner). De self-update wacht alleen op running
// jobs, dus een gepauzeerde runner houdt een update niet tegen.

func (s *Server) runnerSettingsFile() *runnercfg.File {
	dir := s.StateDir
	if dir == "" {
		dir = s.StoragePath()
	}
	return &runnercfg.File{Path: filepath.Join(dir, "runner-settings.json")}
}

func (s *Server) builtinDefaults() runnercfg.Settings {
	d := runnercfg.Defaults()
	if s.Cfg.CI.Concurrency > 0 {
		d.Concurrency = s.Cfg.CI.Concurrency
	}
	return d
}

func (s *Server) runnerWorkDir() string {
	if p := s.StoragePath(); p != "" {
		return p
	}
	return s.StateDir
}

// ApplyRunnerSettings laadt de opgeslagen instellingen en zet ze live.
// Aan te roepen bij het starten, nadat Runner gezet is.
func (s *Server) ApplyRunnerSettings() error {
	if s.Runner == nil {
		return nil
	}
	if s.Runner.Jobs == nil {
		s.Runner.Jobs = &runnercfg.Tracker{}
	}
	st, err := s.runnerSettingsFile().Load(s.builtinDefaults())
	if err != nil {
		return err
	}
	return s.applyBuiltin(st)
}

func (s *Server) applyBuiltin(st runnercfg.Settings) error {
	if s.Runner == nil {
		return nil
	}
	over, err := st.Overrides(filepath.Join(s.runnerWorkDir(), "runner"), s.Cfg.CI.ImageOverrides())
	if err != nil {
		return err
	}
	s.Runner.Configure(st, over)
	return nil
}

// RunnerMaintenance voert elke 10 minuten het opruimbeleid uit.
func (s *Server) RunnerMaintenance(ctx context.Context) {
	t := time.NewTicker(10 * time.Minute)
	defer t.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-t.C:
			if s.Runner == nil {
				continue
			}
			st, _ := s.runnerSettingsFile().Load(s.builtinDefaults())
			runnercfg.Cleanup(ctx, s.Cfg.CI.Docker, st, s.Runner.Jobs, filepath.Join(s.runnerWorkDir(), "cache"))
		}
	}
}

func (s *Server) builtinStatus() runnercfg.Status {
	docker := runnercfg.PingDocker(context.Background(), s.Cfg.CI.Docker)
	st := runnercfg.Status{
		Kind: "builtin", ServerURL: s.Cfg.BaseURL,
		Online: s.Runner != nil && docker.Reachable, LastContact: time.Now(),
		Docker: docker,
	}
	if s.Runner != nil {
		st.Name = s.Runner.BuiltinName()
	}
	if s.StateDir != "" {
		if u, err := update.ReadStatus(s.StateDir); err == nil && u.SHA != "" {
			st.Version = shortSHA(u.SHA)
		}
	}
	return st
}

func (s *Server) runnerAdmin() *runnercfg.Handler {
	return &runnercfg.Handler{
		Prefix:      "/admin/runner",
		APIBase:     "/api/v1/admin/runner",
		File:        s.runnerSettingsFile(),
		Default:     s.builtinDefaults(),
		Tracker:     s.builtinTracker(),
		WorkDir:     s.runnerWorkDir(),
		BasePresets: s.Cfg.CI.ImageOverrides(),
		Apply:       s.applyBuiltin,
		Status:      s.builtinStatus,
		DocsURL:     "/help/runners#ingebouwde-runner",
		Lang:        s.langOf,
		Auth: func(w http.ResponseWriter, r *http.Request, write bool) bool {
			if strings.HasPrefix(r.URL.Path, "/api/") {
				if !apiUser(r).InstanceAdmin {
					writeJSON(w, http.StatusForbidden, map[string]string{"message": "instance admin only"})
					return false
				}
			} else if ok, _ := s.adminOnly(w, r); !ok {
				return false
			}
			if s.Runner == nil {
				http.Error(w, s.tr(r, "rui.ciOff"), http.StatusNotFound)
				return false
			}
			return true
		},
		CSRF: func(r *http.Request) (string, string) { return "csrf", s.who(r).Session.CSRF },
		CheckCSRF: func(r *http.Request) bool {
			p := s.who(r)
			return p.OK && r.FormValue("csrf") != "" && r.FormValue("csrf") == p.Session.CSRF
		},
		Layout: func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML) {
			v := s.view(w, r, title)
			v.Page = "adminrunner"
			v.Wide = true
			v.RunnerUI = body
			rs, _ := s.Store.ListRunners(r.Context(), store.RunnerGlobal, 0)
			v.RunnerList = runnerViews(rs)
			v.NewRunnerToken = s.takeRunnerOnce(w, r, "/admin")
			s.render(w, "adminrunner", v)
		},
	}
}

func (s *Server) builtinTracker() *runnercfg.Tracker {
	if s.Runner == nil {
		return &runnercfg.Tracker{}
	}
	if s.Runner.Jobs == nil {
		s.Runner.Jobs = &runnercfg.Tracker{}
	}
	return s.Runner.Jobs
}

func (s *Server) apiAdminRunnerStatus(w http.ResponseWriter, r *http.Request) {
	s.runnerAdmin().APIStatus(w, r)
}
func (s *Server) apiAdminRunnerSettings(w http.ResponseWriter, r *http.Request) {
	s.runnerAdmin().APISettings(w, r)
}
func (s *Server) apiAdminRunnerJobs(w http.ResponseWriter, r *http.Request) {
	s.runnerAdmin().APIJobs(w, r)
}
func (s *Server) apiAdminRunnerPause(w http.ResponseWriter, r *http.Request) {
	s.runnerAdmin().APIPause(true)(w, r)
}
func (s *Server) apiAdminRunnerResume(w http.ResponseWriter, r *http.Request) {
	s.runnerAdmin().APIPause(false)(w, r)
}

// mountRunnerAdmin hangt de UI-routes op. De API zit in apiCatalog.
func (s *Server) mountRunnerAdmin(mux *http.ServeMux) {
	h := &lazyRunnerAdmin{s: s}
	for _, p := range []string{"GET /admin/runner", "POST /admin/runner/settings", "POST /admin/runner/recommend", "POST /admin/runner/presets", "POST /admin/runner/presets/delete", "POST /admin/runner/pause", "POST /admin/runner/resume"} {
		mux.Handle(p, h)
	}
}

// lazyRunnerAdmin bouwt de handler per verzoek: s.Runner wordt pas na Handler() gezet.
type lazyRunnerAdmin struct{ s *Server }

func (l *lazyRunnerAdmin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	m := http.NewServeMux()
	l.s.runnerAdmin().Mount(m, false)
	m.ServeHTTP(w, r)
}

// ---- globale runners (beheer) ----

func (s *Server) globalRunnerGuard(w http.ResponseWriter, r *http.Request) bool {
	if ok, _ := s.adminOnly(w, r); !ok {
		return false
	}
	return s.csrfOK(w, r)
}

const globalBack = "/admin/runner#global"

func (s *Server) globalRunnerToken(w http.ResponseWriter, r *http.Request) {
	if !s.globalRunnerGuard(w, r) {
		return
	}
	plain, err := s.Store.CreateRunnerRegToken(r.Context(), store.RunnerGlobal, 0, s.who(r).User.ID)
	if err != nil {
		s.redirect(w, r, globalBack, "", s.trErr(r, err))
		return
	}
	s.setRunnerOnce(w, "/admin", plain)
	s.redirect(w, r, globalBack, s.tr(r, "runner.tokenMade"), "")
}

func (s *Server) globalRunnerID(r *http.Request) int64 {
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	return id
}

func (s *Server) globalRunnerDelete(w http.ResponseWriter, r *http.Request) {
	if !s.globalRunnerGuard(w, r) {
		return
	}
	if err := s.revokeRunner(r.Context(), store.RunnerGlobal, 0, s.globalRunnerID(r), false); err != nil {
		s.redirect(w, r, globalBack, "", s.revokeErr(r, err))
		return
	}
	s.redirect(w, r, globalBack, s.tr(r, "runner.revoked"), "")
}

func (s *Server) globalRunnerUpdate(w http.ResponseWriter, r *http.Request) {
	if !s.globalRunnerGuard(w, r) {
		return
	}
	var name *string
	var paused *bool
	if n := strings.TrimSpace(r.FormValue("name")); n != "" {
		name = &n
	}
	if p := r.FormValue("paused"); p != "" {
		b := p == "1"
		paused = &b
	}
	if _, err := s.Store.UpdateRunner(r.Context(), store.RunnerGlobal, 0, s.globalRunnerID(r), name, paused); err != nil {
		s.redirect(w, r, globalBack, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, globalBack, s.tr(r, "flash.saved"), "")
}
