kandev/apps/backend/internal/backendapp/task_change_request_read.go

package backendapp

import (
	"context"
	"errors"
	"fmt"
	"sort"
	"strings"
	"time"

	"github.com/kandev/kandev/internal/github"
	"github.com/kandev/kandev/internal/gitlab"
	mcphandlers "github.com/kandev/kandev/internal/mcp/handlers"
	"github.com/kandev/kandev/internal/task/models"
	taskservice "github.com/kandev/kandev/internal/task/service"
)

type taskChangeRequestTaskLookup interface {
	GetTask(context.Context, string) (*models.Task, error)
	GetRepository(context.Context, string) (*models.Repository, error)
}

type taskChangeRequestProviderResult struct {
	Configured     bool
	Available      bool
	Status         string
	ReasonCode     string
	Settings       *mcphandlers.TaskChangeRequestProviderSettings
	ChangeRequests []mcphandlers.TaskChangeRequest
	Errors         []error
}

const taskChangeRequestProviderReadFailedReason = "provider_read_failed"

type taskChangeRequestProviderAdapter interface {
	Name() string
	ReadTaskChangeRequests(context.Context, *models.Task) taskChangeRequestProviderResult
}

type githubTaskChangeRequestService interface {
	ListTaskPRs(context.Context, []string) (map[string][]*github.TaskPR, error)
	GetTaskCIOptionsResponse(context.Context, string) (*github.TaskCIOptionsResponse, error)
	GetWorkspaceAuthStatus(context.Context, string, string) (*github.WorkspaceAuthStatus, error)
}

type gitlabTaskChangeRequestService interface {
	ListTaskMRsByTask(context.Context, string) ([]*gitlab.TaskMR, error)
	GetTaskMRAutomationResponse(context.Context, string) (*gitlab.TaskMRAutomationResponse, error)
	GetStatusForWorkspace(context.Context, string) (*gitlab.Status, error)
}

type taskChangeRequestReader struct {
	tasks     taskChangeRequestTaskLookup
	providers []taskChangeRequestProviderAdapter
}

func newTaskChangeRequestReader(
	tasks *taskservice.Service,
	githubProvider githubTaskChangeRequestService,
	gitlabProvider gitlabTaskChangeRequestService,
) *taskChangeRequestReader {
	providers := []taskChangeRequestProviderAdapter{
		newGitHubTaskChangeRequestAdapter(githubProvider),
		newGitLabTaskChangeRequestAdapter(tasks, gitlabProvider),
	}
	return &taskChangeRequestReader{tasks: tasks, providers: providers}
}

func (r *taskChangeRequestReader) GetTaskChangeRequests(
	ctx context.Context, taskID string,
) (mcphandlers.TaskChangeRequestReadResponse, error) {
	taskID = strings.TrimSpace(taskID)
	if taskID == "" {
		return mcphandlers.TaskChangeRequestReadResponse{}, fmt.Errorf("task_id is required")
	}
	if r == nil || r.tasks == nil {
		return mcphandlers.TaskChangeRequestReadResponse{}, fmt.Errorf("task change request task reader is unavailable")
	}
	task, err := r.tasks.GetTask(ctx, taskID)
	if err != nil {
		return mcphandlers.TaskChangeRequestReadResponse{}, err
	}
	if task == nil {
		return mcphandlers.TaskChangeRequestReadResponse{}, fmt.Errorf("task %q not found", taskID)
	}

	providers := append([]taskChangeRequestProviderAdapter(nil), r.providers...)
	sort.SliceStable(providers, func(i, j int) bool { return providers[i].Name() < providers[j].Name() })
	result := mcphandlers.TaskChangeRequestReadResponse{
		TaskID:               taskID,
		Complete:             true,
		ChangeRequests:       []mcphandlers.TaskChangeRequest{},
		ProviderSettings:     []mcphandlers.TaskChangeRequestProviderSettings{},
		ProviderCapabilities: []mcphandlers.TaskChangeRequestProviderCapabilities{},
		Errors:               []mcphandlers.TaskChangeRequestProviderError{},
	}
	for _, provider := range providers {
		appendTaskChangeRequestProviderRead(ctx, task, provider, &result)
	}
	return result, nil
}

