package server

import (
	"encoding/json"
	"errors"
	"io"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/runner"
	"gitlab.com/Timfa/bluegit/internal/store"
)

// RunnerView is één aparte runner in de beheer-UI.
type RunnerView struct {
	ID       int64
	Name     string
	Online   bool
	LastSeen time.Time
	Created  time.Time
	Version  string
	Paused   bool
	Draining bool
}

func runnerViews(rs []store.Runner) []RunnerView {
	now := time.Now()
	out := make([]RunnerView, 0, len(rs))
	for _, r := range rs {
		out = append(out, RunnerView{ID: r.ID, Name: r.Name, Online: r.Online(now), LastSeen: r.LastSeen, Created: r.CreatedAt, Version: r.Version, Paused: r.Paused, Draining: r.Draining})
	}
	return out
}

// Long-poll-duur voor runner-jobaanvragen.
var runnerPollWait = 25 * time.Second

func (s *Server) routeRunners(mux *http.ServeMux) {
	mux.HandleFunc("POST /settings/runners/token", s.userRunnerToken)
	mux.HandleFunc("POST /settings/runners/delete", s.userRunnerDelete)
	mux.HandleFunc("POST /settings/runners/pref", s.userRunnerPref)
	mux.HandleFunc("POST /groups/{path}/runners/token", s.groupRunnerToken)
	mux.HandleFunc("POST /groups/{path}/runners/delete", s.groupRunnerDelete)
	mux.HandleFunc("POST /groups/{path}/runners/options", s.groupRunnerOptions)
	mux.HandleFunc("POST /groups/{path}/runners/optin", s.groupRunnerOptIn)
	mux.HandleFunc("POST /admin/runners/token", s.globalRunnerToken)
	mux.HandleFunc("POST /admin/runners/delete", s.globalRunnerDelete)
	mux.HandleFunc("POST /admin/runners/update", s.globalRunnerUpdate)

	mux.HandleFunc("POST /api/v1/runners/register", s.runnerRegister)
	mux.HandleFunc("POST /api/v1/runner/heartbeat", s.runnerHeartbeat)
	mux.HandleFunc("POST /api/v1/runner/jobs/request", s.runnerRequest)
	mux.HandleFunc("POST /api/v1/runner/jobs/{id}/log", s.runnerLog)
	mux.HandleFunc("GET /api/v1/runner/jobs/{id}/inputs", s.runnerInputs)
	mux.HandleFunc("PUT /api/v1/runner/jobs/{id}/artifacts", s.runnerArtifacts)
	mux.HandleFunc("POST /api/v1/runner/jobs/{id}/finish", s.runnerFinish)
}

// ---- beheer-UI ----

func (s *Server) setRunnerOnce(w http.ResponseWriter, path, plain string) {
	secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
	http.SetCookie(w, &http.Cookie{Name: "bluegit_runner_once", Value: plain, Path: path, MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode})
}

func (s *Server) takeRunnerOnce(w http.ResponseWriter, r *http.Request, path string) string {
	v := cookieVal(r, "bluegit_runner_once")
	if v != "" {
		http.SetCookie(w, &http.Cookie{Name: "bluegit_runner_once", Value: "", Path: path, MaxAge: -1})
	}
	return v
}

func (s *Server) fillUserRunners(w http.ResponseWriter, r *http.Request, v *View, u store.User) {
	rs, _ := s.Store.ListRunners(r.Context(), "user", u.ID)
	v.RunnerList = runnerViews(rs)
	v.RunnerPref = s.Store.UserRunnerPref(r.Context(), u.ID)
	v.NewRunnerToken = s.takeRunnerOnce(w, r, "/settings")
}

func (s *Server) userRunnerToken(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	plain, err := s.Store.CreateRunnerRegToken(r.Context(), "user", u.ID, u.ID)
	if err != nil {
		s.redirect(w, r, "/settings#runners", "", s.trErr(r, err))
		return
	}
	s.setRunnerOnce(w, "/settings", plain)
	s.redirect(w, r, "/settings#runners", s.tr(r, "runner.tokenMade"), "")
}

func (s *Server) userRunnerDelete(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	if err := s.revokeRunner(r.Context(), "user", u.ID, id, false); err != nil {
		s.redirect(w, r, "/settings#runners", "", s.revokeErr(r, err))
		return
	}
	s.redirect(w, r, "/settings#runners", s.tr(r, "runner.revoked"), "")
}

func (s *Server) userRunnerPref(w http.ResponseWriter, r *http.Request) {
	u, ok := s.loginRequired(w, r)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	_ = s.Store.SetUserRunnerPref(r.Context(), u.ID, r.FormValue("pref"))
	s.redirect(w, r, "/settings#runners", s.tr(r, "flash.saved"), "")
}

