package server

import (
	"context"
	"net/http"
	"os"
	"path/filepath"
	"strings"

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

func (s *Server) opRunPipeline(ctx context.Context, user store.User, repo store.Repo, ref, source string) (int64, error) {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return 0, err
	}
	if !role.CanWriteCode() {
		return 0, fail(403, i18n.E("err.forbidden"))
	}
	ref = safeRev(ref, repo.DefaultBranch)
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", ref+"^{commit}")
	if sha == "" {
		return 0, fail(400, i18n.E("err.branchMissing"))
	}
	if source == "" {
		source = "api"
	}
	id := s.startPipeline(ctx, repo, sha, "refs/heads/"+ref, user.Username, source, "", nil)
	return id, nil
}

func (s *Server) opJobAction(ctx context.Context, user store.User, repo store.Repo, pipeID, jobID int64, action string) (store.Job, error) {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return store.Job{}, err
	}
	if !role.CanWriteCode() {
		return store.Job{}, fail(403, i18n.E("err.forbidden"))
	}
	p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)
	if err != nil {
		return store.Job{}, notFound(err)
	}
	jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)
	var job store.Job
	found := false
	for _, j := range jobs {
		if j.ID == jobID {
			job = j
			found = true
			break
		}
	}
	if !found {
		return store.Job{}, fail(404, i18n.E("err.notFound"))
	}
	switch action {
	case "play":
		ok, err := s.Store.QueueJob(ctx, job.ID)
		if err != nil {
			return store.Job{}, fail(400, err)
		}
		if !ok {
			return store.Job{}, fail(409, i18n.E("err.jobState"))
		}
	case "retry":
		ok, err := s.Store.RetryJob(ctx, job.ID)
		if err != nil {
			return store.Job{}, fail(400, err)
		}
		if !ok {
			return store.Job{}, fail(409, i18n.E("err.jobState"))
		}
	case "cancel":
		ok, err := s.Store.CancelJob(ctx, job.ID)
		if err != nil {
			return store.Job{}, fail(400, err)
		}
		if !ok {
			return store.Job{}, fail(409, i18n.E("err.jobState"))
		}
		if s.Runner != nil {
			s.Runner.Interrupt([]int64{job.ID})
		}
		_, _ = s.Store.RefreshPipelineStatus(ctx, p.ID)
	default:
		return store.Job{}, fail(400, i18n.E("err.jobState"))
	}
	jobs, _ = s.Store.JobsByPipeline(ctx, p.ID)
	for _, j := range jobs {
		if j.ID == jobID {
			return j, nil
		}
	}
	return job, nil
}

func (s *Server) opRetryPipeline(ctx context.Context, user store.User, repo store.Repo, pipeID int64, mode string) (int64, error) {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return 0, err
	}
	if !role.CanWriteCode() {
		return 0, fail(403, i18n.E("err.forbidden"))
	}
	p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)
	if err != nil {
		return 0, notFound(err)
	}
	switch mode {
	case "all":
		id, err := s.Store.ClonePipeline(ctx, repo.ID, p.ID)
		if err != nil {
			if store.IsNotFound(err) {
				return 0, notFound(err)
			}
			return 0, fail(400, err)
		}
		return id, nil
	case "failed":
		ok, err := s.Store.RetryFailedJobs(ctx, p.ID)
		if err != nil {
			return 0, fail(400, err)
		}
		if !ok {
			return 0, fail(409, i18n.E("err.pipeNoFailed"))
		}
		return p.ID, nil
	default:
		return 0, fail(400, i18n.E("err.pipeRetryMode"))
	}
}

func (s *Server) opCancelPipeline(ctx context.Context, user store.User, repo store.Repo, pipeID int64) error {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return err
	}
	if !role.CanWriteCode() {
		return fail(403, i18n.E("err.forbidden"))
	}
	p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)
	if err != nil {
		return notFound(err)
	}
	jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)
	var running []int64
	for _, j := range jobs {
		if j.Status == "queued" || j.Status == "running" || j.Status == "manual" || j.Status == "pending" || j.Status == "created" {
			ok, _ := s.Store.CancelJob(ctx, j.ID)
			if ok && (j.Status == "running" || j.Status == "queued") {
				running = append(running, j.ID)
			}
		}
	}
	if s.Runner != nil {
		s.Runner.Interrupt(running)
	}
	_, _ = s.Store.RefreshPipelineStatus(ctx, p.ID)
	return nil
}