func appendTaskChangeRequestProviderRead(
	ctx context.Context,
	task *models.Task,
	provider taskChangeRequestProviderAdapter,
	result *mcphandlers.TaskChangeRequestReadResponse,
) {
	if provider == nil {
		return
	}
	name := provider.Name()
	read := provider.ReadTaskChangeRequests(ctx, task)
	status := normalizeTaskChangeRequestProviderStatus(read.Status, read.Configured, read.Available, len(read.Errors) > 0)
	reasonCode := strings.TrimSpace(read.ReasonCode)
	if len(read.Errors) > 0 {
		status = mcphandlers.TaskChangeRequestProviderStatusFailed
		reasonCode = taskChangeRequestProviderReadFailedReason
	}
	if reasonCode == "" {
		reasonCode = defaultTaskChangeRequestProviderReason(status)
	}
	settings := read.Settings
	if settings == nil {
		settings = &mcphandlers.TaskChangeRequestProviderSettings{}
	}
	settings.Provider = name
	settings.Status = status
	settings.Configured = read.Configured
	settings.Available = read.Available
	settings.ReasonCode = reasonCode
	if settings.PromptScope == "" {
		settings.PromptScope = mcphandlers.TaskChangeRequestPromptScopeTaskProvider
	}
	result.ProviderSettings = append(result.ProviderSettings, *settings)
	result.ProviderCapabilities = append(result.ProviderCapabilities, mcphandlers.TaskChangeRequestProviderCapabilities{
		Provider:     name,
		Status:       status,
		Configured:   read.Configured,
		Available:    read.Available,
		ReasonCode:   reasonCode,
		Capabilities: taskChangeRequestProviderCapabilities(name),
	})
	appendTaskChangeRequests(result, name, read.Available, read.ChangeRequests)
	appendTaskChangeRequestProviderErrors(result, name, read.Errors)
}

func appendTaskChangeRequests(
	result *mcphandlers.TaskChangeRequestReadResponse,
	provider string,
	available bool,
	changes []mcphandlers.TaskChangeRequest,
) {
	for _, change := range changes {
		if change.Provider == "" {
			change.Provider = provider
		}
		decorateTaskChangeRequestCapabilities(&change, available, provider)
		result.ChangeRequests = append(result.ChangeRequests, change)
	}
}

func appendTaskChangeRequestProviderErrors(
	result *mcphandlers.TaskChangeRequestReadResponse, provider string, providerErrors []error,
) {
	for _, providerErr := range providerErrors {
		result.Complete = false
		code, message := sanitizeTaskChangeRequestReadError(providerErr)
		result.Errors = append(result.Errors, mcphandlers.TaskChangeRequestProviderError{
			Provider: provider, Code: code, Message: message,
		})
	}
}

func normalizeTaskChangeRequestProviderStatus(status string, configured, available, failed bool) string {
	status = strings.TrimSpace(strings.ToLower(status))
	switch status {
	case mcphandlers.TaskChangeRequestProviderStatusAvailable,
		mcphandlers.TaskChangeRequestProviderStatusUnavailable,
		mcphandlers.TaskChangeRequestProviderStatusFailed:
		if failed {
			return mcphandlers.TaskChangeRequestProviderStatusFailed
		}
		return status
	}
	if failed {
		return mcphandlers.TaskChangeRequestProviderStatusFailed
	}
	if available {
		return mcphandlers.TaskChangeRequestProviderStatusAvailable
	}
	if configured {
		return mcphandlers.TaskChangeRequestProviderStatusUnavailable
	}
	return mcphandlers.TaskChangeRequestProviderStatusUnavailable
}

func defaultTaskChangeRequestProviderReason(status string) string {
	switch status {
	case mcphandlers.TaskChangeRequestProviderStatusAvailable:
		return ""
	case mcphandlers.TaskChangeRequestProviderStatusFailed:
		return taskChangeRequestProviderReadFailedReason
	default:
		return "provider_not_configured"
	}
}

