package server

import (
	"context"
	"errors"
	"net/http"
	"os"
	"path/filepath"
	"time"

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

// De update-poort: zodra een self-update klaarstaat, starten er geen jobs
// meer van pipelines die daarna zijn aangemaakt. Lopende pipelines mogen
// afmaken; de updater wacht tot er niets meer draait (running == 0).
// De release-pipeline zelf blokkeert niets: self_update is de laatste job
// en stopt direct na de POST.
//
// Veiligheidskleppen: na MaxWait gaat de poort vanzelf open (de updater
// geeft dan ook op), en een beheerder kan forceren (update-force), dan
// installeert de updater zonder te wachten.

const forceFile = "update-force"

// DefaultUpdateMaxWait is de standaard maximale wachttijd.
const DefaultUpdateMaxWait = 30 * time.Minute

func (s *Server) updateMaxWait() time.Duration {
	if m := s.Cfg.CI.UpdateMaxWaitMin; m > 0 {
		return time.Duration(m) * time.Minute
	}
	return DefaultUpdateMaxWait
}

// UpdateGate zegt of er een update in afwachting is, en sinds wanneer.
func (s *Server) UpdateGate() (bool, time.Time) {
	if s.StateDir == "" {
		return false, time.Time{}
	}
	st, err := update.ReadStatus(s.StateDir)
	if err != nil || (st.Result != update.ResultWaiting && st.Result != "running") {
		return false, time.Time{}
	}
	since, err := time.Parse(time.RFC3339, st.Time)
	if err != nil {
		return false, time.Time{}
	}
	// wachten + bouwen; daarna is de update mislukt of de dienst herstart
	if time.Since(since) > s.updateMaxWait()+updateRunning {
		return false, time.Time{}
	}
	return true, since
}

// HoldPipeline is de runnerhaak: true = deze pipeline wacht op de update.
func (s *Server) HoldPipeline(p store.Pipeline) bool {
	on, since := s.UpdateGate()
	if on && !p.CreatedAt.Before(since) {
		return true
	}
	_, blocked := s.protectedBlocker(p)
	return blocked
}

// protectedBlocker: een oudere pipeline op dezelfde ref heeft een lopende
// doNotInterrupt-job; deze pipeline start (nog) geen nieuwe jobs.
func (s *Server) protectedBlocker(p store.Pipeline) (store.Job, bool) {
	if s.Store == nil || p.Status == "success" || p.Status == "failed" || p.Status == "canceled" {
		return store.Job{}, false
	}
	return s.Store.ProtectedBlocker(context.Background(), p.RepoID, p.Ref, p.ID)
}

// pipeStatusFor geeft de status voor UI, API en scripts: een wachtende
// pipeline heet waiting_for_update.
func (s *Server) pipeStatusFor(p store.Pipeline) string {
	if p.Status == "queued" || p.Status == "created" {
		if on, since := s.UpdateGate(); on && !p.CreatedAt.Before(since) {
			return "waiting_for_update"
		}
		if _, blocked := s.protectedBlocker(p); blocked {
			return "waiting_for_job"
		}
	}
	return p.Status
}

func (s *Server) updateForced() bool {
	_, err := os.Stat(filepath.Join(s.StateDir, forceFile))
	return err == nil
}

func (s *Server) setUpdateForce(on bool) error {
	p := filepath.Join(s.StateDir, forceFile)
	if !on {
		if err := os.Remove(p); err != nil && !errors.Is(err, os.ErrNotExist) {
			return err
		}
		return nil
	}
	return os.WriteFile(p, []byte(time.Now().UTC().Format(time.RFC3339)+"\n"), 0o640)
}

func (s *Server) countHeld(ctx context.Context) int {
	on, _ := s.UpdateGate()
	if !on || s.Store == nil {
		return 0
	}
	pipes, err := s.Store.ActivePipelines(ctx)
	if err != nil {
		return 0
	}
	n := 0
	for _, p := range pipes {
		if s.HoldPipeline(p) {
			n++
		}
	}
	return n
}

// apiForceUpdate laat een beheerder de wachtende update nu installeren.
func (s *Server) apiForceUpdate(w http.ResponseWriter, r *http.Request) {
	if !apiUser(r).InstanceAdmin {
		s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
		return
	}
	if on, _ := s.UpdateGate(); !on {
		s.writeAPIErr(w, r, fail(409, i18n.E("err.noUpdatePending")))
		return
	}
	if err := s.setUpdateForce(true); err != nil {
		s.writeAPIErr(w, r, fail(500, err))
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"forced": true})
}
