package taskboard

import (
	"context"
	"strings"

	"github.com/tidbcloud/AgentTeam/internal/coredb"
	"github.com/tidbcloud/AgentTeam/internal/store/coordinator"
)

func (store *Store) AddTaskCheckpoint(ctx context.Context, request AddTaskCheckpointRequest) (AddTaskCheckpointResponse, error) {
	var out0 AddTaskCheckpointResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).AddTaskCheckpoint(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) SendTaskScopeMessage(ctx context.Context, request SendTaskScopeMessageRequest) (SendTaskScopeMessageResponse, error) {
	var out0 SendTaskScopeMessageResponse
	txCtx := ctx
	err := coordinator.New(store.db).Run(ctx, "send task scope message", func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).SendTaskScopeMessage(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) AddTaskCollaborator(ctx context.Context, request AddTaskCollaboratorRequest) (AddTaskCollaboratorResponse, error) {
	var out0 AddTaskCollaboratorResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).AddTaskCollaborator(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ApproveTaskReview(ctx context.Context, request ApproveTaskReviewRequest) (TaskReviewDecisionResponse, error) {
	var out0 TaskReviewDecisionResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ApproveTaskReview(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) BlockTask(ctx context.Context, request BlockTaskRequest) (BlockTaskResponse, error) {
	var out0 BlockTaskResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BlockTask(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	if out0.Changed || request.Context.principalType() == PrincipalTypeUser {
		store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	}
	return out0, nil
}

func (store *Store) BlockTaskForAgent(ctx context.Context, agent AgentActor, channel string, taskNumber int64, input TaskBlockInput) (Task, bool, error) {
	var out0 Task
	var out1 bool
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, out1, err = store.InTx(tx).BlockTaskForAgent(ctx, agent, BoardRef{Channel: channel}, taskNumber, input)
		return err
	})
	if err != nil {
		return out0, out1, err
	}
	return out0, out1, nil
}

func (store *Store) BlockTaskForUser(ctx context.Context, userID string, workspaceID string, taskID string, input TaskBlockInput) (Task, bool, error) {
	var out0 Task
	var out1 bool
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, out1, err = store.InTx(tx).BlockTaskForUser(ctx, userID, workspaceID, taskID, input)
		return err
	})
	if err != nil {
		return out0, out1, err
	}
	return out0, out1, nil
}

func (store *Store) BrowseChannelBoardForUser(ctx context.Context, userID string, workspaceID string, channelID string, query TaskBrowseQuery, columnCursors map[string]TaskBrowseCursor, countFirstDone bool) (TaskBoardBrowsePage, error) {
	var out0 TaskBoardBrowsePage
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BrowseChannelBoardForUser(ctx, userID, workspaceID, channelID, query, columnCursors, countFirstDone)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) BrowseChannelRowsForUser(ctx context.Context, userID string, workspaceID string, channelID string, query TaskBrowseQuery) (TaskRowBrowsePage, error) {
	var out0 TaskRowBrowsePage
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BrowseChannelRowsForUser(ctx, userID, workspaceID, channelID, query)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) BrowseChannelTasks(ctx context.Context, request BrowseChannelTasksRequest) (TaskRowBrowsePage, error) {
	var out0 TaskRowBrowsePage
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BrowseChannelTasks(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) BrowseTaskBoard(ctx context.Context, request BrowseTaskBoardRequest) (TaskBoardBrowsePage, error) {
	var out0 TaskBoardBrowsePage
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BrowseTaskBoard(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) BrowseWorkspaceRowsForUser(ctx context.Context, userID string, workspaceID string, query TaskBrowseQuery) (TaskRowBrowsePage, error) {
	var out0 TaskRowBrowsePage
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BrowseWorkspaceRowsForUser(ctx, userID, workspaceID, query)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) BrowseWorkspaceBoardForUser(ctx context.Context, userID string, workspaceID string, query TaskBrowseQuery, columnCursors map[string]TaskBrowseCursor, countFirstDone bool) (TaskBoardBrowsePage, error) {
	var out0 TaskBoardBrowsePage
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BrowseWorkspaceBoardForUser(ctx, userID, workspaceID, query, columnCursors, countFirstDone)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) BrowseWorkspaceTasks(ctx context.Context, request BrowseWorkspaceTasksRequest) (TaskRowBrowsePage, error) {
	var out0 TaskRowBrowsePage
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BrowseWorkspaceTasks(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) BrowseWorkspaceTaskBoard(ctx context.Context, request BrowseWorkspaceTaskBoardRequest) (TaskBoardBrowsePage, error) {
	var out0 TaskBoardBrowsePage
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).BrowseWorkspaceTaskBoard(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ClaimForAgent(ctx context.Context, agent AgentActor, channel string, taskNumbers []int64) (string, []ClaimResult, []int64, error) {
	var out0 string
	var out1 []ClaimResult
	var out2 []int64
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, out1, out2, err = store.InTx(tx).ClaimForAgent(ctx, agent, BoardRef{Channel: channel}, taskNumbers)
		return err
	})
	if err != nil {
		return out0, out1, out2, err
	}
	return out0, out1, out2, nil
}

func (store *Store) ClaimForUser(ctx context.Context, userID string, workspaceID string, taskID string) (Task, error) {
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		return store.InTx(tx).claimForUserInTx(ctx, userID, workspaceID, taskID)
	})
	if err != nil {
		return Task{}, err
	}
	return TxStore{db: store.db}.taskByID(ctx, store.db, workspaceID, taskID)
}