func sanitizeTaskChangeRequestReadError(err error) (string, string) {
	if err == nil {
		return "", ""
	}
	// Provider and database details stay in the backend log. The MCP caller
	// needs a stable category so it can retry a failed provider read safely.
	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
		return "provider_read_cancelled", "provider read was cancelled"
	}
	return taskChangeRequestProviderReadFailedReason, "provider read failed"
}

func finalizeTaskChangeRequestProviderResult(result *taskChangeRequestProviderResult) {
	if len(result.Errors) == 0 || result.Status == mcphandlers.TaskChangeRequestProviderStatusUnavailable {
		return
	}
	result.Status = mcphandlers.TaskChangeRequestProviderStatusFailed
	result.ReasonCode = taskChangeRequestProviderReadFailedReason
}

var taskChangeRequestCapabilityNames = []string{
	"link",
	"unlink",
	"replace_same_provider",
	"auto_fix",
	"auto_merge",
	"lifecycle_notifications",
	"custom_auto_fix_prompt",
	"auto_fix_outcome_reporting",
}

func taskChangeRequestProviderCapabilities(provider string) map[string]bool {
	capabilities := make(map[string]bool, len(taskChangeRequestCapabilityNames))
	for _, name := range taskChangeRequestCapabilityNames {
		capabilities[name] = name != "auto_fix_outcome_reporting" || provider == mcphandlers.TaskChangeRequestProviderGitHub
	}
	return capabilities
}

func decorateTaskChangeRequestCapabilities(
	change *mcphandlers.TaskChangeRequest, available bool, provider string,
) {
	if change == nil {
		return
	}
	change.Capabilities = taskChangeRequestProviderCapabilities(provider)
	if change.CapabilityReasons == nil {
		change.CapabilityReasons = map[string]string{}
	}
	if !available {
		for name, supported := range change.Capabilities {
			if supported {
				change.Capabilities[name] = false
				change.CapabilityReasons[name] = "provider_unavailable"
			}
		}
		return
	}
	if change.IdentityStatus == "" {
		if change.RepositoryID == nil {
			change.IdentityStatus = mcphandlers.TaskChangeRequestIdentityUnresolved
		} else {
			change.IdentityStatus = mcphandlers.TaskChangeRequestIdentityResolved
		}
	}
	if change.IdentityStatus == mcphandlers.TaskChangeRequestIdentityResolved {
		return
	}
	reason := "identity_unresolved"
	if change.IdentityStatus == mcphandlers.TaskChangeRequestIdentityAmbiguous {
		reason = "identity_ambiguous"
	}
	for name, supported := range change.Capabilities {
		if supported {
			change.Capabilities[name] = false
			change.CapabilityReasons[name] = reason
		}
	}
}

type githubTaskChangeRequestAdapter struct {
	service githubTaskChangeRequestService
}

func newGitHubTaskChangeRequestAdapter(service githubTaskChangeRequestService) taskChangeRequestProviderAdapter {
	return githubTaskChangeRequestAdapter{service: service}
}

func (a githubTaskChangeRequestAdapter) Name() string {
	return mcphandlers.TaskChangeRequestProviderGitHub
}

func (a githubTaskChangeRequestAdapter) ReadTaskChangeRequests(
	ctx context.Context, task *models.Task,
) taskChangeRequestProviderResult {
	result := taskChangeRequestProviderResult{
		Status:     mcphandlers.TaskChangeRequestProviderStatusUnavailable,
		ReasonCode: "provider_not_configured",
	}
	if a.service == nil || task == nil {
		return result
	}
	a.readGitHubTaskChangeRequests(ctx, task, &result)
	a.readGitHubStatus(ctx, task, &result)
	a.readGitHubAutomationSettings(ctx, task, &result)
	finalizeTaskChangeRequestProviderResult(&result)
	return result
}

