package server

import (
	"context"
	"net/http"
	"os/exec"
	"strings"

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

// planPipeline leest blue-ci-cd.yml en kiest de jobs.
// Een ontbrekend bestand geeft geen jobs en geen fout.
// broken is een kapot bestand; de aanroeper bewaart dan een mislukte pipeline.
func (s *Server) planPipeline(ctx context.Context, repo store.Repo, sha, ref, source, before string, mr *ci.MRInfo) (string, []store.NewJob, error) {
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	raw, err := gitShow(ctx, s.Git, dir, sha, "blue-ci-cd.yml")
	if err != nil || len(raw) == 0 {
		return "", nil, nil
	}
	read := func(path string) ([]byte, error) {
		return gitShow(ctx, s.Git, dir, sha, path)
	}
	spec, err := ci.ParseIn(raw, read)
	if err != nil {
		return "", nil, err
	}
	name, kind := ci.SplitRef(ref)
	title := strings.TrimSpace(gitOne(ctx, s.Git, dir, "log", "-1", "--format=%s", sha))
	files := gitLines(ctx, s.Git, dir, "ls-tree", "-r", "--name-only", sha)
	changed := changedFiles(ctx, s.Git, dir, sha, before, files)
	base := strings.TrimRight(s.Cfg.BaseURL, "/")
	stamp, _ := gitrepo.CommitterTimestamp(ctx, s.Git, dir, sha)
	env := ci.Variables(ci.Ref{
		SHA: sha, FullRef: ref, Name: name, Kind: kind, Title: title, Timestamp: stamp,
		DefaultBranch: repo.DefaultBranch, Source: source, ProjectPath: repo.FullPath(),
		ProjectURL: base + "/" + repo.FullPath(), APIURL: base + "/api/v1", MR: mr,
	})
	ev := ci.Eval{Env: env, Changed: changed, Files: files}
	allow, err := spec.Allow(ev)
	if err != nil {
		return "", nil, err
	}
	if !allow {
		return title, nil, nil
	}
	active, err := spec.Select(ev)
	if err != nil {
		return "", nil, err
	}
	var jobs []store.NewJob
	for i, j := range active {
		vars := map[string]string{}
		for k, v := range spec.Variables {
			vars[k] = v
		}
		for k, v := range j.Variables {
			vars[k] = v
		}
		needs := j.Needs
		if needs == nil {
			needs = []string{}
		}
		paths := j.Artifacts.Paths
		if paths == nil {
			paths = []string{}
		}
		var services []store.Service
		for _, svc := range j.Services {
			services = append(services, store.Service{
				Name: svc.Name, Alias: svc.Alias, Command: svc.Command, Entrypoint: svc.Entrypoint, Variables: svc.Variables,
			})
		}
		jobs = append(jobs, store.NewJob{
			Name: j.Name, Stage: j.Stage, Position: i, Image: j.Image,
			Before: strings.Join(j.Before, "\n"), Script: strings.Join(j.Script, "\n"), After: strings.Join(j.After, "\n"),
			Needs: needs, Optional: j.Optional, NeedsSet: j.NeedsSet,
			Variables: vars, ArtifactPaths: paths, ArtifactExpire: j.Artifacts.ExpireIn,
			AllowFailure: j.AllowFailure, When: j.When, Timeout: j.Timeout, Tags: j.Tags,
			CachePaths: j.Cache.Paths, CacheKey: j.Cache.Key, ResourceGroup: j.ResourceGroup,
			RetryMax: j.Retry.Max, RetryWhen: j.Retry.When, Services: services,
			Environment: j.Environment.Name, EnvironmentURL: j.Environment.URL, Interruptible: j.Interruptible, DoNotInterrupt: j.DoNotInterrupt,
		})
	}
	return title, jobs, nil
}

func gitShow(ctx context.Context, gitBin, dir, sha, path string) ([]byte, error) {
	if path == "" || strings.Contains(path, "..") || strings.HasPrefix(path, "/") {
		return nil, i18n.E("ci.err.rel", path)
	}
	return exec.CommandContext(ctx, gitBin, "-C", dir, "show", sha+":"+path).Output()
}

func (s *Server) startMergeRequestPipelines(ctx context.Context, repo store.Repo, sha, branch, actor, before string) {
	mrs, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch)
	if err != nil {
		return
	}
	for _, mr := range mrs {
		s.startOneMergePipeline(ctx, repo, sha, actor, before, mr)
	}
}