func (store *Store) ClaimTasks(ctx context.Context, request ClaimTasksRequest) (ClaimTasksResponse, error) {
	workspaceID, err := request.Context.requireWorkspaceID()
	if err != nil {
		return ClaimTasksResponse{}, err
	}
	txCtx := ctx

	switch request.Context.principalType() {
	case PrincipalTypeUser:
		if len(request.Tasks) != 1 {
			return ClaimTasksResponse{}, badRequest("exactly one task is required")
		}
		userID, _, err := request.Context.requireUser()
		if err != nil {
			return ClaimTasksResponse{}, err
		}
		taskID, err := request.Tasks[0].requireTaskID()
		if err != nil {
			return ClaimTasksResponse{}, err
		}
		task, err := store.ClaimForUser(txCtx, userID, workspaceID, taskID)
		if err != nil {
			return ClaimTasksResponse{}, err
		}
		response := ClaimTasksResponse{
			ChannelID:          task.ChannelID,
			Task:               task,
			Tasks:              []Task{task},
			ChangedTaskNumbers: []int64{task.TaskNumber},
		}
		store.emitTaskUpdated(txCtx, request.Context, task)
		return response, nil
	case PrincipalTypeAgent:
		agent, err := request.Context.requireAgentActor()
		if err != nil {
			return ClaimTasksResponse{}, err
		}
		taskNumbers, err := taskNumbersFromRefs(request.Tasks)
		if err != nil {
			return ClaimTasksResponse{}, err
		}
		var channelID string
		var results []ClaimResult
		var changedTaskNumbers []int64
		err = coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
			var claimErr error
			channelID, results, changedTaskNumbers, claimErr = store.InTx(tx).ClaimForAgent(
				txCtx,
				agent,
				request.Board,
				taskNumbers,
			)
			return claimErr
		})
		if err != nil {
			return ClaimTasksResponse{}, err
		}
		tasks, err := TxStore{db: store.db}.ListByTaskNumbers(txCtx, workspaceID, channelID, changedTaskNumbers)
		if err != nil {
			return ClaimTasksResponse{}, err
		}
		response := ClaimTasksResponse{
			ChannelID:          channelID,
			Tasks:              tasks,
			Results:            results,
			ChangedTaskNumbers: changedTaskNumbers,
		}
		store.emitTasksUpdated(txCtx, request.Context, tasks)
		return response, nil
	default:
		return ClaimTasksResponse{}, badRequest("context subject principalType is required")
	}
}

func (store *Store) CreateForAgent(ctx context.Context, agent AgentActor, channel string, inputs []TaskCreateInput, metadata CreateTaskMetadata) (string, []CreatedTask, error) {
	var out0 string
	var out1 []CreatedTask
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, out1, err = store.InTx(tx).CreateForAgent(ctx, agent, BoardRef{Channel: channel}, inputs, metadata)
		return err
	})
	if err != nil {
		return out0, out1, err
	}
	return out0, out1, nil
}

func (store *Store) CreateForUser(ctx context.Context, userID string, userName string, workspaceID string, channelID string, inputs []TaskCreateInput, metadata CreateTaskMetadata) ([]Task, []CreatedTask, error) {
	var out0 []Task
	var out1 []CreatedTask
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, out1, err = store.InTx(tx).CreateForUser(ctx, userID, userName, workspaceID, channelID, inputs, metadata)
		return err
	})
	if err != nil {
		return out0, out1, err
	}
	return out0, out1, nil
}