func (a githubTaskChangeRequestAdapter) readGitHubTaskChangeRequests(
	ctx context.Context, task *models.Task, result *taskChangeRequestProviderResult,
) {
	byTask, err := a.service.ListTaskPRs(ctx, []string{task.ID})
	if err != nil {
		result.Errors = append(result.Errors, err)
		return
	}
	for _, pr := range byTask[task.ID] {
		if pr != nil {
			result.ChangeRequests = append(result.ChangeRequests, githubTaskChangeRequest(pr))
		}
	}
}

func (a githubTaskChangeRequestAdapter) readGitHubStatus(
	ctx context.Context, task *models.Task, result *taskChangeRequestProviderResult,
) {
	authStatus, err := a.service.GetWorkspaceAuthStatus(ctx, task.WorkspaceID, "")
	if err != nil {
		result.Errors = append(result.Errors, err)
		return
	}
	if authStatus == nil {
		return
	}
	result.Configured = authStatus.Automation != nil
	result.Available = authStatus.Authenticated
	if !result.Configured {
		return
	}
	result.Status = mcphandlers.TaskChangeRequestProviderStatusAvailable
	if !result.Available {
		result.Status = mcphandlers.TaskChangeRequestProviderStatusUnavailable
		result.ReasonCode = "credentials_unavailable"
	}
}

func (a githubTaskChangeRequestAdapter) readGitHubAutomationSettings(
	ctx context.Context, task *models.Task, result *taskChangeRequestProviderResult,
) {
	if !result.Configured {
		return
	}
	options, err := a.service.GetTaskCIOptionsResponse(ctx, task.ID)
	if err != nil {
		result.Errors = append(result.Errors, err)
		return
	}
	if options == nil {
		return
	}
	result.Settings = githubTaskChangeRequestSettings(options)
	applyGitHubTaskChangeRequestAutomation(result.ChangeRequests, options)
}

func githubTaskChangeRequest(pr *github.TaskPR) mcphandlers.TaskChangeRequest {
	change := mcphandlers.TaskChangeRequest{
		Provider:       mcphandlers.TaskChangeRequestProviderGitHub,
		Number:         pr.PRNumber,
		URL:            pr.PRURL,
		Title:          pr.PRTitle,
		State:          normalizeTaskChangeRequestState(pr.State),
		ProviderState:  pr.State,
		Draft:          pr.IsDraft,
		BaseRef:        pr.BaseBranch,
		HeadRef:        pr.HeadBranch,
		HeadSHA:        pr.HeadSHA,
		MergedAt:       pr.MergedAt,
		ClosedAt:       pr.ClosedAt,
		UpdatedAt:      taskChangeRequestTimePointer(pr.UpdatedAt),
		IdentityStatus: mcphandlers.TaskChangeRequestIdentityResolved,
	}
	if strings.TrimSpace(pr.RepositoryID) == "" {
		change.IdentityStatus = mcphandlers.TaskChangeRequestIdentityUnresolved
	} else {
		repositoryID := strings.TrimSpace(pr.RepositoryID)
		change.RepositoryID = &repositoryID
	}
	return change
}

func githubTaskChangeRequestSettings(options *github.TaskCIOptionsResponse) *mcphandlers.TaskChangeRequestProviderSettings {
	return &mcphandlers.TaskChangeRequestProviderSettings{
		Provider:               mcphandlers.TaskChangeRequestProviderGitHub,
		AutoFixPromptOverride:  options.AutoFixPromptOverride,
		EffectiveAutoFixPrompt: options.EffectiveAutoFixPrompt,
		UsingDefaultPrompt:     options.UsingDefaultPrompt,
		AutoFixMaxRounds:       options.AutoFixMaxRounds,
		PromptScope:            mcphandlers.TaskChangeRequestPromptScopeTaskProvider,
	}
}

