// Package runner voert pipelinejobs uit, elk in een eigen Docker-container.
package runner

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"log/slog"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"time"

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

// Runner plant jobs en stuurt het resultaat door naar webhooks.
type Runner struct {
	Store   *store.Store
	GitBin  string
	Docker  string
	Storage string
	BaseURL string
	Network string
	Timeout time.Duration
	Log     *slog.Logger
	OnEvent func(repoID int64, ev webhook.Event)
	slots   chan struct{}
}

// Loop blijft jobs oppakken tot ctx afloopt.
func (r *Runner) Loop(ctx context.Context, concurrency int) {
	if concurrency < 1 {
		concurrency = 1
	}
	r.slots = make(chan struct{}, concurrency)
	tick := time.NewTicker(2 * time.Second)
	defer tick.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-tick.C:
			r.Tick(ctx)
		}
	}
}

// Tick bekijkt alle open pipelines één keer.
func (r *Runner) Tick(ctx context.Context) {
	pipes, err := r.Store.ActivePipelines(ctx)
	if err != nil {
		r.Log.Error("pipelines", "err", err)
		return
	}
	for _, p := range pipes {
		r.schedule(ctx, p)
	}
}

func (r *Runner) schedule(ctx context.Context, p store.Pipeline) {
	jobs, err := r.Store.JobsByPipeline(ctx, p.ID)
	if err != nil {
		r.Log.Error("jobs", "err", err)
		return
	}
	specs := make([]ci.Job, len(jobs))
	status := map[string]string{}
	for i, j := range jobs {
		specs[i] = ci.Job{Name: j.Name, Stage: j.Stage, Needs: j.Needs, NeedsSet: j.NeedsSet, AllowFailure: j.AllowFailure}
		status[j.Name] = j.Status
	}
	for _, j := range jobs {
		if j.Status != "queued" {
			continue
		}
		switch ci.Gate(specs, status, specs[indexOf(jobs, j.Name)]) {
		case "skip":
			_ = r.Store.SkipJob(ctx, j.ID, "overgeslagen omdat een eerdere job mislukte")
			status[j.Name] = "skipped"
		case "ready":
			ok, err := r.Store.MarkJobRunning(ctx, j.ID)
			if err != nil || !ok {
				continue
			}
			status[j.Name] = "running"
			job := j
			pipe := p
			go r.execute(ctx, pipe, job)
		}
	}
}

func indexOf(jobs []store.Job, name string) int {
	for i, j := range jobs {
		if j.Name == name {
			return i
		}
	}
	return 0
}

func (r *Runner) execute(ctx context.Context, p store.Pipeline, job store.Job) {
	if r.slots != nil {
		r.slots <- struct{}{}
		defer func() { <-r.slots }()
	}
	before, _ := r.Store.PipelineByID(context.Background(), p.RepoID, p.ID)
	logText, err := r.runOne(ctx, p, job)
	status := "success"
	if err != nil {
		status = "failed"
		if logText != "" {
			logText += "\n"
		}
		logText += err.Error() + "\n"
	}
	if ferr := r.Store.FinishJob(context.Background(), job.ID, status, logText); ferr != nil {
		r.Log.Error("job afronden", "err", ferr)
	}
	final, rerr := r.Store.RefreshPipelineStatus(context.Background(), p.ID)
	if rerr != nil {
		r.Log.Error("pipelinestatus", "err", rerr)
		return
	}
	if before.Status != final && (final == "success" || final == "failed") && r.OnEvent != nil {
		kind := webhook.EventPipelineSuccess
		word := "geslaagd"
		if final == "failed" {
			kind = webhook.EventPipelineFailure
			word = "mislukt"
		}
		repo, err := r.Store.RepoByID(context.Background(), p.RepoID)
		if err != nil {
			return
		}
		branch, _ := gitrepo.BranchOfRef(p.Ref)
		if branch == "" {
			branch = strings.TrimPrefix(p.Ref, "refs/heads/")
		}
		r.OnEvent(p.RepoID, webhook.Event{
			Type:       kind,
			Project:    repo.FullPath(),
			Branch:     branch,
			Commit:     p.CommitSHA,
			Summary:    fmt.Sprintf("pipeline #%d voor %s is %s", p.ID, repo.FullPath(), word),
			URL:        strings.TrimRight(r.BaseURL, "/") + "/" + repo.FullPath() + "/-/pipelines/" + fmt.Sprint(p.ID),
			PipelineID: fmt.Sprint(p.ID),
		})
	}
}