func (s *Server) fillGroupRunners(w http.ResponseWriter, r *http.Request, v *View, g store.Group) {
	rs, _ := s.Store.ListRunners(r.Context(), "group", g.ID)
	v.RunnerList = runnerViews(rs)
	v.BuiltinFirst = s.Store.GroupBuiltinFirst(r.Context(), g.ID)
	ids, _ := s.Store.RunnerOptIns(r.Context(), g.ID)
	for _, id := range ids {
		if v.User != nil && id == v.User.ID {
			v.RunnerOptIn = true
		}
		if u, err := s.Store.UserByID(r.Context(), id); err == nil {
			v.OptInNames = append(v.OptInNames, u.Username)
		}
	}
	v.NewRunnerToken = s.takeRunnerOnce(w, r, "/groups/"+g.Path)
}

func (s *Server) groupRunnerToken(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back := "/groups/" + g.Path + "?tab=settings#runners"
	plain, err := s.Store.CreateRunnerRegToken(r.Context(), "group", g.ID, s.who(r).User.ID)
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.setRunnerOnce(w, "/groups/"+g.Path, plain)
	s.redirect(w, r, back, s.tr(r, "runner.tokenMade"), "")
}

func (s *Server) groupRunnerDelete(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back := "/groups/" + g.Path + "?tab=settings#runners"
	id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
	if err := s.revokeRunner(r.Context(), "group", g.ID, id, false); err != nil {
		s.redirect(w, r, back, "", s.revokeErr(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "runner.revoked"), "")
}

func (s *Server) groupRunnerOptions(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	_ = s.Store.SetGroupBuiltinFirst(r.Context(), g.ID, r.FormValue("builtin_first") == "1")
	s.redirect(w, r, "/groups/"+g.Path+"?tab=settings#runners", s.tr(r, "flash.saved"), "")
}

// groupRunnerOptIn: een maintainer staat zijn eigen account-runners toe
// voor de groep (of trekt dat in). Alleen voor zichzelf.
func (s *Server) groupRunnerOptIn(w http.ResponseWriter, r *http.Request) {
	g, _, ok := s.guardGroup(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	_ = s.Store.SetRunnerOptIn(r.Context(), g.ID, s.who(r).User.ID, r.FormValue("on") == "1")
	s.redirect(w, r, "/groups/"+g.Path+"?tab=settings#runners", s.tr(r, "flash.saved"), "")
}

// ---- runner-protocol ----

func runnerJSONErr(w http.ResponseWriter, code int, msg string) {
	writeJSON(w, code, map[string]any{"message": msg})
}

func (s *Server) runnerAuth(w http.ResponseWriter, r *http.Request) (store.Runner, bool) {
	h := r.Header.Get("Authorization")
	tok := ""
	if strings.HasPrefix(strings.ToLower(h), "bearer ") {
		tok = strings.TrimSpace(h[7:])
	}
	rn, err := s.Store.RunnerByToken(r.Context(), tok)
	if err != nil {
		runnerJSONErr(w, http.StatusUnauthorized, "invalid runner token")
		return store.Runner{}, false
	}
	if s.Runner == nil || s.StoragePath() == "" {
		runnerJSONErr(w, http.StatusServiceUnavailable, "CI is disabled on this server")
		return store.Runner{}, false
	}
	_ = s.Store.TouchRunner(r.Context(), rn.ID, r.Header.Get("X-Runner-Version"))
	return rn, true
}

func (s *Server) runnerJob(w http.ResponseWriter, r *http.Request, rn store.Runner) (store.Job, bool) {
	id, _ := strconv.ParseInt(r.PathValue("id"), 10, 64)
	job, err := s.Store.JobForRunner(r.Context(), rn.ID, id)
	if err != nil {
		runnerJSONErr(w, http.StatusNotFound, "job not found")
		return store.Job{}, false
	}
	return job, true
}

func (s *Server) runnerRegister(w http.ResponseWriter, r *http.Request) {
	var body struct {
		Token   string `json:"token"`
		Name    string `json:"name"`
		Version string `json:"version"`
	}
	if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&body); err != nil {
		runnerJSONErr(w, http.StatusBadRequest, "invalid JSON")
		return
	}
	rn, plain, err := s.Store.RegisterRunner(r.Context(), strings.TrimSpace(body.Token), body.Name, body.Version)
	if err != nil {
		if errors.Is(err, store.ErrRegToken) {
			runnerJSONErr(w, http.StatusForbidden, err.Error())
			return
		}
		runnerJSONErr(w, http.StatusInternalServerError, "registration failed")
		return
	}
	writeJSON(w, http.StatusCreated, map[string]any{"id": rn.ID, "name": rn.Name, "token": plain})
}

func (s *Server) runnerHeartbeat(w http.ResponseWriter, r *http.Request) {
	rn, ok := s.runnerAuth(w, r)
	if !ok {
		return
	}
	// Optioneel: {"draining": true} als de runner lokaal gepauzeerd is.
	// {"name": "..."} als de naam op de runner zelf is ingesteld (die wint).
	var body struct {
		Draining *bool  `json:"draining"`
		Name     string `json:"name"`
	}
	_ = json.NewDecoder(io.LimitReader(r.Body, 4096)).Decode(&body)
	if body.Draining != nil && *body.Draining != rn.Draining {
		_ = s.Store.SetRunnerDraining(r.Context(), rn.ID, *body.Draining)
	}
	if n := strings.TrimSpace(body.Name); n != "" && n != rn.Name && len(n) <= 63 {
		if upd, err := s.Store.UpdateRunner(r.Context(), rn.OwnerKind, rn.OwnerID, rn.ID, &n, nil); err == nil {
			rn = upd
		}
	}
	writeJSON(w, http.StatusOK, map[string]any{"id": rn.ID, "name": rn.Name, "paused": rn.Paused})
}

func (s *Server) runnerRequest(w http.ResponseWriter, r *http.Request) {
	rn, ok := s.runnerAuth(w, r)
	if !ok {
		return
	}
	deadline := time.Now().Add(runnerPollWait)
	for {
		pl, err := s.Runner.Claim(r.Context(), rn)
		if err != nil {
			runnerJSONErr(w, http.StatusInternalServerError, "claim failed")
			return
		}
		if pl != nil {
			writeJSON(w, http.StatusOK, pl)
			return
		}
		if time.Now().After(deadline) {
			w.WriteHeader(http.StatusNoContent)
			return
		}
		select {
		case <-r.Context().Done():
			return
		case <-time.After(time.Second):
		}
		_ = s.Store.TouchRunner(r.Context(), rn.ID, "")
	}
}

func (s *Server) runnerLog(w http.ResponseWriter, r *http.Request) {
	rn, ok := s.runnerAuth(w, r)
	if !ok {
		return
	}
	job, ok := s.runnerJob(w, r, rn)
	if !ok {
		return
	}
	chunk, _ := io.ReadAll(io.LimitReader(r.Body, 4<<20))
	cancel, err := s.Runner.RemoteLog(r.Context(), job, string(chunk))
	if err != nil {
		runnerJSONErr(w, http.StatusInternalServerError, "log failed")
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"cancel": cancel})
}