func applyGitHubTaskChangeRequestAutomation(
	changes []mcphandlers.TaskChangeRequest, options *github.TaskCIOptionsResponse,
) {
	optionByIdentity := make(map[string]*github.TaskPRAutomationOptions, len(options.PROptions))
	for _, option := range options.PROptions {
		if option == nil {
			continue
		}
		optionByIdentity[taskChangeRequestIdentityKey(option.RepositoryID, option.PRNumber)] = option
	}
	stateByIdentity := make(map[string]*github.TaskCIPRAutomationState, len(options.PRStates))
	for _, state := range options.PRStates {
		if state == nil {
			continue
		}
		stateByIdentity[taskChangeRequestIdentityKey(state.RepositoryID, state.PRNumber)] = state
	}
	for i := range changes {
		change := &changes[i]
		key := taskChangeRequestIdentityKey(pointerString(change.RepositoryID), change.Number)
		if option := optionByIdentity[key]; option != nil {
			change.Automation = &mcphandlers.TaskChangeRequestAutomation{
				AutoFixEnabled:          boolPointer(option.AutoFixEnabled),
				AutoMergeEnabled:        boolPointer(option.AutoMergeEnabled),
				PromptOnReviewRequested: boolPointer(option.PromptOnReviewRequested),
				PromptOnMerged:          boolPointer(option.PromptOnMerged),
				PromptOnClosed:          boolPointer(option.PromptOnClosed),
			}
		}
		if state := stateByIdentity[key]; state != nil {
			rounds := state.AutoFixRoundCount
			change.AutomationStatus = &mcphandlers.TaskChangeRequestAutomationStatus{
				AutoFixRoundCount: &rounds,
				LastError:         state.LastError,
				StateKnown:        true,
			}
		}
	}
}

type gitlabTaskChangeRequestAdapter struct {
	tasks   taskChangeRequestTaskLookup
	service gitlabTaskChangeRequestService
}

func newGitLabTaskChangeRequestAdapter(
	tasks taskChangeRequestTaskLookup, service gitlabTaskChangeRequestService,
) taskChangeRequestProviderAdapter {
	return gitlabTaskChangeRequestAdapter{tasks: tasks, service: service}
}

func (a gitlabTaskChangeRequestAdapter) Name() string {
	return mcphandlers.TaskChangeRequestProviderGitLab
}

func (a gitlabTaskChangeRequestAdapter) ReadTaskChangeRequests(
	ctx context.Context, task *models.Task,
) taskChangeRequestProviderResult {
	result := taskChangeRequestProviderResult{
		Status:     mcphandlers.TaskChangeRequestProviderStatusUnavailable,
		ReasonCode: "provider_not_configured",
	}
	if a.service == nil || task == nil {
		return result
	}
	a.readGitLabTaskChangeRequests(ctx, task, &result)
	a.readGitLabStatus(ctx, task, &result)
	a.readGitLabAutomationSettings(ctx, task, &result)
	finalizeTaskChangeRequestProviderResult(&result)
	return result
}

func (a gitlabTaskChangeRequestAdapter) readGitLabTaskChangeRequests(
	ctx context.Context, task *models.Task, result *taskChangeRequestProviderResult,
) {
	mrs, err := a.service.ListTaskMRsByTask(ctx, task.ID)
	if err != nil {
		result.Errors = append(result.Errors, err)
		return
	}
	changes, resolveErr := a.gitLabTaskChangeRequestsWithErrors(ctx, task, mrs)
	result.ChangeRequests = changes
	if resolveErr != nil {
		result.Errors = append(result.Errors, resolveErr)
	}
}

func (a gitlabTaskChangeRequestAdapter) readGitLabStatus(
	ctx context.Context, task *models.Task, result *taskChangeRequestProviderResult,
) {
	status, err := a.service.GetStatusForWorkspace(ctx, task.WorkspaceID)
	if err != nil {
		result.Errors = append(result.Errors, err)
		return
	}
	if status == nil {
		return
	}
	if connectionErr := strings.TrimSpace(status.ConnectionError); connectionErr != "" {
		result.Errors = append(result.Errors, errors.New(connectionErr))
	}
	result.Configured = strings.TrimSpace(status.AuthMethod) != "" && strings.TrimSpace(status.AuthMethod) != "none"
	result.Configured = result.Configured || status.TokenConfigured || strings.TrimSpace(status.Username) != ""
	result.Available = status.Authenticated
	if !result.Configured {
		return
	}
	result.Status = mcphandlers.TaskChangeRequestProviderStatusAvailable
	if !result.Available {
		result.Status = mcphandlers.TaskChangeRequestProviderStatusUnavailable
		result.ReasonCode = "credentials_unavailable"
	}
}

