package server

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"

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

// PipeRow is één rij in het pipeline-overzicht.
type PipeRow struct {
	ID          int64
	Status      string
	Label       string
	Duration    string
	When        string
	Title       string
	SHA         string
	Short       string
	Ref         string
	RefKind     string
	Source      string
	SourceLabel string
	MRNumber    int64
	Actor       string
	ActorURL    string
	Avatar      string
	Initial     string
	Stages      []StageView
	Failed      bool
	Live        bool
}

// StageView is één bolletje in de stages-kolom.
type StageView struct {
	Name   string
	Status string
	Label  string
	Tip    string
	Jobs   []JobLink
}

// JobLink is een job in een stage-popover of in de zijbalk.
type JobLink struct {
	ID      int64
	Name    string
	Status  string
	Label   string
	Queue   string
	Current bool
	Stage   string
	// DNI: doNotInterrupt staat aan (badge met tooltip).
	DNI bool
}

// CancelView is een annuleerknop met eigen bevestigingsvenster. Force staat
// aan als er een lopende doNotInterrupt-job bij is; de vraag waarschuwt dan.
type CancelView struct {
	Label string
	Ask   string
	OK    string
	Force bool
}

// cancelView bouwt de knop voor jobs die gestopt zouden worden; nil als er
// niets te annuleren valt.
func cancelView(tr func(string, ...any) string, label, ask string, jobs []store.Job) *CancelView {
	open := false
	for _, j := range jobs {
		switch j.Status {
		case "queued", "running", "manual", "created", "pending":
			open = true
		}
	}
	if !open {
		return nil
	}
	v := &CancelView{Label: label, Ask: ask, OK: label}
	if prot := store.ProtectedRunning(jobs); len(prot) > 0 {
		v.Ask = tr("pipe.cancelDNI", jobNames(prot))
		v.OK = tr("pipe.cancelDNIOk")
		v.Force = true
	}
	return v
}