// rerunMergeRequestsOnTarget start een nieuwe merge-request-pipeline op de
// broncommit wanneer de doelbranch zelf een push krijgt.
func (s *Server) rerunMergeRequestsOnTarget(ctx context.Context, repo store.Repo, branch, actor string) {
	mrs, err := s.Store.OpenMergeRequestsByTarget(ctx, repo.ID, branch)
	if err != nil {
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	for _, mr := range mrs {
		sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.SourceBranch)
		if sha == "" {
			continue
		}
		s.startOneMergePipeline(ctx, repo, sha, actor, "", mr)
	}
}

func (s *Server) startOneMergePipeline(ctx context.Context, repo store.Repo, sha, actor, before string, mr store.MergeRequest) {
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	base := strings.TrimRight(s.Cfg.BaseURL, "/")
	info := &ci.MRInfo{
		ID: mr.ID, IID: mr.Number, Title: mr.Title,
		SourceBranch: mr.SourceBranch, TargetBranch: mr.TargetBranch,
		ProjectPath: repo.FullPath(), ProjectURL: base + "/" + repo.FullPath(),
		TargetSHA: gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.TargetBranch),
	}
	s.startPipeline(ctx, repo, sha, "refs/heads/"+mr.SourceBranch, actor, "merge_request_event", before, info)
}

// mergeBlocks zijn de vertaalde redenen waarom mergen nog niet mag.
// Een pipeline is verplicht zodra blue-ci-cd.yml jobs voor deze merge request kiest.
func (s *Server) mergeBlocks(r *http.Request, repo store.Repo, mr store.MergeRequest) []string {
	if mr.Status != "open" {
		return nil
	}
	var blocks []string
	if mr.Draft {
		blocks = append(blocks, s.tr(r, "mr.block.draft"))
	}
	if s.Cfg.CI.Enabled && s.StoragePath() != "" {
		blocks = append(blocks, s.pipelineBlocks(r, repo, mr)...)
	}
	blocks = append(blocks, s.reviewBlocks(r, repo, mr)...)
	if s.StoragePath() != "" {
		dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
		if conflict, known := s.branchConflict(r.Context(), dir, mr.TargetBranch, mr.SourceBranch); known && conflict {
			blocks = append(blocks, s.tr(r, "mr.block.conflict"))
		}
	}
	return blocks
}

func (s *Server) branchConflict(ctx context.Context, dir, target, source string) (conflict, known bool) {
	if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+target) == "" {
		return false, false
	}
	if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+source) == "" {
		return false, false
	}
	conflict, err := gitrepo.Conflicts(ctx, s.Git, dir, "refs/heads/"+target, "refs/heads/"+source)
	if err != nil {
		return false, false
	}
	return conflict, true
}

func (s *Server) pipelineBlocks(r *http.Request, repo store.Repo, mr store.MergeRequest) []string {
	ctx := r.Context()
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.SourceBranch)
	required := false
	if sha != "" {
		info := &ci.MRInfo{
			ID: mr.ID, IID: mr.Number, Title: mr.Title,
			SourceBranch: mr.SourceBranch, TargetBranch: mr.TargetBranch,
			ProjectPath: repo.FullPath(),
		}
		_, jobs, broken := s.planPipeline(ctx, repo, sha, "refs/heads/"+mr.SourceBranch, "merge_request_event", "", info)
		required = broken != nil || len(jobs) > 0
	}
	p, err := s.Store.LatestMergePipeline(ctx, repo.ID, mr.ID)
	if store.IsNotFound(err) {
		if required {
			return []string{s.tr(r, "mr.block.waiting")}
		}
		return nil
	}
	if err != nil {
		return []string{s.tr(r, "mr.block.waiting")}
	}
	jobs, err := s.Store.JobsByPipeline(ctx, p.ID)
	if err != nil {
		return []string{s.tr(r, "mr.block.waiting")}
	}
	switch store.PipelineBlocksMerge(jobs) {
	case "running":
		return []string{s.tr(r, "mr.block.running")}
	case "failed":
		return []string{s.tr(r, "mr.block.failed")}
	case "waiting":
		if required {
			return []string{s.tr(r, "mr.block.waiting")}
		}
	}
	return nil
}

func (s *Server) fillMRPipeline(r *http.Request, v *View, repo store.Repo, mr store.MergeRequest) {
	p, err := s.Store.LatestMergePipeline(r.Context(), repo.ID, mr.ID)
	if err != nil {
		return
	}
	row := s.pipeRow(r, s.langOf(r), repo, p, map[string]store.User{}, s.queueRanks(r.Context()))
	v.MRPipe = &row
}