func (store *Store) CreateSubtasks(ctx context.Context, request CreateSubtasksRequest) (CreateSubtasksResponse, error) {
	var out0 CreateSubtasksResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).CreateSubtasks(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskCreated(txCtx, request.Context, out0.ChannelID, out0.Tasks)
	return out0, nil
}

func (store *Store) CreateTasks(ctx context.Context, request CreateTasksRequest) (CreateTasksResponse, error) {
	var out0 CreateTasksResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).CreateTasks(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskCreated(txCtx, request.Context, out0.ChannelID, out0.Tasks)
	return out0, nil
}

func (store *Store) DeleteForUser(ctx context.Context, request DeleteForUserRequest) (DeleteTaskResponse, error) {
	var out0 DeleteTaskResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).DeleteForUser(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) DeleteTask(ctx context.Context, request DeleteTaskRequest) (DeleteTaskResponse, error) {
	var out0 DeleteTaskResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).DeleteTask(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	for _, promotedTask := range out0.PromotedTasks {
		store.emitTaskUpdated(txCtx, request.Context, promotedTask)
	}
	if len(out0.DeletedTaskIDs) == 0 {
		if taskID := strings.TrimSpace(request.Task.TaskID); taskID != "" {
			out0.DeletedTaskIDs = []string{taskID}
		}
	}
	for _, deletedTaskID := range out0.DeletedTaskIDs {
		store.emitTaskDeleted(txCtx, request.Context, out0.ChannelID, deletedTaskID)
	}
	return out0, nil
}