func (a gitlabTaskChangeRequestAdapter) readGitLabAutomationSettings(
	ctx context.Context, task *models.Task, result *taskChangeRequestProviderResult,
) {
	if !result.Configured {
		return
	}
	options, err := a.service.GetTaskMRAutomationResponse(ctx, task.ID)
	if err != nil {
		result.Errors = append(result.Errors, err)
		return
	}
	if options == nil {
		return
	}
	result.Settings = gitlabTaskChangeRequestSettings(options)
	applyGitLabTaskChangeRequestAutomation(result.ChangeRequests, options)
}

func (a gitlabTaskChangeRequestAdapter) gitLabTaskChangeRequests(
	ctx context.Context, task *models.Task, mrs []*gitlab.TaskMR,
) []mcphandlers.TaskChangeRequest {
	changes, _ := a.gitLabTaskChangeRequestsWithErrors(ctx, task, mrs)
	return changes
}

func (a gitlabTaskChangeRequestAdapter) gitLabTaskChangeRequestsWithErrors(
	ctx context.Context, task *models.Task, mrs []*gitlab.TaskMR,
) ([]mcphandlers.TaskChangeRequest, error) {
	changes := make([]mcphandlers.TaskChangeRequest, 0, len(mrs))
	pathsByIdentity := make(map[string]map[string]struct{})
	var resolveErrs []error
	for _, mr := range mrs {
		if mr == nil {
			continue
		}
		change, err := a.gitLabTaskChangeRequestWithError(ctx, task, mr)
		if err != nil {
			resolveErrs = append(resolveErrs, err)
		}
		change.ProviderProjectPath = strings.Trim(strings.TrimSpace(mr.ProjectPath), "/")
		change.ProviderRepositoryID = strings.TrimSpace(mr.RepositoryID)
		changes = append(changes, change)
		if change.RepositoryID != nil {
			key := taskChangeRequestIdentityKey(pointerString(change.RepositoryID), change.Number)
			if pathsByIdentity[key] == nil {
				pathsByIdentity[key] = make(map[string]struct{})
			}
			pathsByIdentity[key][change.ProviderProjectPath] = struct{}{}
		}
	}
	for i := range changes {
		change := &changes[i]
		if change.RepositoryID == nil {
			continue
		}
		key := taskChangeRequestIdentityKey(pointerString(change.RepositoryID), change.Number)
		if len(pathsByIdentity[key]) > 1 {
			change.IdentityStatus = mcphandlers.TaskChangeRequestIdentityAmbiguous
		}
	}
	return changes, errors.Join(resolveErrs...)
}

func (a gitlabTaskChangeRequestAdapter) gitLabTaskChangeRequest(
	ctx context.Context, task *models.Task, mr *gitlab.TaskMR,
) mcphandlers.TaskChangeRequest {
	change, _ := a.gitLabTaskChangeRequestWithError(ctx, task, mr)
	return change
}

func (a gitlabTaskChangeRequestAdapter) gitLabTaskChangeRequestWithError(
	ctx context.Context, task *models.Task, mr *gitlab.TaskMR,
) (mcphandlers.TaskChangeRequest, error) {
	change := mcphandlers.TaskChangeRequest{
		Provider:            mcphandlers.TaskChangeRequestProviderGitLab,
		Number:              mr.MRIID,
		URL:                 mr.MRURL,
		Title:               mr.MRTitle,
		State:               normalizeTaskChangeRequestState(mr.State),
		ProviderState:       mr.State,
		ProviderProjectPath: strings.Trim(strings.TrimSpace(mr.ProjectPath), "/"),
		BaseRef:             mr.BaseBranch,
		HeadRef:             mr.HeadBranch,
		HeadSHA:             mr.HeadSHA,
		Draft:               boolPointer(mr.Draft),
		MergedAt:            mr.MergedAt,
		ClosedAt:            mr.ClosedAt,
		UpdatedAt:           taskChangeRequestTimePointer(mr.UpdatedAt),
		IdentityStatus:      mcphandlers.TaskChangeRequestIdentityUnresolved,
	}
	if repositoryID, identityStatus, err := a.resolveGitLabRepositoryIdentityWithError(ctx, task, mr); err != nil {
		return change, err
	} else if repositoryID != "" {
		change.RepositoryID = &repositoryID
		change.IdentityStatus = identityStatus
	} else {
		change.IdentityStatus = identityStatus
	}
	return change, nil
}