func (s *Server) cancelJobWeb(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	p, job, ok := s.jobFromRequest(w, r, repo)
	if !ok {
		return
	}
	back := repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10) + "/jobs/" + strconv.FormatInt(job.ID, 10)
	if _, err := s.opJobActionForce(r.Context(), u, repo, p.ID, job.ID, "cancel", forceParam(r)); err != nil {
		s.redirect(w, r, back, "", i18n.Text(s.langOf(r), err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.canceled"), "")
}

func (s *Server) cancelPipelineWeb(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	back := repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(id, 10)
	if err := s.opCancelPipeline(r.Context(), u, repo, id, forceParam(r)); err != nil {
		s.redirect(w, r, back, "", i18n.Text(s.langOf(r), err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.canceled"), "")
}

// JobPage is de console van één job.
type JobPage struct {
	Expired         string // uitleg als dit een verlopen handmatige job is
	Job             store.Job
	Runner          string
	Pipe            store.Pipeline
	Name            string
	Status          string
	Label           string
	Actor           string
	ActorURL        string
	Avatar          string
	Initial         string
	When            string
	Duration        string
	Finished        string
	Queued          string
	Timeout         string
	Source          string
	Ref             string
	RefKind         string
	Short           string
	Title           string
	Stage           string
	PipeStatus      string
	PipeLabel       string
	Stages          []string
	Related         []JobLink
	Blocks          []LogBlock
	Running         bool
	LogBytes        int
	Cancel          *CancelView
	CanPlay         bool
	Environment     string
	EnvironmentURL  string
	EnvironmentLink string
	Queue           string
}

// LogBlock is een losse regel of een inklapbare sectie.
type LogBlock struct {
	Section  bool
	Title    string
	Duration string
	Open     bool
	Lines    []LogLine
}

// LogLine is één regel in de console.
type LogLine struct {
	N     int
	Time  string
	Text  string
	Spans []LogSpan
}

func (s *Server) fillPipelines(r *http.Request, v *View, repo store.Repo) {
	lang := s.langOf(r)
	list, _ := s.Store.ListPipelines(r.Context(), repo.ID)
	q := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("q")))
	v.Query = r.URL.Query().Get("q")
	ranks := s.queueRanks(r.Context())
	users := map[string]store.User{}
	for _, p := range list {
		row := s.pipeRow(r, lang, repo, p, users, ranks)
		if q != "" && !pipeMatches(row, q) {
			continue
		}
		if rowLive(row) {
			v.Live = true
		}
		v.PipeRows = append(v.PipeRows, row)
	}
	v.LiveURL = repoURL(repo) + "/-/pipelines"
	if raw := strings.TrimSpace(r.URL.Query().Get("q")); raw != "" {
		v.LiveURL += "?q=" + url.QueryEscape(raw)
	}
}

func rowLive(row PipeRow) bool {
	if row.Status == "pending" || row.Status == "running" {
		return true
	}
	for _, st := range row.Stages {
		if st.Status == "pending" || st.Status == "running" {
			return true
		}
		for _, j := range st.Jobs {
			if j.Status == "pending" || j.Status == "running" {
				return true
			}
		}
	}
	return false
}

func (s *Server) pipeRow(r *http.Request, lang i18n.Lang, repo store.Repo, p store.Pipeline, users map[string]store.User, ranks map[int64]int) PipeRow {
	jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
	name, kind := ci.SplitRef(p.Ref)
	status := displayStatus(s.pipeStatusFor(p), jobs)
	actor, avatar, actorURL := s.actorOf(r, p.Actor, users)
	initial := ""
	if actor != "" {
		initial = strings.ToUpper(actor[:1])
	}
	sourceLabel, mrNumber := s.pipelineSourceLabel(r, repo, p)
	row := PipeRow{
		ID: p.ID, Status: status, Label: s.tr(r, "pipe."+status),
		Duration: pipelineClock(p), When: i18n.Ago(lang, p.CreatedAt.Unix()),
		Title: p.CommitTitle, SHA: p.CommitSHA, Short: shortSHA(p.CommitSHA),
		Ref: name, RefKind: kind, Source: p.Source, SourceLabel: sourceLabel, MRNumber: mrNumber,
		Actor: actor, ActorURL: actorURL, Avatar: avatar, Initial: initial,
		Stages: stageViews(jobs, ranks, func(key string, args ...any) string { return s.tr(r, key, args...) }),
		Failed: jobsFailed(jobs),
	}
	row.Live = rowLive(row)
	return row
}

func jobsFailed(jobs []store.Job) bool {
	for _, j := range jobs {
		if j.Status == "failed" {
			return true
		}
	}
	return false
}

// pipelineSourceLabel benoemt een pipeline die bij een merge request hoort,
// ook wanneer de rij als push is gestart en daarna gekoppeld is.
// Een gewone push zonder merge request krijgt geen extra label.
func (s *Server) pipelineSourceLabel(r *http.Request, repo store.Repo, p store.Pipeline) (string, int64) {
	if p.MRID != 0 {
		var number int64
		if mr, err := s.Store.MergeRequest(r.Context(), repo.ID, p.MRID); err == nil {
			number = mr.Number
		}
		return s.tr(r, "pipe.src.merge_request_event"), number
	}
	if p.Source == "" || p.Source == "push" {
		return "", 0
	}
	key := "pipe.src." + p.Source
	label := s.tr(r, key)
	if label == key {
		label = p.Source
	}
	return label, 0
}

func (s *Server) pipelineSourceText(r *http.Request, repo store.Repo, p store.Pipeline) string {
	label, number := s.pipelineSourceLabel(r, repo, p)
	if label == "" {
		return ""
	}
	if number == 0 {
		return label
	}
	return label + " !" + strconv.FormatInt(number, 10)
}

func (s *Server) actorOf(r *http.Request, name string, cache map[string]store.User) (string, string, string) {
	name = strings.TrimSpace(name)
	if name == "" {
		return "", "", ""
	}
	u, ok := cache[name]
	if !ok {
		found, err := s.Store.UserByUsername(r.Context(), name)
		if err == nil {
			u = found
		}
		cache[name] = u
	}
	if u.ID == 0 {
		return name, "", ""
	}
	return u.Username, u.AvatarURL, "/users/" + u.Username
}

func pipeMatches(row PipeRow, q string) bool {
	bits := []string{row.Label, row.Title, row.SHA, row.Short, row.Ref, row.Actor, row.SourceLabel, strconv.FormatInt(row.ID, 10), row.Status}
	for _, st := range row.Stages {
		bits = append(bits, st.Name)
		for _, j := range st.Jobs {
			bits = append(bits, j.Name)
		}
	}
	for _, b := range bits {
		if strings.Contains(strings.ToLower(b), q) {
			return true
		}
	}
	return false
}

func displayStatus(pipe string, jobs []store.Job) string {
	switch pipe {
	case "failed":
		return "failed"
	case "running":
		return "running"
	case "manual":
		// Alleen handmatige jobs (en wat daarop wacht) zijn over.
		return "blocked"
	case "queued":
		return "pending"
	case "canceled":
		if store.PipelineObsolete(jobs) {
			return "obsolete"
		}
		return "canceled"
	case "waiting_for_update":
		return "waiting_for_update"
	case "waiting_for_job":
		return "waiting_for_job"
	}
	warn := false
	for _, j := range jobs {
		if (j.Status == "failed" || j.Status == "canceled") && j.AllowFailure && !j.Obsolete() {
			warn = true
		}
	}
	if warn {
		return "warning"
	}
	if pipe == "success" {
		return "passed"
	}
	if pipe == "" {
		return "pending"
	}
	return pipe
}

func stageViews(jobs []store.Job, ranks map[int64]int, tr func(string, ...any) string) []StageView {
	var order []string
	by := map[string][]store.Job{}
	for _, j := range jobs {
		if _, ok := by[j.Stage]; !ok {
			order = append(order, j.Stage)
		}
		by[j.Stage] = append(by[j.Stage], j)
	}
	var out []StageView
	for _, name := range order {
		group := by[name]
		status := stageStatus(group)
		label := tr("pipe." + status)
		var links []JobLink
		for _, j := range group {
			st := jobDisplay(j)
			links = append(links, JobLink{
				ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Stage: j.Stage,
				Queue: queueText(tr, ranks, j.ID),
			})
		}
		stip := name + ": " + strings.ToLower(label)
		if status == "obsolete" {
			stip += " (" + tr("pipe.obsolete.tip") + ")"
		}
		out = append(out, StageView{Name: name, Status: status, Label: label, Tip: stip, Jobs: links})
	}
	return out
}

func stageStatus(jobs []store.Job) string {
	pending, failed, warning, running, canceled := false, false, false, false, false
	softCanceled, passed := false, false
	seen := false
	for _, j := range jobs {
		seen = true
		switch {
		case j.Status == "running":
			running = true
		case j.Status == "failed" && !j.AllowFailure:
			failed = true
		case j.Status == "canceled" && !j.AllowFailure:
			canceled = true
		case j.Status == "canceled":
			// allow_failure telt niet als fout, maar een geannuleerde job
			// is nooit geslaagd: alleen-geannuleerd wordt grijs, gemengd
			// met geslaagde jobs een waarschuwing.
			softCanceled = true
		case j.Status == "failed" && j.AllowFailure:
			warning = true
		case j.Status == "success":
			passed = true
		case j.Status == "queued" || j.Status == "manual":
			pending = true
		}
	}
	if !seen {
		return "skipped"
	}
	if running {
		return "running"
	}
	if failed {
		return "failed"
	}
	if canceled || (softCanceled && !passed && !warning && !pending) {
		if store.PipelineObsolete(jobs) || (!canceled && allCanceledObsolete(jobs)) {
			return "obsolete"
		}
		return "canceled"
	}
	if warning || (softCanceled && passed) {
		return "warning"
	}
	if pending {
		return "pending"
	}
	allSkip := true
	for _, j := range jobs {
		if j.Status != "skipped" {
			allSkip = false
		}
	}
	if allSkip {
		return "skipped"
	}
	return "passed"
}

func jobDisplay(j store.Job) string {
	if j.Status == "failed" && j.AllowFailure {
		return "warning"
	}
	if j.Obsolete() {
		return "obsolete"
	}
	switch j.Status {
	case "success":
		return "passed"
	case "queued":
		return "pending"
	case "":
		return "pending"
	default:
		return j.Status
	}
}

func pipelineClock(p store.Pipeline) string {
	end := p.FinishedAt
	if end.IsZero() {
		end = time.Now()
	}
	start := p.StartedAt
	if start.IsZero() {
		start = p.CreatedAt
	}
	if start.IsZero() {
		return ""
	}
	return formatClock(end.Sub(start))
}

func formatClock(d time.Duration) string {
	if d < 0 {
		d = 0
	}
	s := int(d.Seconds())
	return pad2(s/3600) + ":" + pad2((s%3600)/60) + ":" + pad2(s%60)
}

func pad2(n int) string {
	if n < 10 {
		return "0" + strconv.Itoa(n)
	}
	return strconv.Itoa(n)
}

func shortSHA(sha string) string {
	if len(sha) > 8 {
		return sha[:8]
	}
	return sha
}

func (s *Server) showJob(w http.ResponseWriter, r *http.Request) {
	_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	p, job, ok := s.jobFromRequest(w, r, repo)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, job.Name)
	v.Wide = true
	v.Page = "pipelines"
	v.Pipe = &p
	v.JobPage = s.jobPage(r, repo, p, job, role)
	s.render(w, "job", v)
}

func (s *Server) jobLog(w http.ResponseWriter, r *http.Request) {
	_, repo, _, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	_, job, ok := s.jobFromRequest(w, r, repo)
	if !ok {
		return
	}
	if r.URL.Query().Get("raw") == "1" {
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		_, _ = w.Write([]byte(job.Log))
		return
	}
	offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
	if offset < 0 || offset > len(job.Log) {
		offset = 0
	}
	queue := ""
	if job.Status == "queued" {
		tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
		queue = queueText(tr, s.queueRanks(r.Context()), job.ID)
	}
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Cache-Control", "no-store")
	_ = json.NewEncoder(w).Encode(map[string]any{
		"offset": len(job.Log),
		"status": job.Status,
		"text":   job.Log[offset:],
		"queue":  queue,
	})
}

func (s *Server) retryPipeline(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	back := safeRepoBack(repo, r.FormValue("back"))
	if back == "" {
		back = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(id, 10)
	}
	newID, err := s.opRetryPipeline(r.Context(), u, repo, id, r.FormValue("mode"))
	if !s.uiOK(w, r, back, err) {
		return
	}
	dest := back
	if r.FormValue("mode") == "all" {
		dest = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(newID, 10)
	}
	s.redirect(w, r, dest, s.tr(r, "flash.pipeRetry"), "")
}

func safeRepoBack(repo store.Repo, back string) string {
	back = strings.TrimSpace(back)
	prefix := "/" + repo.FullPath()
	if back != prefix && !strings.HasPrefix(back, prefix+"/") {
		return ""
	}
	if strings.Contains(back, "..") || strings.Contains(back, "\\") || strings.Contains(back, "\n") || strings.Contains(back, "?") {
		return ""
	}
	return back
}

func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {
	u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	p, job, ok := s.jobFromRequest(w, r, repo)
	if !ok {
		return
	}
	_, _ = s.opJobAction(r.Context(), u, repo, p.ID, job.ID, "play")
	s.redirect(w, r, repoURL(repo)+"/-/pipelines/"+strconv.FormatInt(p.ID, 10)+"/jobs/"+strconv.FormatInt(job.ID, 10), s.tr(r, "flash.pipeline"), "")
}

func (s *Server) jobFromRequest(w http.ResponseWriter, r *http.Request, repo store.Repo) (store.Pipeline, store.Job, bool) {
	pid, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return store.Pipeline{}, store.Job{}, false
	}
	jid, err := strconv.ParseInt(r.PathValue("job"), 10, 64)
	if err != nil {
		http.NotFound(w, r)
		return store.Pipeline{}, store.Job{}, false
	}
	p, err := s.Store.PipelineByID(r.Context(), repo.ID, pid)
	if err != nil {
		http.NotFound(w, r)
		return store.Pipeline{}, store.Job{}, false
	}
	jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
	for _, j := range jobs {
		if j.ID == jid {
			return p, j, true
		}
	}
	http.NotFound(w, r)
	return store.Pipeline{}, store.Job{}, false
}

func (s *Server) jobPage(r *http.Request, repo store.Repo, p store.Pipeline, job store.Job, role access.Role) *JobPage {
	lang := s.langOf(r)
	jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
	users := map[string]store.User{}
	actor, avatar, actorURL := s.actorOf(r, p.Actor, users)
	initial := ""
	if actor != "" {
		initial = strings.ToUpper(actor[:1])
	}
	name, kind := ci.SplitRef(p.Ref)
	status := jobDisplay(job)
	pipeStatus := displayStatus(s.pipeStatusFor(p), jobs)
	end := job.FinishedAt
	if end.IsZero() && (job.Status == "success" || job.Status == "failed" || job.Status == "skipped") {
		end = p.FinishedAt
	}
	start := job.StartedAt
	dur := ""
	if !start.IsZero() {
		until := end
		if until.IsZero() {
			until = time.Now()
		}
		dur = formatClock(until.Sub(start))
	}
	queued := ""
	if !start.IsZero() && !p.CreatedAt.IsZero() {
		queued = formatClock(start.Sub(p.CreatedAt))
	}
	timeout := formatClock(job.Timeout)
	if job.Timeout == 0 && s.Cfg.CI.TimeoutSec > 0 {
		timeout = formatClock(time.Duration(s.Cfg.CI.TimeoutSec) * time.Second)
	}
	finished := ""
	if !end.IsZero() {
		finished = i18n.Ago(lang, end.Unix())
	}
	ranks := s.queueRanks(r.Context())
	tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
	var stages []string
	seen := map[string]bool{}
	var related []JobLink
	for _, j := range jobs {
		if !seen[j.Stage] {
			seen[j.Stage] = true
			stages = append(stages, j.Stage)
		}
		st := jobDisplay(j)
		related = append(related, JobLink{
			ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Current: j.ID == job.ID, Stage: j.Stage,
			Queue: queueText(tr, ranks, j.ID),
		})
	}
	sourceKey := "pipe.src." + p.Source
	source := s.tr(r, sourceKey)
	if source == sourceKey {
		source = p.Source
	}
	return &JobPage{
		Runner: s.Store.JobRun(r.Context(), job.ID).RunnerName,
		Job:    job, Pipe: p, Name: job.Name, Status: status, Label: s.tr(r, "pipe."+status),
		Actor: actor, ActorURL: actorURL, Avatar: avatar, Initial: initial, When: i18n.Ago(lang, p.CreatedAt.Unix()),
		Duration: dur, Finished: finished, Queued: queued, Timeout: timeout, Source: source,
		Ref: name, RefKind: kind, Short: shortSHA(p.CommitSHA), Title: p.CommitTitle, Stage: job.Stage,
		PipeStatus: pipeStatus, PipeLabel: s.tr(r, "pipe."+pipeStatus),
		Stages: stages, Related: related, Blocks: parseLog(job.Log), Running: job.Status == "running" || job.Status == "queued",
		LogBytes: len(job.Log), CanPlay: job.Status == "manual" && role.CanWriteCode(),
		Expired:     expiredText(tr, job),
		Cancel:      jobCancel(tr, role.CanWriteCode(), job),
		Queue:       queueText(tr, ranks, job.ID),
		Environment: job.Environment, EnvironmentURL: job.EnvironmentURL, EnvironmentLink: safeEnvironmentURL(job.EnvironmentURL),
	}
}

func safeEnvironmentURL(raw string) string {
	if strings.Contains(raw, "$") {
		return ""
	}
	if strings.HasPrefix(raw, "https://") || strings.HasPrefix(raw, "http://") {
		return raw
	}
	return ""
}

func parseLog(raw string) []LogBlock {
	var blocks []LogBlock
	var cur *LogBlock
	n := 0
	flush := func() {
		if cur == nil {
			return
		}
		blocks = append(blocks, *cur)
		cur = nil
	}
	for _, row := range strings.Split(raw, "\n") {
		if row == "" {
			continue
		}
		ts, text := row, row
		if i := strings.IndexByte(row, '\t'); i >= 0 {
			ts, text = row[:i], row[i+1:]
		}
		if strings.HasPrefix(text, "section_start:") {
			flush()
			body := strings.TrimPrefix(text, "section_start:")
			title := body
			if i := strings.IndexByte(body, ':'); i >= 0 {
				title = body[i+1:]
			}
			cur = &LogBlock{Section: true, Title: title, Open: true}
			continue
		}
		if strings.HasPrefix(text, "section_end:") {
			dur := ""
			body := strings.TrimPrefix(text, "section_end:")
			if i := strings.IndexByte(body, '\t'); i >= 0 {
				dur = body[i+1:]
			}
			if cur != nil {
				cur.Duration = dur
				flush()
			}
			continue
		}
		n++
		line := LogLine{N: n, Time: clockOf(ts), Text: text, Spans: ansiSpans(text)}
		if cur != nil {
			cur.Lines = append(cur.Lines, line)
			continue
		}
		blocks = append(blocks, LogBlock{Lines: []LogLine{line}})
	}
	if cur != nil {
		flush()
	}
	return blocks
}

func wantsJSON(r *http.Request) bool {
	return strings.Contains(r.Header.Get("Accept"), "application/json")
}

func jobsLive(pipe string, jobs []store.Job) bool {
	if pipe == "queued" || pipe == "running" {
		return true
	}
	for _, j := range jobs {
		if j.Status == "queued" || j.Status == "running" {
			return true
		}
	}
	return false
}

func linksFor(jobs []store.Job, ranks map[int64]int, tr func(string, ...any) string) []JobLink {
	out := make([]JobLink, 0, len(jobs))
	for _, j := range jobs {
		st := jobDisplay(j)
		out = append(out, JobLink{
			ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Stage: j.Stage,
			Queue: queueText(tr, ranks, j.ID), DNI: j.DoNotInterrupt,
		})
	}
	return out
}

func (s *Server) partial(name string, v View) string {
	var buf bytes.Buffer
	tmpl := s.byLang[v.Lang]
	if tmpl == nil {
		tmpl = s.tmpl
	}
	if tmpl == nil {
		return ""
	}
	if err := tmpl.ExecuteTemplate(&buf, name, v); err != nil && s.Log != nil {
		s.Log.Error("sjabloon", "name", name, "err", err)
	}
	return buf.String()
}

func (s *Server) writePipeList(w http.ResponseWriter, v View) {
	type job struct {
		ID     int64  `json:"id"`
		Name   string `json:"name"`
		Status string `json:"status"`
		Label  string `json:"label"`
		Queue  string `json:"queue"`
	}
	type stage struct {
		Name   string `json:"name"`
		Status string `json:"status"`
		Tip    string `json:"tip"`
		Jobs   []job  `json:"jobs"`
	}
	type row struct {
		ID       int64   `json:"id"`
		Status   string  `json:"status"`
		Label    string  `json:"label"`
		Duration string  `json:"duration"`
		When     string  `json:"when"`
		Stages   []stage `json:"stages"`
		HTML     string  `json:"html"`
	}
	rows := make([]row, 0, len(v.PipeRows))
	for _, pr := range v.PipeRows {
		one := v
		one.PipeRows = []PipeRow{pr}
		item := row{
			ID: pr.ID, Status: pr.Status, Label: pr.Label, Duration: pr.Duration, When: pr.When,
			HTML: s.partial("pipe-rows", one),
		}
		for _, st := range pr.Stages {
			jobs := make([]job, 0, len(st.Jobs))
			for _, j := range st.Jobs {
				jobs = append(jobs, job{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Queue: j.Queue})
			}
			item.Stages = append(item.Stages, stage{Name: st.Name, Status: st.Status, Tip: st.Tip, Jobs: jobs})
		}
		rows = append(rows, item)
	}
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Cache-Control", "no-store")
	_ = json.NewEncoder(w).Encode(map[string]any{"active": v.Live, "rows": rows})
}

func (s *Server) writePipeDetail(w http.ResponseWriter, v View) {
	type job struct {
		ID     int64  `json:"id"`
		Name   string `json:"name"`
		Status string `json:"status"`
		Label  string `json:"label"`
		Stage  string `json:"stage"`
		Queue  string `json:"queue"`
	}
	type stageJob struct {
		ID     int64  `json:"id"`
		Name   string `json:"name"`
		Status string `json:"status"`
		Label  string `json:"label"`
		Queue  string `json:"queue"`
	}
	type stage struct {
		Name   string     `json:"name"`
		Status string     `json:"status"`
		Tip    string     `json:"tip"`
		Jobs   []stageJob `json:"jobs"`
	}
	jobs := make([]job, 0, len(v.PipeJobs))
	for _, j := range v.PipeJobs {
		jobs = append(jobs, job{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Stage: j.Stage, Queue: j.Queue})
	}
	stages := make([]stage, 0, len(v.PipeStages))
	for _, st := range v.PipeStages {
		item := stage{Name: st.Name, Status: st.Status, Tip: st.Tip, Jobs: make([]stageJob, 0, len(st.Jobs))}
		for _, j := range st.Jobs {
			item.Jobs = append(item.Jobs, stageJob{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Queue: j.Queue})
		}
		stages = append(stages, item)
	}
	dur := ""
	html := ""
	if v.Pipe != nil {
		dur = pipelineClock(*v.Pipe)
		if v.Repo != nil {
			head := CommitRow{PipeID: v.Pipe.ID, PipeStages: v.PipeStages}
			html = s.partial("stage-dots", View{Lang: v.Lang, Repo: v.Repo, Head: &head})
		}
	}
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Cache-Control", "no-store")
	_ = json.NewEncoder(w).Encode(map[string]any{
		"active": v.Live, "status": v.PipeStatus, "label": v.PipeLabel,
		"duration": dur, "jobs": jobs, "stages": stages, "html": html,
	})
}

func clockOf(ts string) string {
	if t, err := time.Parse(time.RFC3339, ts); err == nil {
		return t.UTC().Format("15:04:05")
	}
	if len(ts) >= 19 && strings.Contains(ts, "T") {
		return ts[11:19]
	}
	return ""
}

func jobCancel(tr func(string, ...any) string, can bool, job store.Job) *CancelView {
	if !can {
		return nil
	}
	return cancelView(tr, tr("pipe.cancelJob"), tr("pipe.cancelAsk"), []store.Job{job})
}

// allCanceledObsolete: elke geannuleerde job (ook allow_failure) is
// automatisch door een nieuwere pipeline gestopt.
func allCanceledObsolete(jobs []store.Job) bool {
	seen := false
	for _, j := range jobs {
		if j.Status != "canceled" {
			continue
		}
		if !j.Obsolete() {
			return false
		}
		seen = true
	}
	return seen
}

// expiredText legt uit waarom een verlopen handmatige job niet meer start.
func expiredText(tr func(string, ...any) string, j store.Job) string {
	if !expiredManualJob(j) {
		return ""
	}
	if j.Reason == store.ReasonStaleManual {
		return tr("stale.expired.age")
	}
	return tr("stale.expired.superseded")
}