func (store *Store) GetTaskBoardViewState(ctx context.Context, request GetTaskBoardViewStateRequest) (GetTaskBoardViewStateResponse, error) {
	var out0 GetTaskBoardViewStateResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).GetTaskBoardViewState(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListTaskBoardSavedViews(ctx context.Context, request ListTaskBoardSavedViewsRequest) (ListTaskBoardSavedViewsResponse, error) {
	var out0 ListTaskBoardSavedViewsResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListTaskBoardSavedViews(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) GetTaskDetail(ctx context.Context, request GetTaskDetailRequest) (GetTaskDetailResponse, error) {
	var out0 GetTaskDetailResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).GetTaskDetail(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) GetTaskTimeline(ctx context.Context, request GetTaskTimelineRequest) (GetTaskTimelineResponse, error) {
	var out0 GetTaskTimelineResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).GetTaskTimeline(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) LeaveTaskCollaborator(ctx context.Context, request LeaveTaskCollaboratorRequest) (LeaveTaskCollaboratorResponse, error) {
	var out0 LeaveTaskCollaboratorResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).LeaveTaskCollaborator(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListByTaskNumbers(ctx context.Context, workspaceID string, channelID string, taskNumbers []int64) ([]Task, error) {
	var out0 []Task
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListByTaskNumbers(ctx, workspaceID, channelID, taskNumbers)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListEffectiveTaskCollaborators(ctx context.Context, request ListEffectiveTaskCollaboratorsRequest) (ListEffectiveTaskCollaboratorsResponse, error) {
	var out0 ListEffectiveTaskCollaboratorsResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListEffectiveTaskCollaborators(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListForUser(ctx context.Context, userID string, workspaceID string, channelID string, includeSubtasks bool) ([]Task, error) {
	var out0 []Task
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListForUser(ctx, userID, workspaceID, channelID, includeSubtasks)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListPrivateAgentMentionCandidates(ctx context.Context, request ListPrivateAgentMentionCandidatesRequest) (ListPrivateAgentMentionCandidatesResponse, error) {
	var out0 ListPrivateAgentMentionCandidatesResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListPrivateAgentMentionCandidates(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListTaskCollaborators(ctx context.Context, request ListTaskCollaboratorsRequest) (ListTaskCollaboratorsResponse, error) {
	var out0 ListTaskCollaboratorsResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListTaskCollaborators(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListAgentCollaborators(ctx context.Context, request ListAgentCollaboratorsRequest) (ListAgentCollaboratorsResponse, error) {
	var out0 ListAgentCollaboratorsResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListAgentCollaborators(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListTaskFieldOptions(ctx context.Context, request ListTaskFieldOptionsRequest) (ListTaskFieldOptionsResponse, error) {
	var out0 ListTaskFieldOptionsResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListTaskFieldOptions(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListTaskReviewQueue(ctx context.Context, request ListTaskReviewQueueRequest) (ListTaskReviewQueueResponse, error) {
	var out0 ListTaskReviewQueueResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListTaskReviewQueue(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListTasks(ctx context.Context, request ListTasksRequest) (ListTasksResponse, error) {
	var out0 ListTasksResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListTasks(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListWorkspaceTasks(ctx context.Context, request ListWorkspaceTasksRequest) (ListWorkspaceTasksResponse, error) {
	var out0 ListWorkspaceTasksResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListWorkspaceTasks(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListWorkspaceTasksForUser(ctx context.Context, userID string, workspaceID string, includeSubtasks bool) ([]Task, error) {
	var out0 []Task
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListWorkspaceTasksForUser(ctx, userID, workspaceID, includeSubtasks)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) MarkTaskRead(ctx context.Context, request MarkTaskReadRequest) (MarkTaskReadResponse, error) {
	var out0 MarkTaskReadResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).MarkTaskRead(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListRelatedTasksForThread(ctx context.Context, request ListRelatedTasksForThreadRequest) (RelatedTasksResponse, error) {
	var out0 RelatedTasksResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListRelatedTasksForThread(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ListRelatedExecutionTasksForAgent(ctx context.Context, request ListRelatedExecutionTasksForAgentRequest) (RelatedTasksResponse, error) {
	var out0 RelatedTasksResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ListRelatedExecutionTasksForAgent(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) RelatedExecutionTasksSummaryForAgent(ctx context.Context, request RelatedExecutionTasksSummaryForAgentRequest) (RelatedTaskUnreadSummary, error) {
	var out0 RelatedTaskUnreadSummary
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).RelatedExecutionTasksSummaryForAgent(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) RelatedTasksSummaryForThread(ctx context.Context, request RelatedTasksSummaryForThreadRequest) (RelatedTaskUnreadSummary, error) {
	var out0 RelatedTaskUnreadSummary
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).RelatedTasksSummaryForThread(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) MarkTaskReviewNotReviewable(ctx context.Context, request MarkTaskReviewNotReviewableRequest) (TaskReviewDecisionResponse, error) {
	var out0 TaskReviewDecisionResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).MarkTaskReviewNotReviewable(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) CreateTaskBoardSavedView(ctx context.Context, request CreateTaskBoardSavedViewRequest) (CreateTaskBoardSavedViewResponse, error) {
	var out0 CreateTaskBoardSavedViewResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).CreateTaskBoardSavedView(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) PutTaskBoardViewState(ctx context.Context, request PutTaskBoardViewStateRequest) (PutTaskBoardViewStateResponse, error) {
	var out0 PutTaskBoardViewStateResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).PutTaskBoardViewState(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) UpdateTaskBoardSavedView(ctx context.Context, request UpdateTaskBoardSavedViewRequest) (UpdateTaskBoardSavedViewResponse, error) {
	var out0 UpdateTaskBoardSavedViewResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).UpdateTaskBoardSavedView(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) DeleteTaskBoardSavedView(ctx context.Context, request DeleteTaskBoardSavedViewRequest) (DeleteTaskBoardSavedViewResponse, error) {
	var out0 DeleteTaskBoardSavedViewResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).DeleteTaskBoardSavedView(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ReassignTaskReview(ctx context.Context, request ReassignTaskReviewRequest) (TaskReviewDecisionResponse, error) {
	var out0 TaskReviewDecisionResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ReassignTaskReview(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) RemoveTaskCollaborator(ctx context.Context, request RemoveTaskCollaboratorRequest) (RemoveTaskCollaboratorResponse, error) {
	var out0 RemoveTaskCollaboratorResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).RemoveTaskCollaborator(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ReorderTaskFieldOption(ctx context.Context, request ReorderTaskFieldOptionRequest) (ReorderTaskFieldOptionResponse, error) {
	var out0 ReorderTaskFieldOptionResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ReorderTaskFieldOption(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) RequestTaskChanges(ctx context.Context, request RequestTaskChangesRequest) (TaskReviewDecisionResponse, error) {
	var out0 TaskReviewDecisionResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).RequestTaskChanges(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) RequestTaskReview(ctx context.Context, request RequestTaskReviewRequest) (RequestTaskReviewResponse, error) {
	var out0 RequestTaskReviewResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).RequestTaskReview(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) ResolvePrivateAgentContextContributionCapability(ctx context.Context, request ResolvePrivateAgentContextContributionCapabilityRequest) (ResolvePrivateAgentContextContributionCapabilityResponse, error) {
	var out0 ResolvePrivateAgentContextContributionCapabilityResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ResolvePrivateAgentContextContributionCapability(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) ResolvePrivateAgentContextState(ctx context.Context, request ResolvePrivateAgentContextStateRequest) (ResolvePrivateAgentContextStateResponse, error) {
	var out0 ResolvePrivateAgentContextStateResponse
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).ResolvePrivateAgentContextState(ctx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) SetTaskFieldOptionActive(ctx context.Context, request SetTaskFieldOptionActiveRequest) (SetTaskFieldOptionActiveResponse, error) {
	var out0 SetTaskFieldOptionActiveResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).SetTaskFieldOptionActive(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTasksUpdated(txCtx, request.Context, out0.AffectedTasks)
	return out0, nil
}

func (store *Store) UnblockTask(ctx context.Context, request UnblockTaskRequest) (UnblockTaskResponse, error) {
	var out0 UnblockTaskResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).UnblockTask(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	if out0.Changed || request.Context.principalType() == PrincipalTypeUser {
		store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	}
	return out0, nil
}

func (store *Store) UnblockTaskForAgent(ctx context.Context, agent AgentActor, channel string, taskNumber int64) (Task, bool, error) {
	var out0 Task
	var out1 bool
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, out1, err = store.InTx(tx).UnblockTaskForAgent(ctx, agent, BoardRef{Channel: channel}, taskNumber)
		return err
	})
	if err != nil {
		return out0, out1, err
	}
	return out0, out1, nil
}

func (store *Store) UnblockTaskForUser(ctx context.Context, userID string, workspaceID string, taskID string) (Task, bool, error) {
	var out0 Task
	var out1 bool
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, out1, err = store.InTx(tx).UnblockTaskForUser(ctx, userID, workspaceID, taskID)
		return err
	})
	if err != nil {
		return out0, out1, err
	}
	return out0, out1, nil
}

func (store *Store) UnclaimForAgent(ctx context.Context, agent AgentActor, channel string, taskNumber int64) (Task, error) {
	var out0 Task
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).UnclaimForAgent(ctx, agent, BoardRef{Channel: channel}, taskNumber)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) UnclaimForUser(ctx context.Context, userID string, workspaceID string, taskID string) (Task, error) {
	var out0 Task
	err := coredb.WithTx(ctx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).UnclaimForUser(ctx, userID, workspaceID, taskID)
		return err
	})
	if err != nil {
		return out0, err
	}
	return out0, nil
}

func (store *Store) UnclaimTask(ctx context.Context, request UnclaimTaskRequest) (UnclaimTaskResponse, error) {
	var out0 UnclaimTaskResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).UnclaimTask(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) UpdateTask(ctx context.Context, request UpdateTaskRequest) (UpdateTaskResponse, error) {
	var out0 UpdateTaskResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).UpdateTask(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	return out0, nil
}

func (store *Store) UpdateTaskStatus(ctx context.Context, request UpdateTaskStatusRequest) (UpdateTaskStatusResponse, error) {
	var out0 UpdateTaskStatusResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).UpdateTaskStatus(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	if out0.Changed || request.Context.principalType() == PrincipalTypeUser {
		store.emitTaskUpdated(txCtx, request.Context, out0.Task)
	}
	return out0, nil
}

func (store *Store) UpsertTaskFieldOption(ctx context.Context, request UpsertTaskFieldOptionRequest) (UpsertTaskFieldOptionResponse, error) {
	var out0 UpsertTaskFieldOptionResponse
	txCtx := ctx
	err := coredb.WithTx(txCtx, store.db, func(tx coredb.Tx) error {
		var err error
		out0, err = store.InTx(tx).UpsertTaskFieldOption(txCtx, request)
		return err
	})
	if err != nil {
		return out0, err
	}
	store.emitTasksUpdated(txCtx, request.Context, out0.AffectedTasks)
	return out0, nil
}