func (s *Server) runnerInputs(w http.ResponseWriter, r *http.Request) {
	rn, ok := s.runnerAuth(w, r)
	if !ok {
		return
	}
	job, ok := s.runnerJob(w, r, rn)
	if !ok || job.Status != "running" {
		if ok {
			runnerJSONErr(w, http.StatusConflict, "job is not running")
		}
		return
	}
	dir, err := os.MkdirTemp("", "bluegit-inputs-")
	if err != nil {
		runnerJSONErr(w, http.StatusInternalServerError, "temp dir")
		return
	}
	defer os.RemoveAll(dir)
	if err := s.Runner.RemoteInputs(r.Context(), job, dir); err != nil {
		runnerJSONErr(w, http.StatusInternalServerError, "inputs failed")
		return
	}
	w.Header().Set("Content-Type", "application/gzip")
	_ = runner.WriteTar(w, dir, nil)
}

func (s *Server) runnerArtifacts(w http.ResponseWriter, r *http.Request) {
	rn, ok := s.runnerAuth(w, r)
	if !ok {
		return
	}
	job, ok := s.runnerJob(w, r, rn)
	if !ok || job.Status != "running" {
		if ok {
			runnerJSONErr(w, http.StatusConflict, "job is not running")
		}
		return
	}
	dir, err := os.MkdirTemp("", "bluegit-artifacts-")
	if err != nil {
		runnerJSONErr(w, http.StatusInternalServerError, "temp dir")
		return
	}
	defer os.RemoveAll(dir)
	paths := job.ArtifactPaths
	if paths == nil {
		paths = []string{}
	}
	if err := runner.ReadTar(r.Body, dir, paths, 4<<30); err != nil {
		runnerJSONErr(w, http.StatusBadRequest, "bad archive: "+err.Error())
		return
	}
	if err := s.Runner.RemoteArtifacts(r.Context(), job, dir); err != nil {
		runnerJSONErr(w, http.StatusBadRequest, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
}

func (s *Server) runnerFinish(w http.ResponseWriter, r *http.Request) {
	rn, ok := s.runnerAuth(w, r)
	if !ok {
		return
	}
	job, ok := s.runnerJob(w, r, rn)
	if !ok {
		return
	}
	var body struct {
		Status  string `json:"status"`
		Message string `json:"message"`
	}
	if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body); err != nil {
		runnerJSONErr(w, http.StatusBadRequest, "invalid JSON")
		return
	}
	if err := s.Runner.RemoteFinish(r.Context(), rn, job.ID, body.Status, body.Message); err != nil {
		runnerJSONErr(w, http.StatusInternalServerError, "finish failed")
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
}