func (a gitlabTaskChangeRequestAdapter) resolveGitLabRepositoryIdentity(
	ctx context.Context, task *models.Task, mr *gitlab.TaskMR,
) (string, string) {
	repositoryID, identityStatus, _ := a.resolveGitLabRepositoryIdentityWithError(ctx, task, mr)
	return repositoryID, identityStatus
}

func (a gitlabTaskChangeRequestAdapter) resolveGitLabRepositoryIdentityWithError(
	ctx context.Context, task *models.Task, mr *gitlab.TaskMR,
) (string, string, error) {
	if repositoryID := strings.TrimSpace(mr.RepositoryID); repositoryID != "" {
		return repositoryID, mcphandlers.TaskChangeRequestIdentityResolved, nil
	}
	if a.tasks == nil || task == nil {
		return "", mcphandlers.TaskChangeRequestIdentityUnresolved, nil
	}
	candidates, err := a.gitLabRepositoryCandidatesWithError(ctx, task, mr)
	if err != nil {
		return "", mcphandlers.TaskChangeRequestIdentityUnresolved, err
	}
	switch len(candidates) {
	case 0:
		return "", mcphandlers.TaskChangeRequestIdentityUnresolved, nil
	case 1:
		for repositoryID := range candidates {
			return repositoryID, mcphandlers.TaskChangeRequestIdentityResolved, nil
		}
	default:
		return "", mcphandlers.TaskChangeRequestIdentityAmbiguous, nil
	}
	return "", mcphandlers.TaskChangeRequestIdentityUnresolved, nil
}

func (a gitlabTaskChangeRequestAdapter) gitLabRepositoryCandidates(
	ctx context.Context, task *models.Task, mr *gitlab.TaskMR,
) map[string]struct{} {
	candidates, _ := a.gitLabRepositoryCandidatesWithError(ctx, task, mr)
	return candidates
}

func (a gitlabTaskChangeRequestAdapter) gitLabRepositoryCandidatesWithError(
	ctx context.Context, task *models.Task, mr *gitlab.TaskMR,
) (map[string]struct{}, error) {
	candidates := make(map[string]struct{})
	var lookupErrs []error
	for _, taskRepository := range task.Repositories {
		if taskRepository == nil || strings.TrimSpace(taskRepository.RepositoryID) == "" {
			continue
		}
		repository, err := a.tasks.GetRepository(ctx, taskRepository.RepositoryID)
		if err != nil {
			lookupErrs = append(lookupErrs, err)
			continue
		}
		if repository == nil || repository.WorkspaceID != task.WorkspaceID {
			continue
		}
		if !strings.EqualFold(strings.TrimSpace(repository.Provider), mcphandlers.TaskChangeRequestProviderGitLab) {
			continue
		}
		if normalizeProviderHost(repository.ProviderHost) != normalizeProviderHost(mr.Host) {
			continue
		}
		if !sameGitLabProjectPath(repository, mr.ProjectPath) {
			continue
		}
		candidates[repository.ID] = struct{}{}
	}
	return candidates, errors.Join(lookupErrs...)
}