func (r *Runner) runOne(ctx context.Context, p store.Pipeline, job store.Job) (string, error) {
	if r.Timeout > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithTimeout(ctx, r.Timeout)
		defer cancel()
	}
	repo, err := r.Store.RepoByID(ctx, p.RepoID)
	if err != nil {
		return "", err
	}
	work := filepath.Join(r.Storage, "work", fmt.Sprint(p.ID), job.Name)
	_ = os.RemoveAll(work)
	if err := os.MkdirAll(work, 0o755); err != nil {
		return "", err
	}
	bare := gitrepo.Dir(r.Storage, repo.OwnerPath, repo.Name)
	if _, err := execOut(ctx, r.GitBin, "clone", "--local", bare, work); err != nil {
		return "", fmt.Errorf("clone: %w", err)
	}
	if _, err := execOut(ctx, r.GitBin, "-C", work, "checkout", "--detach", p.CommitSHA); err != nil {
		return "", fmt.Errorf("checkout %s: %w", p.CommitSHA, err)
	}
	if err := r.materialize(ctx, p, job, work); err != nil {
		return "", err
	}
	scriptPath := filepath.Join(work, ".bluegit-job.sh")
	if err := os.WriteFile(scriptPath, []byte(scriptOf(job.Script)), 0o755); err != nil {
		return "", err
	}
	token, err := r.Store.CreateJobToken(ctx, job.ID)
	if err != nil {
		return "", err
	}
	env, err := r.environment(ctx, repo, p, job, token)
	if err != nil {
		return "", err
	}
	if _, err := exec.LookPath(r.Docker); err != nil {
		return "", fmt.Errorf("docker (%s) is niet beschikbaar; de job draait alleen in een container", r.Docker)
	}
	// -e NAAM zonder waarde laat Docker de variabele uit de omgeving van
	// deze client overnemen. Zo blijft een meerregelige sleutel heel en
	// staat de waarde niet in de proceslijst.
	args := []string{"run", "--rm", "--network", r.Network, "-v", work + ":/workspace", "-w", "/workspace"}
	cmdEnv := append([]string{}, os.Environ()...)
	for k, v := range env {
		args = append(args, "-e", k)
		cmdEnv = append(cmdEnv, k+"="+v)
	}
	args = append(args, "--entrypoint", "sh", job.Image, "/workspace/.bluegit-job.sh")
	cmd := exec.CommandContext(ctx, r.Docker, args...)
	cmd.Env = cmdEnv
	var buf bytes.Buffer
	cmd.Stdout = &buf
	cmd.Stderr = &buf
	err = cmd.Run()
	logText := buf.String()
	if err != nil {
		return logText, fmt.Errorf("container eindigde met een fout: %w", err)
	}
	if err := r.collect(ctx, job, work); err != nil {
		return logText, err
	}
	return logText, nil
}

func scriptOf(lines string) string {
	var b strings.Builder
	b.WriteString("#!/bin/sh\nset -e\ncd /workspace\n")
	b.WriteString(lines)
	if !strings.HasSuffix(lines, "\n") {
		b.WriteByte('\n')
	}
	return b.String()
}

