package server

import (
	"context"
	"net/http"
	"strconv"
	"strings"
	"time"

	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/store"
)

// Verlopen handmatige jobs: zie store/stale_manual.go voor de regels.

// expiredManualJob is true voor een handmatige job die verlopen is; die kan
// niet meer gestart of opnieuw gestart worden.
func expiredManualJob(j store.Job) bool {
	if j.Status != "canceled" {
		return false
	}
	return j.Reason == store.ReasonStaleManual || (j.Reason == store.ReasonSuperseded && j.When == "manual")
}

// expireSuperseded laat handmatige jobs van oudere pipelines op dezelfde ref
// verlopen zodra een nieuwe pipeline gemaakt is.
func (s *Server) expireSuperseded(ctx context.Context, repoID int64, ref string, keep int64) {
	out, err := s.Store.ExpireSupersededManual(ctx, repoID, ref, keep)
	if err != nil && s.Log != nil {
		s.Log.Error("stale manual", "err", err)
	}
	s.logExpired(ctx, out)
}

func (s *Server) logExpired(ctx context.Context, out []store.ExpiredManual) {
	if s.Log == nil {
		return
	}
	for _, e := range out {
		path := strconv.FormatInt(e.RepoID, 10)
		if r, err := s.Store.RepoByID(ctx, e.RepoID); err == nil {
			path = r.FullPath()
		}
		s.Log.Info("stale manual expired", "repo", path, "pipeline", e.PipelineID, "ref", e.Ref, "jobs", e.Jobs, "reason", e.Reason)
	}
}

// StaleManualSweeper ruimt kort na de start en daarna elk uur verlopen
// handmatige jobs op.
func (s *Server) StaleManualSweeper(ctx context.Context) {
	first := time.NewTimer(time.Minute)
	defer first.Stop()
	t := time.NewTicker(time.Hour)
	defer t.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-first.C:
		case <-t.C:
		}
		out, err := s.Store.SweepStaleManual(ctx, time.Now())
		if err != nil && s.Log != nil {
			s.Log.Error("stale manual sweep", "err", err)
		}
		s.logExpired(ctx, out)
	}
}

func (s *Server) adminPipelines(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok {
		return
	}
	v := s.view(w, r, "title.admin")
	v.Page = "adminpipelines"
	v.StaleDays, _ = s.Store.StaleManualDays(r.Context())
	v.StaleDaysDefault = store.DefaultStaleManualDays
	s.render(w, "adminpipelines", v)
}

func (s *Server) adminPipelinesSave(w http.ResponseWriter, r *http.Request) {
	if ok, _ := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
		return
	}
	n, err := strconv.Atoi(strings.TrimSpace(r.FormValue("stale_manual_days")))
	if err != nil || s.Store.SetStaleManualDays(r.Context(), n) != nil {
		s.redirect(w, r, "/admin/pipelines", "", s.tr(r, "stale.err.days"))
		return
	}
	if s.Log != nil {
		s.Log.Info("admin audit", "by", s.who(r).User.Username, "stale_manual_days", n)
	}
	s.redirect(w, r, "/admin/pipelines", s.tr(r, "flash.saved"), "")
}

func (s *Server) apiAdminPipelineSettings(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	if r.Method == http.MethodPut {
		var in struct {
			Days *int `json:"stale_manual_days"`
		}
		if err := readJSON(r, &in); err != nil || in.Days == nil {
			s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
			return
		}
		if err := s.Store.SetStaleManualDays(r.Context(), *in.Days); err != nil {
			s.writeAPIErr(w, r, fail(400, i18n.E("stale.err.days")))
			return
		}
		if s.Log != nil {
			s.Log.Info("admin audit", "by", apiUser(r).Username, "stale_manual_days", *in.Days)
		}
	}
	n, err := s.Store.StaleManualDays(r.Context())
	if err != nil {
		s.writeAPIErr(w, r, err)
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"stale_manual_days": n, "default": store.DefaultStaleManualDays})
}

func (s *Server) apiAdminExpireStale(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	out, err := s.Store.SweepStaleManual(r.Context(), time.Now())
	s.logExpired(r.Context(), out)
	if err != nil {
		s.writeAPIErr(w, r, err)
		return
	}
	list := []map[string]any{}
	for _, e := range out {
		path := ""
		if rp, err := s.Store.RepoByID(r.Context(), e.RepoID); err == nil {
			path = rp.FullPath()
		}
		list = append(list, map[string]any{"project": path, "pipeline_id": e.PipelineID, "ref": e.Ref, "jobs": e.Jobs, "reason": e.Reason})
	}
	writeJSON(w, http.StatusOK, list)
}