func sameGitLabProjectPath(repository *models.Repository, projectPath string) bool {
	projectPath = strings.Trim(strings.TrimSpace(projectPath), "/")
	if projectPath == "" {
		return false
	}
	for _, path := range []string{
		strings.Trim(strings.TrimSpace(repository.ProviderOwner)+"/"+strings.TrimSpace(repository.ProviderName), "/"),
		strings.Trim(strings.TrimSpace(repository.ProviderScope)+"/"+strings.TrimSpace(repository.ProviderName), "/"),
	} {
		if path != "/" && path == projectPath {
			return true
		}
	}
	return false
}

func gitlabTaskChangeRequestSettings(options *gitlab.TaskMRAutomationResponse) *mcphandlers.TaskChangeRequestProviderSettings {
	return &mcphandlers.TaskChangeRequestProviderSettings{
		Provider:               mcphandlers.TaskChangeRequestProviderGitLab,
		AutoFixPromptOverride:  options.AutoFixPromptOverride,
		EffectiveAutoFixPrompt: options.EffectiveAutoFixPrompt,
		UsingDefaultPrompt:     options.UsingDefaultPrompt,
		AutoFixMaxRounds:       options.AutoFixMaxRounds,
		PromptScope:            mcphandlers.TaskChangeRequestPromptScopeTaskProvider,
	}
}

func applyGitLabTaskChangeRequestAutomation(
	changes []mcphandlers.TaskChangeRequest, options *gitlab.TaskMRAutomationResponse,
) {
	for i := range changes {
		change := &changes[i]
		for _, option := range options.MROptions {
			if option == nil || option.MRIID != change.Number {
				continue
			}
			if gitLabAutomationRepositoryIDMatches(option.RepositoryID, change) &&
				strings.Trim(strings.TrimSpace(option.ProjectPath), "/") == change.ProviderProjectPath {
				change.Automation = &mcphandlers.TaskChangeRequestAutomation{
					AutoFixEnabled:          boolPointer(option.AutoFixEnabled),
					AutoMergeEnabled:        boolPointer(option.AutoMergeEnabled),
					PromptOnReviewRequested: boolPointer(option.PromptOnReviewRequested),
					PromptOnMerged:          boolPointer(option.PromptOnMerged),
					PromptOnClosed:          boolPointer(option.PromptOnClosed),
				}
				break
			}
		}
		for _, state := range options.MRStates {
			if state == nil || state.MRIID != change.Number {
				continue
			}
			if gitLabAutomationRepositoryIDMatches(state.RepositoryID, change) &&
				strings.Trim(strings.TrimSpace(state.ProjectPath), "/") == change.ProviderProjectPath {
				rounds := state.AutoFixRoundCount
				lastError := state.LastError
				if lastError == nil {
					lastError = state.LastSyncError
				}
				change.AutomationStatus = &mcphandlers.TaskChangeRequestAutomationStatus{
					AutoFixRoundCount: &rounds,
					LastError:         lastError,
					StateKnown:        true,
				}
				break
			}
		}
	}
}

func gitLabAutomationRepositoryIDMatches(repositoryID string, change *mcphandlers.TaskChangeRequest) bool {
	if change == nil {
		return false
	}
	repositoryID = strings.TrimSpace(repositoryID)
	if repositoryID == strings.TrimSpace(change.ProviderRepositoryID) {
		return true
	}
	return repositoryID == strings.TrimSpace(pointerString(change.RepositoryID))
}

func normalizeTaskChangeRequestState(state string) string {
	switch strings.ToLower(strings.TrimSpace(state)) {
	case "open", "opened":
		return "open"
	case "closed":
		return "closed"
	case "merged":
		return "merged"
	default:
		return "unknown"
	}
}

func normalizeProviderHost(host string) string {
	return strings.TrimRight(strings.ToLower(strings.TrimSpace(host)), "/")
}

func taskChangeRequestTimePointer(value time.Time) *time.Time {
	if value.IsZero() {
		return nil
	}
	copy := value
	return &copy
}

func taskChangeRequestIdentityKey(repositoryID string, number int) string {
	return fmt.Sprintf("%s#%d", repositoryID, number)
}

func pointerString(value *string) string {
	if value == nil {
		return ""
	}
	return *value
}

func boolPointer(value bool) *bool {
	copy := value
	return &copy
}