func (s *Server) opLintCI(r *http.Request, repo store.Repo, body, ref string) (map[string]any, error) {
	if len(body) > ciMaxBytes {
		return nil, fail(400, i18n.E("edit.fail"))
	}
	ref = safeRev(ref, repo.DefaultBranch)
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref))
	lines := make([]string, len(model.Rows))
	var bad []int
	for i, row := range model.Rows {
		lines[i] = string(row.HTML)
		if row.Bad {
			bad = append(bad, row.N)
		}
	}
	return map[string]any{
		"status": model.Status, "statusClass": model.Class, "errors": model.Errors,
		"warnings": model.Warnings, "issues": model.Issues, "lines": lines, "bad": bad,
	}, nil
}

func (s *Server) opSaveCI(ctx context.Context, user store.User, repo store.Repo, base, branch, message, body string, openMR bool) (string, int64, error) {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return "", 0, err
	}
	base = safeRev(base, repo.DefaultBranch)
	if !validBranchName(branch) {
		return "", 0, fail(400, i18n.E("edit.badBranch"))
	}
	if len(body) > ciMaxBytes {
		return "", 0, fail(400, i18n.E("edit.fail"))
	}
	patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
	if openMR && (branch == base || access.BranchProtected(patterns, branch)) {
		return "", 0, fail(400, i18n.E("edit.badBranch"))
	}
	sha, err := s.opWriteFiles(ctx, user, repo, role, branch, base, message, "", map[string]string{ciFile: body}, nil)
	if err != nil {
		return "", 0, err
	}
	if !openMR {
		return sha, 0, nil
	}
	existing, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch)
	if err != nil {
		return sha, 0, fail(400, err)
	}
	if len(existing) > 0 {
		return sha, existing[0].Number, nil
	}
	mr, err := s.opCreateMR(ctx, user, repo, message, "", branch, base, false)
	if err != nil {
		return sha, 0, err
	}
	return sha, mr.Number, nil
}

func (s *Server) opPublishRelease(ctx context.Context, repo store.Repo, author store.User, job store.Job, req releaseRequest) (int64, error) {
	if s.StoragePath() == "" {
		return 0, fail(503, i18n.E("err.noStorage"))
	}
	if err := names.ValidTag(req.Tag); err != nil {
		return 0, fail(400, err)
	}
	if !safeSHA(req.Commit) {
		return 0, fail(400, i18n.E("err.commitAbsent"))
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if !gitrepo.HasCommit(ctx, s.Git, dir, req.Commit) {
		return 0, fail(400, i18n.E("err.commitMissing"))
	}
	if req.Name == "" {
		req.Name = req.Tag
	}
	if job.ID == 0 && len(req.Assets) > 0 {
		return 0, fail(400, i18n.E("err.assetsJob"))
	}
	var assets []store.ReleaseAsset
	for _, a := range req.Assets {
		if a.Name == "" {
			a.Name = filepath.Base(a.Path)
		}
		if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" {
			return 0, fail(400, i18n.E("err.assetName"))
		}
		src, err := s.Store.ArtifactPath(ctx, job.PipelineID, a.Job, a.Path)
		if err != nil {
			return 0, fail(400, i18n.E("err.artifactMissing", a.Job, a.Path))
		}
		info, err := os.Stat(src)
		if err != nil {
			return 0, fail(400, i18n.E("err.assetDisk"))
		}
		dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name)
		if err := copyRelease(src, dst); err != nil {
			return 0, fail(500, i18n.E("err.assetCopy"))
		}
		assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: info.Size()})
	}
	if err := s.postReceive(ctx, repo, author, dir, func() error {
		return gitrepo.Tag(ctx, s.Git, dir, req.Tag, req.Commit, req.Name)
	}); err != nil {
		return 0, fail(400, i18n.E("err.tagFail", err.Error()))
	}
	authorID := author.ID
	id, err := s.Store.CreateRelease(ctx, repo.ID, req.Tag, req.Commit, req.Name, req.Body, authorID, job.ID, assets)
	if err != nil {
		return 0, fail(400, err)
	}
	s.Dispatch(repo.ID, s.releaseEvent(repo, req.Tag, req.Name, req.Commit, assets))
	return id, nil
}

func (s *Server) opCIFile(ctx context.Context, repo store.Repo, ref string) (string, error) {
	ref = safeRev(ref, repo.DefaultBranch)
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	body := gitOne(ctx, s.Git, dir, "show", ref+":"+ciFile)
	return body, nil
}