func (r *Runner) materialize(ctx context.Context, p store.Pipeline, job store.Job, work string) error {
	jobs, err := r.Store.JobsByPipeline(ctx, p.ID)
	if err != nil {
		return err
	}
	wanted := map[string]bool{}
	if job.NeedsSet {
		for _, n := range job.Needs {
			wanted[n] = true
		}
	} else {
		stageOrder := map[string]int{}
		n := 0
		for _, j := range jobs {
			if _, ok := stageOrder[j.Stage]; !ok {
				stageOrder[j.Stage] = n
				n++
			}
		}
		my := stageOrder[job.Stage]
		for _, j := range jobs {
			if stageOrder[j.Stage] < my {
				wanted[j.Name] = true
			}
		}
	}
	for _, j := range jobs {
		if !wanted[j.Name] || j.Status != "success" {
			continue
		}
		for _, rel := range j.ArtifactPaths {
			src, err := r.Store.ArtifactPath(ctx, p.ID, j.Name, rel)
			if err != nil {
				continue
			}
			dst := filepath.Join(work, filepath.FromSlash(rel))
			if err := copyFile(src, dst); err != nil {
				return err
			}
		}
	}
	return nil
}

func (r *Runner) collect(ctx context.Context, job store.Job, work string) error {
	var expires *time.Time
	if job.ArtifactExpire > 0 {
		t := time.Now().Add(job.ArtifactExpire)
		expires = &t
	}
	for _, rel := range job.ArtifactPaths {
		src := filepath.Join(work, filepath.FromSlash(rel))
		info, err := os.Stat(src)
		if err != nil || info.IsDir() {
			return fmt.Errorf("artifact %s ontbreekt", rel)
		}
		dst := filepath.Join(r.Storage, "artifacts", fmt.Sprint(job.ID), filepath.FromSlash(rel))
		if err := copyFile(src, dst); err != nil {
			return err
		}
		if err := r.Store.AddArtifact(ctx, job.ID, rel, dst, info.Size(), expires); err != nil {
			return err
		}
	}
	return nil
}

func (r *Runner) environment(ctx context.Context, repo store.Repo, p store.Pipeline, job store.Job, token string) (map[string]string, error) {
	branch := strings.TrimPrefix(p.Ref, "refs/heads/")
	patterns, err := r.Store.ProtectedPatterns(ctx, repo.ID)
	if err != nil {
		return nil, err
	}
	refProtected := access.BranchProtected(patterns, branch)
	env := map[string]string{}
	if repo.OwnerKind == "group" {
		groupSecrets, err := r.Store.SecretValues(ctx, "group", repo.OwnerID, refProtected)
		if err != nil {
			return nil, err
		}
		for k, v := range groupSecrets {
			env[k] = v
		}
	}
	repoSecrets, err := r.Store.SecretValues(ctx, "repo", repo.ID, refProtected)
	if err != nil {
		return nil, err
	}
	for k, v := range repoSecrets {
		env[k] = v
	}
	for k, v := range job.Variables {
		env[k] = v
	}
	env["CI"] = "true"
	env["CI_COMMIT_SHA"] = p.CommitSHA
	env["CI_COMMIT_BRANCH"] = branch
	env["CI_COMMIT_REF"] = p.Ref
	env["CI_PROJECT_PATH"] = repo.FullPath()
	env["CI_PIPELINE_ID"] = fmt.Sprint(p.ID)
	env["CI_JOB_ID"] = fmt.Sprint(job.ID)
	env["CI_JOB_NAME"] = job.Name
	env["CI_JOB_TOKEN"] = token
	env["CI_API_URL"] = strings.TrimRight(r.BaseURL, "/") + "/api/v1"
	return env, nil
}

func copyFile(src, dst string) error {
	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
		return err
	}
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()
	out, err := os.OpenFile(dst, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
	if err != nil {
		return err
	}
	defer out.Close()
	_, err = io.Copy(out, in)
	return err
}

func execOut(ctx context.Context, bin string, args ...string) (string, error) {
	if bin == "" {
		bin = "git"
	}
	cmd := exec.CommandContext(ctx, bin, args...)
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	if err := cmd.Run(); err != nil {
		msg := strings.TrimSpace(stderr.String())
		if msg == "" {
			msg = err.Error()
		}
		return "", fmt.Errorf("%s", msg)
	}
	return stdout.String(), nil
}
