package task

import (
	"context"

	"github.com/tidbcloud/AgentTeam/internal/store/attachment"
	"github.com/tidbcloud/AgentTeam/internal/store/message"
	"github.com/tidbcloud/AgentTeam/internal/store/taskboard"
)

type taskBoardServiceAdapter struct {
	base *taskboard.Store
}

func NewTaskBoardServiceAdapter(base *taskboard.Store) TaskBoardService {
	if base == nil {
		return nil
	}
	return taskBoardServiceAdapter{base: base}
}

func (adapter taskBoardServiceAdapter) ListTasks(ctx context.Context, request ListTasksRequest) (ListTasksResponse, error) {
	response, err := adapter.base.ListTasks(ctx, taskboard.ListTasksRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Status: request.Status, IncludeSubtasks: request.IncludeSubtasks})
	if err != nil {
		return ListTasksResponse{}, err
	}
	return ListTasksResponse{ChannelID: response.ChannelID, Tasks: fromTaskboardTasks(response.Tasks), TaskViews: fromTaskboardTaskViews(response.TaskViews)}, nil
}

func (adapter taskBoardServiceAdapter) ListWorkspaceTasks(ctx context.Context, request ListWorkspaceTasksRequest) (ListWorkspaceTasksResponse, error) {
	response, err := adapter.base.ListWorkspaceTasks(ctx, taskboard.ListWorkspaceTasksRequest{Context: toTaskboardServiceContext(request.Context), Status: request.Status, IncludeSubtasks: request.IncludeSubtasks})
	if err != nil {
		return ListWorkspaceTasksResponse{}, err
	}
	return ListWorkspaceTasksResponse{Tasks: fromTaskboardTasks(response.Tasks)}, nil
}

func (adapter taskBoardServiceAdapter) BrowseWorkspaceTasks(ctx context.Context, request BrowseWorkspaceTasksRequest) (TaskRowBrowsePage, error) {
	response, err := adapter.base.BrowseWorkspaceTasks(ctx, taskboard.BrowseWorkspaceTasksRequest{Context: toTaskboardServiceContext(request.Context), Query: toTaskboardTaskBrowseQuery(request.Query)})
	if err != nil {
		return TaskRowBrowsePage{}, err
	}
	return fromTaskboardRowBrowsePage(response), nil
}

func (adapter taskBoardServiceAdapter) BrowseWorkspaceTaskBoard(ctx context.Context, request BrowseWorkspaceTaskBoardRequest) (TaskBoardBrowsePage, error) {
	response, err := adapter.base.BrowseWorkspaceTaskBoard(ctx, taskboard.BrowseWorkspaceTaskBoardRequest{Context: toTaskboardServiceContext(request.Context), Query: toTaskboardTaskBrowseQuery(request.Query)})
	if err != nil {
		return TaskBoardBrowsePage{}, err
	}
	return fromTaskboardBoardBrowsePage(response), nil
}

func (adapter taskBoardServiceAdapter) BrowseChannelTasks(ctx context.Context, request BrowseChannelTasksRequest) (TaskRowBrowsePage, error) {
	response, err := adapter.base.BrowseChannelTasks(ctx, taskboard.BrowseChannelTasksRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Query: toTaskboardTaskBrowseQuery(request.Query)})
	if err != nil {
		return TaskRowBrowsePage{}, err
	}
	return fromTaskboardRowBrowsePage(response), nil
}

func (adapter taskBoardServiceAdapter) BrowseTaskBoard(ctx context.Context, request BrowseTaskBoardRequest) (TaskBoardBrowsePage, error) {
	response, err := adapter.base.BrowseTaskBoard(ctx, taskboard.BrowseTaskBoardRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Query: toTaskboardTaskBrowseQuery(request.Query)})
	if err != nil {
		return TaskBoardBrowsePage{}, err
	}
	return fromTaskboardBoardBrowsePage(response), nil
}

func (adapter taskBoardServiceAdapter) ListWorkspaceTaskFilterOptions(ctx context.Context, request ListWorkspaceTaskFilterOptionsRequest) (ListWorkspaceTaskFilterOptionsResponse, error) {
	response, err := adapter.base.ListWorkspaceTaskFilterOptions(ctx, taskboard.ListWorkspaceTaskFilterOptionsRequest{
		Context:   toTaskboardServiceContext(request.Context),
		ChannelID: request.ChannelID,
		Dimension: taskboard.TaskFilterOptionDimension(request.Dimension),
		Query:     request.Query,
		Limit:     request.Limit,
		Cursor:    request.Cursor,
		Include:   request.Include,
	})
	if err != nil {
		return ListWorkspaceTaskFilterOptionsResponse{}, err
	}
	return ListWorkspaceTaskFilterOptionsResponse{
		Channel:  fromTaskboardFilterOptionPage(response.Channel),
		Assignee: fromTaskboardFilterOptionPage(response.Assignee),
		Kind:     fromTaskboardFilterOptionPage(response.Kind),
		Priority: fromTaskboardFilterOptionPage(response.Priority),
	}, nil
}

func fromTaskboardFilterOptionPage(page taskboard.TaskFilterOptionPage) TaskFilterOptionPage {
	options := make([]TaskFilterOption, 0, len(page.Options))
	for _, option := range page.Options {
		options = append(options, TaskFilterOption{Value: option.Value, Label: option.Label, Tone: option.Tone})
	}
	return TaskFilterOptionPage{Options: options, HasMore: page.HasMore, NextCursor: page.NextCursor}
}

func (adapter taskBoardServiceAdapter) ListTaskFieldOptions(ctx context.Context, request ListTaskFieldOptionsRequest) (ListTaskFieldOptionsResponse, error) {
	response, err := adapter.base.ListTaskFieldOptions(ctx, taskboard.ListTaskFieldOptionsRequest{Context: toTaskboardServiceContext(request.Context)})
	if err != nil {
		return ListTaskFieldOptionsResponse{}, err
	}
	return ListTaskFieldOptionsResponse{CanManage: response.CanManage, PriorityOptions: fromTaskboardFieldOptions(response.PriorityOptions), KindOptions: fromTaskboardFieldOptions(response.KindOptions)}, nil
}

func (adapter taskBoardServiceAdapter) GetTaskBoardViewState(ctx context.Context, request GetTaskBoardViewStateRequest) (GetTaskBoardViewStateResponse, error) {
	response, err := adapter.base.GetTaskBoardViewState(ctx, taskboard.GetTaskBoardViewStateRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board)})
	if err != nil {
		return GetTaskBoardViewStateResponse{}, err
	}
	return GetTaskBoardViewStateResponse{ViewState: fromTaskboardViewState(response.ViewState)}, nil
}

func (adapter taskBoardServiceAdapter) PutTaskBoardViewState(ctx context.Context, request PutTaskBoardViewStateRequest) (PutTaskBoardViewStateResponse, error) {
	response, err := adapter.base.PutTaskBoardViewState(ctx, taskboard.PutTaskBoardViewStateRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), ViewState: toTaskboardViewState(request.ViewState)})
	if err != nil {
		return PutTaskBoardViewStateResponse{}, err
	}
	return PutTaskBoardViewStateResponse{ViewState: fromTaskboardViewState(response.ViewState)}, nil
}

func (adapter taskBoardServiceAdapter) ListTaskBoardSavedViews(ctx context.Context, request ListTaskBoardSavedViewsRequest) (ListTaskBoardSavedViewsResponse, error) {
	response, err := adapter.base.ListTaskBoardSavedViews(ctx, taskboard.ListTaskBoardSavedViewsRequest{Context: toTaskboardServiceContext(request.Context)})
	if err != nil {
		return ListTaskBoardSavedViewsResponse{}, err
	}
	return ListTaskBoardSavedViewsResponse{SavedViews: fromTaskboardSavedViews(response.SavedViews)}, nil
}

func (adapter taskBoardServiceAdapter) CreateTaskBoardSavedView(ctx context.Context, request CreateTaskBoardSavedViewRequest) (CreateTaskBoardSavedViewResponse, error) {
	response, err := adapter.base.CreateTaskBoardSavedView(ctx, taskboard.CreateTaskBoardSavedViewRequest{Context: toTaskboardServiceContext(request.Context), Name: request.Name, ViewState: toTaskboardViewState(request.ViewState)})
	if err != nil {
		return CreateTaskBoardSavedViewResponse{}, err
	}
	return CreateTaskBoardSavedViewResponse{SavedView: fromTaskboardSavedView(response.SavedView)}, nil
}

func (adapter taskBoardServiceAdapter) UpdateTaskBoardSavedView(ctx context.Context, request UpdateTaskBoardSavedViewRequest) (UpdateTaskBoardSavedViewResponse, error) {
	response, err := adapter.base.UpdateTaskBoardSavedView(ctx, taskboard.UpdateTaskBoardSavedViewRequest{Context: toTaskboardServiceContext(request.Context), SavedViewID: request.SavedViewID, Name: request.Name, ViewState: toTaskboardViewState(request.ViewState)})
	if err != nil {
		return UpdateTaskBoardSavedViewResponse{}, err
	}
	return UpdateTaskBoardSavedViewResponse{SavedView: fromTaskboardSavedView(response.SavedView)}, nil
}

func (adapter taskBoardServiceAdapter) DeleteTaskBoardSavedView(ctx context.Context, request DeleteTaskBoardSavedViewRequest) (DeleteTaskBoardSavedViewResponse, error) {
	_, err := adapter.base.DeleteTaskBoardSavedView(ctx, taskboard.DeleteTaskBoardSavedViewRequest{Context: toTaskboardServiceContext(request.Context), SavedViewID: request.SavedViewID})
	if err != nil {
		return DeleteTaskBoardSavedViewResponse{}, err
	}
	return DeleteTaskBoardSavedViewResponse{}, nil
}

func (adapter taskBoardServiceAdapter) UpsertTaskFieldOption(ctx context.Context, request UpsertTaskFieldOptionRequest) (UpsertTaskFieldOptionResponse, error) {
	response, err := adapter.base.UpsertTaskFieldOption(ctx, taskboard.UpsertTaskFieldOptionRequest{Context: toTaskboardServiceContext(request.Context), OptionID: request.OptionID, Option: toTaskboardFieldOptionInput(request.Option)})
	if err != nil {
		return UpsertTaskFieldOptionResponse{}, err
	}
	return UpsertTaskFieldOptionResponse{Option: fromTaskboardFieldOption(response.Option), AffectedTasks: fromTaskboardTasks(response.AffectedTasks)}, nil
}

func (adapter taskBoardServiceAdapter) ReorderTaskFieldOption(ctx context.Context, request ReorderTaskFieldOptionRequest) (ReorderTaskFieldOptionResponse, error) {
	response, err := adapter.base.ReorderTaskFieldOption(ctx, taskboard.ReorderTaskFieldOptionRequest{Context: toTaskboardServiceContext(request.Context), OptionID: request.OptionID, Position: request.Position})
	if err != nil {
		return ReorderTaskFieldOptionResponse{}, err
	}
	return ReorderTaskFieldOptionResponse{Option: fromTaskboardFieldOption(response.Option)}, nil
}

func (adapter taskBoardServiceAdapter) SetTaskFieldOptionActive(ctx context.Context, request SetTaskFieldOptionActiveRequest) (SetTaskFieldOptionActiveResponse, error) {
	response, err := adapter.base.SetTaskFieldOptionActive(ctx, taskboard.SetTaskFieldOptionActiveRequest{Context: toTaskboardServiceContext(request.Context), OptionID: request.OptionID, Active: request.Active})
	if err != nil {
		return SetTaskFieldOptionActiveResponse{}, err
	}
	return SetTaskFieldOptionActiveResponse{Option: fromTaskboardFieldOption(response.Option), AffectedTasks: fromTaskboardTasks(response.AffectedTasks)}, nil
}

func (adapter taskBoardServiceAdapter) CreateTasks(ctx context.Context, request CreateTasksRequest) (CreateTasksResponse, error) {
	response, err := adapter.base.CreateTasks(ctx, taskboard.CreateTasksRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Titles: request.Titles, Task: toTaskboardTaskCreateInput(request.Task), Metadata: toTaskboardCreateTaskMetadata(request.Metadata)})
	if err != nil {
		return CreateTasksResponse{}, err
	}
	return CreateTasksResponse{ChannelID: response.ChannelID, Tasks: fromTaskboardTasks(response.Tasks), CreatedTasks: fromTaskboardCreatedTasks(response.CreatedTasks)}, nil
}

func (adapter taskBoardServiceAdapter) CreateSubtasks(ctx context.Context, request CreateSubtasksRequest) (CreateSubtasksResponse, error) {
	response, err := adapter.base.CreateSubtasks(ctx, taskboard.CreateSubtasksRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Titles: request.Titles, Input: toTaskboardTaskCreateInput(request.Input)})
	if err != nil {
		return CreateSubtasksResponse{}, err
	}
	return CreateSubtasksResponse{ChannelID: response.ChannelID, Tasks: fromTaskboardTasks(response.Tasks), CreatedTasks: fromTaskboardCreatedTasks(response.CreatedTasks)}, nil
}

func (adapter taskBoardServiceAdapter) ListTaskSubtasks(ctx context.Context, request ListTaskSubtasksRequest) (ListTaskSubtasksResponse, error) {
	response, err := adapter.base.ListTaskSubtasks(ctx, taskboard.ListTaskSubtasksRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Limit: request.Limit, Cursor: toTaskboardSubtaskCursor(request.Cursor)})
	if err != nil {
		return ListTaskSubtasksResponse{}, err
	}
	return ListTaskSubtasksResponse{Tasks: fromTaskboardTasks(response.Tasks), HasMore: response.HasMore, NextCursor: fromTaskboardSubtaskCursor(response.NextCursor)}, nil
}

func (adapter taskBoardServiceAdapter) ClaimTasks(ctx context.Context, request ClaimTasksRequest) (ClaimTasksResponse, error) {
	response, err := adapter.base.ClaimTasks(ctx, taskboard.ClaimTasksRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Tasks: toTaskboardTaskRefs(request.Tasks)})
	if err != nil {
		return ClaimTasksResponse{}, err
	}
	return ClaimTasksResponse{ChannelID: response.ChannelID, Task: fromTaskboardTask(response.Task), Tasks: fromTaskboardTasks(response.Tasks), Results: fromTaskboardClaimResults(response.Results), ChangedTaskNumbers: response.ChangedTaskNumbers}, nil
}

func (adapter taskBoardServiceAdapter) UnclaimTask(ctx context.Context, request UnclaimTaskRequest) (UnclaimTaskResponse, error) {
	response, err := adapter.base.UnclaimTask(ctx, taskboard.UnclaimTaskRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task)})
	if err != nil {
		return UnclaimTaskResponse{}, err
	}
	return UnclaimTaskResponse{Task: fromTaskboardTask(response.Task)}, nil
}

func (adapter taskBoardServiceAdapter) BlockTask(ctx context.Context, request BlockTaskRequest) (BlockTaskResponse, error) {
	response, err := adapter.base.BlockTask(ctx, taskboard.BlockTaskRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Block: taskboard.TaskBlockInput{Reason: request.Block.Reason}})
	if err != nil {
		return BlockTaskResponse{}, err
	}
	return BlockTaskResponse{Task: fromTaskboardTask(response.Task), Changed: response.Changed}, nil
}

func (adapter taskBoardServiceAdapter) UnblockTask(ctx context.Context, request UnblockTaskRequest) (UnblockTaskResponse, error) {
	response, err := adapter.base.UnblockTask(ctx, taskboard.UnblockTaskRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task)})
	if err != nil {
		return UnblockTaskResponse{}, err
	}
	return UnblockTaskResponse{Task: fromTaskboardTask(response.Task), Changed: response.Changed}, nil
}

func (adapter taskBoardServiceAdapter) DeleteTask(ctx context.Context, request DeleteTaskRequest) (DeleteTaskResponse, error) {
	response, err := adapter.base.DeleteTask(ctx, taskboard.DeleteTaskRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), SubtaskMode: taskboard.DeleteTaskSubtaskMode(request.SubtaskMode)})
	if err != nil {
		return DeleteTaskResponse{}, err
	}
	return DeleteTaskResponse{ChannelID: response.ChannelID, DeletedTaskIDs: response.DeletedTaskIDs, PromotedTasks: fromTaskboardTasks(response.PromotedTasks)}, nil
}

func (adapter taskBoardServiceAdapter) GetTaskDetail(ctx context.Context, request GetTaskDetailRequest) (GetTaskDetailResponse, error) {
	response, err := adapter.base.GetTaskDetail(ctx, taskboard.GetTaskDetailRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), SkipTimeline: request.SkipTimeline})
	if err != nil {
		return GetTaskDetailResponse{}, err
	}
	return GetTaskDetailResponse{Detail: fromTaskboardTaskDetail(response.Detail)}, nil
}

func (adapter taskBoardServiceAdapter) GetTaskTimeline(ctx context.Context, request GetTaskTimelineRequest) (GetTaskTimelineResponse, error) {
	response, err := adapter.base.GetTaskTimeline(ctx, taskboard.GetTaskTimelineRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Cursor: toTaskboardTaskTimelineCursor(request.Cursor)})
	if err != nil {
		return GetTaskTimelineResponse{}, err
	}
	return GetTaskTimelineResponse{Entries: fromTaskboardTimelineEntries(response.Entries), HasMore: response.HasMore, NextCursor: fromTaskboardTaskTimelineCursor(response.NextCursor)}, nil
}

func (adapter taskBoardServiceAdapter) MarkTaskRead(ctx context.Context, request MarkTaskReadRequest) (MarkTaskReadResponse, error) {
	response, err := adapter.base.MarkTaskRead(ctx, taskboard.MarkTaskReadRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task)})
	if err != nil {
		return MarkTaskReadResponse{}, err
	}
	return MarkTaskReadResponse{Task: fromTaskboardTask(response.Task), ReadState: fromTaskboardReadStateValue(response.ReadState)}, nil
}

func (adapter taskBoardServiceAdapter) ListRelatedTasksForThread(ctx context.Context, request ListRelatedTasksForThreadRequest) (RelatedTasksResponse, error) {
	response, err := adapter.base.ListRelatedTasksForThread(ctx, taskboard.ListRelatedTasksForThreadRequest{Context: toTaskboardServiceContext(request.Context), ThreadChannelID: request.ThreadChannelID, Limit: request.Limit, Cursor: taskboard.RelatedTaskCursor{TaskNumber: request.Cursor.TaskNumber, TaskID: request.Cursor.TaskID}, Status: taskboard.RelatedTaskStatus(request.Status)})
	if err != nil {
		return RelatedTasksResponse{}, err
	}
	return fromTaskboardRelatedTasksResponse(response), nil
}

func (adapter taskBoardServiceAdapter) ListRelatedExecutionTasksForAgent(ctx context.Context, request ListRelatedExecutionTasksForAgentRequest) (RelatedTasksResponse, error) {
	response, err := adapter.base.ListRelatedExecutionTasksForAgent(ctx, taskboard.ListRelatedExecutionTasksForAgentRequest{Context: toTaskboardServiceContext(request.Context), AgentID: request.AgentID, Limit: request.Limit, Cursor: taskboard.RelatedTaskCursor{TaskNumber: request.Cursor.TaskNumber, TaskID: request.Cursor.TaskID}, Status: taskboard.RelatedTaskStatus(request.Status)})
	if err != nil {
		return RelatedTasksResponse{}, err
	}
	return fromTaskboardRelatedTasksResponse(response), nil
}

func (adapter taskBoardServiceAdapter) RelatedExecutionTasksSummaryForAgent(ctx context.Context, request RelatedExecutionTasksSummaryForAgentRequest) (RelatedTasksSummaryResponse, error) {
	response, err := adapter.base.RelatedExecutionTasksSummaryForAgent(ctx, taskboard.RelatedExecutionTasksSummaryForAgentRequest{Context: toTaskboardServiceContext(request.Context), AgentID: request.AgentID, Limit: request.Limit, Cursor: taskboard.RelatedTaskCursor{TaskNumber: request.Cursor.TaskNumber, TaskID: request.Cursor.TaskID}, Status: taskboard.RelatedTaskStatus(request.Status)})
	if err != nil {
		return RelatedTasksSummaryResponse{}, err
	}
	return RelatedTasksSummaryResponse{TaskCount: response.TaskCount, Unread: fromTaskboardRelatedTaskUnread(response.Unread), StatusCounts: response.StatusCounts}, nil
}

func (adapter taskBoardServiceAdapter) RelatedTasksSummaryForThread(ctx context.Context, request RelatedTasksSummaryForThreadRequest) (RelatedTasksSummaryResponse, error) {
	response, err := adapter.base.RelatedTasksSummaryForThread(ctx, taskboard.RelatedTasksSummaryForThreadRequest{Context: toTaskboardServiceContext(request.Context), ThreadChannelID: request.ThreadChannelID})
	if err != nil {
		return RelatedTasksSummaryResponse{}, err
	}
	return RelatedTasksSummaryResponse{TaskCount: response.TaskCount, StatusCounts: response.StatusCounts}, nil
}

func (adapter taskBoardServiceAdapter) UpdateTask(ctx context.Context, request UpdateTaskRequest) (UpdateTaskResponse, error) {
	response, err := adapter.base.UpdateTask(ctx, taskboard.UpdateTaskRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Patch: toTaskboardTaskUpdatePatch(request.Patch)})
	if err != nil {
		return UpdateTaskResponse{}, err
	}
	return UpdateTaskResponse{Task: fromTaskboardTask(response.Task)}, nil
}

func (adapter taskBoardServiceAdapter) UpdateTaskStatus(ctx context.Context, request UpdateTaskStatusRequest) (UpdateTaskStatusResponse, error) {
	response, err := adapter.base.UpdateTaskStatus(ctx, taskboard.UpdateTaskStatusRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Status: request.Status})
	if err != nil {
		return UpdateTaskStatusResponse{}, err
	}
	return UpdateTaskStatusResponse{Task: fromTaskboardTask(response.Task), Changed: response.Changed}, nil
}

func (adapter taskBoardServiceAdapter) AddTaskCheckpoint(ctx context.Context, request AddTaskCheckpointRequest) (AddTaskCheckpointResponse, error) {
	response, err := adapter.base.AddTaskCheckpoint(ctx, taskboard.AddTaskCheckpointRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Checkpoint: taskboard.TaskCheckpointInput{Text: request.Checkpoint.Text}})
	if err != nil {
		return AddTaskCheckpointResponse{}, err
	}
	return AddTaskCheckpointResponse{Task: fromTaskboardTask(response.Task)}, nil
}

func (adapter taskBoardServiceAdapter) RequestTaskReview(ctx context.Context, request RequestTaskReviewRequest) (RequestTaskReviewResponse, error) {
	response, err := adapter.base.RequestTaskReview(ctx, taskboard.RequestTaskReviewRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Review: taskboard.TaskReviewRequestInput{ReviewerRef: request.Review.ReviewerRef, Summary: request.Review.Summary, Questions: request.Review.Questions, ReviewTargetType: request.Review.ReviewTargetType, ReviewTargetPayload: request.Review.ReviewTargetPayload}})
	if err != nil {
		return RequestTaskReviewResponse{}, err
	}
	return RequestTaskReviewResponse{Task: fromTaskboardTask(response.Task), Review: fromTaskboardReview(response.Review)}, nil
}

func (adapter taskBoardServiceAdapter) ApproveTaskReview(ctx context.Context, request ApproveTaskReviewRequest) (TaskReviewDecisionResponse, error) {
	response, err := adapter.base.ApproveTaskReview(ctx, taskboard.ApproveTaskReviewRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Review: toTaskboardReviewDecisionInput(request.Review)})
	if err != nil {
		return TaskReviewDecisionResponse{}, err
	}
	return fromTaskboardTaskReviewDecisionResponse(response), nil
}

func (adapter taskBoardServiceAdapter) RequestTaskChanges(ctx context.Context, request RequestTaskChangesRequest) (TaskReviewDecisionResponse, error) {
	response, err := adapter.base.RequestTaskChanges(ctx, taskboard.RequestTaskChangesRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Review: toTaskboardReviewDecisionInput(request.Review)})
	if err != nil {
		return TaskReviewDecisionResponse{}, err
	}
	return fromTaskboardTaskReviewDecisionResponse(response), nil
}

func (adapter taskBoardServiceAdapter) ReassignTaskReview(ctx context.Context, request ReassignTaskReviewRequest) (TaskReviewDecisionResponse, error) {
	response, err := adapter.base.ReassignTaskReview(ctx, taskboard.ReassignTaskReviewRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Review: taskboard.TaskReviewReassignmentInput{ReviewID: request.Review.ReviewID, ReviewerRef: request.Review.ReviewerRef}})
	if err != nil {
		return TaskReviewDecisionResponse{}, err
	}
	return fromTaskboardTaskReviewDecisionResponse(response), nil
}

func (adapter taskBoardServiceAdapter) MarkTaskReviewNotReviewable(ctx context.Context, request MarkTaskReviewNotReviewableRequest) (TaskReviewDecisionResponse, error) {
	response, err := adapter.base.MarkTaskReviewNotReviewable(ctx, taskboard.MarkTaskReviewNotReviewableRequest{Context: toTaskboardServiceContext(request.Context), Board: toTaskboardBoardRef(request.Board), Task: toTaskboardTaskRef(request.Task), Review: taskboard.TaskReviewCancellationInput{ReviewID: request.Review.ReviewID}})
	if err != nil {
		return TaskReviewDecisionResponse{}, err
	}
	return fromTaskboardTaskReviewDecisionResponse(response), nil
}

func toTaskboardServiceContext(ctx ServiceContext) taskboard.ServiceContext {
	return taskboard.ServiceContext{RequestID: ctx.RequestID, WorkspaceID: ctx.WorkspaceID, Subject: taskboard.SubjectContext{PrincipalID: ctx.Subject.PrincipalID, PrincipalType: taskboard.PrincipalType(ctx.Subject.PrincipalType), MemberID: ctx.Subject.MemberID, DisplayName: ctx.Subject.DisplayName}, InstallationID: ctx.InstallationID, Scopes: ctx.Scopes}
}

func toTaskboardBoardRef(ref BoardRef) taskboard.BoardRef {
	return taskboard.BoardRef{ChannelID: ref.ChannelID, Channel: ref.Channel}
}

func toTaskboardTaskRef(ref TaskRef) taskboard.TaskRef {
	return taskboard.TaskRef{TaskID: ref.TaskID, TaskNumber: ref.TaskNumber}
}

func toTaskboardTaskRefs(refs []TaskRef) []taskboard.TaskRef {
	if len(refs) == 0 {
		return nil
	}
	out := make([]taskboard.TaskRef, 0, len(refs))
	for _, ref := range refs {
		out = append(out, toTaskboardTaskRef(ref))
	}
	return out
}

func toTaskboardTaskBrowseCursor(cursor TaskBrowseCursor) taskboard.TaskBrowseCursor {
	return taskboard.TaskBrowseCursor{SortMode: cursor.SortMode, TaskID: cursor.TaskID, CreatedAt: cursor.CreatedAt, ActivityAt: cursor.ActivityAt, Title: cursor.Title, PriorityMissing: cursor.PriorityMissing, PriorityLabel: cursor.PriorityLabel, TaskNumber: cursor.TaskNumber}
}

func toTaskboardTaskBrowseCursors(cursors map[string]TaskBrowseCursor) map[string]taskboard.TaskBrowseCursor {
	if len(cursors) == 0 {
		return nil
	}
	out := make(map[string]taskboard.TaskBrowseCursor, len(cursors))
	for key, cursor := range cursors {
		out[key] = toTaskboardTaskBrowseCursor(cursor)
	}
	return out
}

func fromTaskboardTaskBrowseCursor(cursor taskboard.TaskBrowseCursor) TaskBrowseCursor {
	return TaskBrowseCursor{SortMode: cursor.SortMode, TaskID: cursor.TaskID, CreatedAt: cursor.CreatedAt, ActivityAt: cursor.ActivityAt, Title: cursor.Title, PriorityMissing: cursor.PriorityMissing, PriorityLabel: cursor.PriorityLabel, TaskNumber: cursor.TaskNumber}
}

func fromTaskboardTaskBrowseCursors(cursors map[string]taskboard.TaskBrowseCursor) map[string]TaskBrowseCursor {
	if len(cursors) == 0 {
		return nil
	}
	out := make(map[string]TaskBrowseCursor, len(cursors))
	for key, cursor := range cursors {
		out[key] = fromTaskboardTaskBrowseCursor(cursor)
	}
	return out
}

func toTaskboardTaskTimelineCursor(cursor TaskTimelineCursor) taskboard.TaskTimelineCursor {
	return taskboard.TaskTimelineCursor{Seq: cursor.Seq, CreatedAt: cursor.CreatedAt, ID: cursor.ID}
}

func fromTaskboardTaskTimelineCursor(cursor taskboard.TaskTimelineCursor) TaskTimelineCursor {
	return TaskTimelineCursor{Seq: cursor.Seq, CreatedAt: cursor.CreatedAt, ID: cursor.ID}
}

func toTaskboardSubtaskCursor(cursor TaskSubtaskCursor) taskboard.SubtaskPageCursor {
	return taskboard.SubtaskPageCursor{CreatedAt: cursor.CreatedAt, ID: cursor.ID}
}

func fromTaskboardSubtaskCursor(cursor taskboard.SubtaskPageCursor) TaskSubtaskCursor {
	return TaskSubtaskCursor{CreatedAt: cursor.CreatedAt, ID: cursor.ID}
}

func toTaskboardTaskBrowseQuery(query TaskBrowseQuery) taskboard.TaskBrowseQuery {
	return taskboard.TaskBrowseQuery{Limit: query.Limit, SearchQuery: query.SearchQuery, SortMode: query.SortMode, StatusFilter: query.StatusFilter, QuickFilters: query.QuickFilters, StructuredFilters: query.StructuredFilters, IncludeSubtasks: query.IncludeSubtasks, Cursor: toTaskboardTaskBrowseCursor(query.Cursor), ColumnCursors: toTaskboardTaskBrowseCursors(query.ColumnCursors)}
}

func toTaskboardViewState(state TaskBoardViewState) taskboard.TaskBoardViewState {
	return taskboard.TaskBoardViewState{View: state.View, SearchQuery: state.SearchQuery, QuickFilters: state.QuickFilters, StructuredFilters: state.StructuredFilters, SortMode: state.SortMode, CardPropertyToggles: state.CardPropertyToggles, DoneCollapsed: state.DoneCollapsed}
}

func toTaskboardFieldOptionInput(input TaskFieldOptionInput) taskboard.TaskFieldOptionInput {
	return taskboard.TaskFieldOptionInput{FieldKind: input.FieldKind, Key: input.Key, Label: input.Label, Aliases: input.Aliases}
}

func toTaskboardTaskCreateInput(input *TaskCreateInput) *taskboard.TaskCreateInput {
	if input == nil {
		return nil
	}
	return &taskboard.TaskCreateInput{Title: input.Title, Description: input.Description, Kind: input.Kind, Priority: input.Priority, KindOptionID: input.KindOptionID, PriorityOptionID: input.PriorityOptionID, AssigneeRef: input.AssigneeRef}
}

func toTaskboardCreateTaskMetadata(metadata *CreateTaskMetadata) *taskboard.CreateTaskMetadata {
	if metadata == nil {
		return nil
	}
	return &taskboard.CreateTaskMetadata{SourceThreadChannelID: metadata.SourceThreadChannelID, SourceThreadParentChannelID: metadata.SourceThreadParentChannelID, SourceThreadParentMessageID: metadata.SourceThreadParentMessageID, SourceThreadRef: metadata.SourceThreadRef}
}

func toTaskboardTaskUpdatePatch(patch TaskUpdatePatch) taskboard.TaskUpdatePatch {
	return taskboard.TaskUpdatePatch{Title: patch.Title, Description: patch.Description, Kind: patch.Kind, Priority: patch.Priority, KindOptionID: patch.KindOptionID, PriorityOptionID: patch.PriorityOptionID, AssigneeRef: patch.AssigneeRef, AcceptanceCriteria: toTaskboardChecklistItems(patch.AcceptanceCriteria), ReviewChecklist: toTaskboardChecklistItems(patch.ReviewChecklist), PinnedMessageRefs: patch.PinnedMessageRefs, RelevantURLs: patch.RelevantURLs, WorkspaceRefs: patch.WorkspaceRefs, BlockedReason: patch.BlockedReason, ParentTaskRef: patch.ParentTaskRef, AttachmentIDs: patch.AttachmentIDs}
}

func toTaskboardChecklistItems(items []TaskChecklistItem) []taskboard.TaskChecklistItem {
	if len(items) == 0 {
		return nil
	}
	out := make([]taskboard.TaskChecklistItem, 0, len(items))
	for _, item := range items {
		out = append(out, taskboard.TaskChecklistItem{ID: item.ID, Text: item.Text, Checked: item.Checked})
	}
	return out
}

func toTaskboardReviewDecisionInput(input TaskReviewDecisionInput) taskboard.TaskReviewDecisionInput {
	return taskboard.TaskReviewDecisionInput{ReviewID: input.ReviewID, Decision: input.Decision, Summary: input.Summary, Questions: input.Questions}
}

func fromTaskboardTask(task taskboard.Task) Task {
	return Task{ID: task.ID, TaskScopeID: task.TaskScopeID, ChannelID: task.ChannelID, TaskNumber: task.TaskNumber, Title: task.Title, Status: task.Status, Description: task.Description, Kind: task.Kind, Priority: task.Priority, BlockedReason: task.BlockedReason, LastActivityAt: task.LastActivityAt, ArtifactCount: task.ArtifactCount, ParentTaskRef: task.ParentTaskRef, DiscussionCount: task.DiscussionCount, AssigneeProfile: taskPrincipalProfileFromTaskboard(task.AssigneeProfile), KindField: fromTaskboardFieldValue(task.KindField), PriorityField: fromTaskboardFieldValue(task.PriorityField), CheckpointProgress: TaskProgressSummary{Total: task.CheckpointProgress.Total, Done: task.CheckpointProgress.Done}, SubtaskProgress: TaskProgressSummary{Total: task.SubtaskProgress.Total, Done: task.SubtaskProgress.Done}, CreatedAt: task.CreatedAt, CreatedByProfile: taskPrincipalProfileFromTaskboard(task.CreatedByProfile), CreatedByType: task.CreatedByType, CreatedByID: task.CreatedByID, CreatedByName: task.CreatedByName, Source: contributionSourceFromTaskboard(task.Source), SourceThread: fromTaskboardSourceThread(task.SourceThread), ReadState: fromTaskboardReadState(task.ReadState), AssignedAt: task.AssignedAt, CompletedAt: task.CompletedAt}
}

func fromTaskboardTasks(tasks []taskboard.Task) []Task {
	if len(tasks) == 0 {
		return nil
	}
	out := make([]Task, 0, len(tasks))
	for _, task := range tasks {
		out = append(out, fromTaskboardTask(task))
	}
	return out
}

func fromTaskboardRelatedTaskSignal(signal *taskboard.RelatedTaskSignal) *RelatedTaskSignal {
	if signal == nil {
		return nil
	}
	return &RelatedTaskSignal{Type: signal.Type, Payload: signal.Payload, CreatedAt: signal.CreatedAt}
}

func fromTaskboardRelatedTaskUnread(unread taskboard.RelatedTaskUnread) RelatedTaskUnread {
	return RelatedTaskUnread{Count: unread.Count, ManualUnread: unread.ManualUnread}
}

func fromTaskboardRelatedTaskRow(row taskboard.RelatedTaskRow) RelatedTaskRow {
	return RelatedTaskRow{
		TaskID:          row.TaskID,
		TaskScopeID:     row.TaskScopeID,
		ChannelID:       row.ChannelID,
		TaskNumber:      row.TaskNumber,
		Title:           row.Title,
		Status:          row.Status,
		ParentTaskID:    row.ParentTaskID,
		ParentTaskRef:   row.ParentTaskRef,
		Source:          contributionSourceFromTaskboard(row.Source),
		SourceThread:    fromTaskboardSourceThread(row.SourceThread),
		AssigneeProfile: taskPrincipalProfileFromTaskboard(row.AssigneeProfile),
		LastSignal:      fromTaskboardRelatedTaskSignal(row.LastSignal),
		Unread:          fromTaskboardRelatedTaskUnread(row.Unread),
		Route:           row.Route,
	}
}

func fromTaskboardRelatedTaskRows(rows []taskboard.RelatedTaskRow) []RelatedTaskRow {
	if len(rows) == 0 {
		return nil
	}
	out := make([]RelatedTaskRow, 0, len(rows))
	for _, row := range rows {
		out = append(out, fromTaskboardRelatedTaskRow(row))
	}
	return out
}

func fromTaskboardRelatedTasksResponse(response taskboard.RelatedTasksResponse) RelatedTasksResponse {
	return RelatedTasksResponse{Tasks: fromTaskboardRelatedTaskRows(response.Rows), HasMore: response.HasMore, NextCursor: RelatedTaskCursor{TaskNumber: response.NextCursor.TaskNumber, TaskID: response.NextCursor.TaskID}}
}

func fromTaskboardTaskViews(views []taskboard.TaskView) []TaskView {
	if len(views) == 0 {
		return nil
	}
	out := make([]TaskView, 0, len(views))
	for _, view := range views {
		out = append(out, TaskView{
			TaskScopeID:      view.TaskScopeID,
			TaskNumber:       view.TaskNumber,
			Title:            view.Title,
			Status:           view.Status,
			AssigneeProfile:  taskPrincipalProfileFromTaskboard(view.AssigneeProfile),
			CreatedByProfile: taskPrincipalProfileFromTaskboard(view.CreatedByProfile),
			CreatedByName:    view.CreatedByName,
		})
	}
	return out
}

func fromTaskboardCreatedTasks(tasks []taskboard.CreatedTask) []CreatedTask {
	if len(tasks) == 0 {
		return nil
	}
	out := make([]CreatedTask, 0, len(tasks))
	for _, task := range tasks {
		out = append(out, CreatedTask{TaskScopeID: task.TaskScopeID, TaskNumber: task.TaskNumber, Title: task.Title, Reused: task.Reused})
	}
	return out
}

func fromTaskboardClaimResults(results []taskboard.ClaimResult) []ClaimResult {
	if len(results) == 0 {
		return nil
	}
	out := make([]ClaimResult, 0, len(results))
	for _, result := range results {
		out = append(out, ClaimResult{TaskNumber: result.TaskNumber, Success: result.Success, Reason: result.Reason})
	}
	return out
}

func taskPrincipalProfileFromTaskboard(profile *taskboard.TaskPrincipalProfile) *AuthorProfile {
	if profile == nil {
		return nil
	}
	return authorProfileFromTaskboard(*profile)
}

func fromTaskboardActor(actor *taskboard.TaskActor) *TaskActor {
	if actor == nil {
		return nil
	}
	return &TaskActor{Type: actor.Type, ID: actor.ID, Name: actor.Name}
}

func fromTaskboardFieldValue(value *taskboard.TaskFieldValue) *TaskFieldValue {
	if value == nil {
		return nil
	}
	return &TaskFieldValue{OptionID: value.OptionID, Key: value.Key, Label: value.Label, RawValue: value.RawValue, IsLegacy: value.IsLegacy, IsNone: value.IsNone}
}

func fromTaskboardSourceThread(thread *taskboard.TaskSourceThread) *TaskSourceThread {
	if thread == nil {
		return nil
	}
	return &TaskSourceThread{ThreadChannelID: thread.ThreadChannelID, ParentChannelID: thread.ParentChannelID, ParentMessageID: thread.ParentMessageID, Ref: thread.Ref}
}

func fromTaskboardReadState(readState *taskboard.TaskReadState) *TaskReadState {
	if readState == nil {
		return nil
	}
	out := fromTaskboardReadStateValue(*readState)
	return &out
}

func fromTaskboardReadStateValue(readState taskboard.TaskReadState) TaskReadState {
	return TaskReadState{
		UnreadCount:            readState.UnreadCount,
		ManualUnread:           readState.ManualUnread,
		LatestEventID:          readState.LatestEventID,
		LatestEventCreatedAt:   readState.LatestEventCreatedAt,
		LastReadEventID:        readState.LastReadEventID,
		LastReadEventCreatedAt: readState.LastReadEventCreatedAt,
		LastMessageReadSeq:     readState.LastMessageReadSeq,
		LastActivityReadSeq:    readState.LastActivityReadSeq,
		ManualUnreadGeneration: readState.ManualUnreadGeneration,
	}
}

func fromTaskboardChecklistItems(items []taskboard.TaskChecklistItem) []TaskChecklistItem {
	if len(items) == 0 {
		return nil
	}
	out := make([]TaskChecklistItem, 0, len(items))
	for _, item := range items {
		out = append(out, TaskChecklistItem{ID: item.ID, Text: item.Text, Checked: item.Checked})
	}
	return out
}

func fromTaskboardArtifact(artifact taskboard.TaskArtifact) TaskArtifact {
	createdByProfile := taskPrincipalProfileFromTaskboard(artifact.CreatedByProfile)
	return TaskArtifact{ID: artifact.ID, Kind: artifact.Kind, Title: artifact.Title, Payload: artifact.Payload, CreatedByProfile: createdByProfile, CreatedByRef: taskFactCompatRefFromAuthorProfile(createdByProfile, artifact.CreatedByRef), CreatedAt: artifact.CreatedAt}
}

func fromTaskboardArtifacts(artifacts []taskboard.TaskArtifact) []TaskArtifact {
	if len(artifacts) == 0 {
		return nil
	}
	out := make([]TaskArtifact, 0, len(artifacts))
	for _, artifact := range artifacts {
		out = append(out, fromTaskboardArtifact(artifact))
	}
	return out
}

func fromTaskboardActivityEvent(event taskboard.TaskActivityEvent) TaskActivityEvent {
	authorProfile := authorProfileFromTaskboard(event.AuthorProfile)
	source := contributionSourceFromTaskboard(event.Source)
	return TaskActivityEvent{ID: event.ID, Type: event.Type, AuthorProfile: authorProfile, Source: source, ActorRef: taskActivityCompatActorRefFromAuthorProfile(authorProfile, event.ActorRef), ActorDisplayName: taskActivityCompatActorDisplayNameFromAuthorProfile(authorProfile, event.ActorDisplayName), Payload: event.Payload, SourceKind: taskActivityCompatSourceKindFromContributionSource(source, event.SourceKind), SourceMessageID: taskActivityCompatSourceMessageIDFromContributionSource(source, event.SourceMessageID), SourceActivityID: taskActivityCompatSourceActivityIDFromContributionSource(source, event.SourceActivityID), CreatedAt: event.CreatedAt}
}

func taskActivityCompatActorRefFromAuthorProfile(profile *AuthorProfile, fallback string) string {
	if profile == nil {
		return fallback
	}
	return firstNonEmptyTaskString(profile.MemberID, profile.PrincipalID, profile.TargetID, fallback)
}

func taskActivityCompatActorDisplayNameFromAuthorProfile(profile *AuthorProfile, fallback string) string {
	if profile == nil {
		return fallback
	}
	return firstNonEmptyTaskString(profile.DisplayName, fallback)
}

func fromTaskboardTimelineEntry(entry taskboard.TaskTimelineEntry) TaskTimelineEntry {
	converted := TaskTimelineEntry{ID: entry.ID, Kind: entry.Kind, CreatedAt: entry.CreatedAt}
	if entry.Activity != nil {
		activity := fromTaskboardActivityEvent(*entry.Activity)
		converted.Activity = &activity
	}
	if entry.Discussion != nil {
		discussion := fromTaskboardDiscussionEntry(*entry.Discussion)
		converted.Discussion = &discussion
	}
	return converted
}

func fromTaskboardTimelineEntries(entries []taskboard.TaskTimelineEntry) []TaskTimelineEntry {
	if len(entries) == 0 {
		return nil
	}
	out := make([]TaskTimelineEntry, 0, len(entries))
	for _, entry := range entries {
		out = append(out, fromTaskboardTimelineEntry(entry))
	}
	return out
}

func fromTaskboardReview(review taskboard.TaskReviewRequest) TaskReviewRequest {
	requestedByProfile := taskPrincipalProfileFromTaskboard(review.RequestedByProfile)
	reviewerProfile := taskPrincipalProfileFromTaskboard(review.ReviewerProfile)
	decidedByProfile := taskPrincipalProfileFromTaskboard(review.DecidedByProfile)
	return TaskReviewRequest{ID: review.ID, Status: review.Status, RequestedByProfile: requestedByProfile, ReviewerProfile: reviewerProfile, DecidedByProfile: decidedByProfile, RequestedByRef: taskFactCompatRefFromAuthorProfile(requestedByProfile, review.RequestedByRef), ReviewerRef: taskFactCompatRefFromAuthorProfile(reviewerProfile, review.ReviewerRef), Summary: review.Summary, Questions: review.Questions, Decision: review.Decision, DecisionSummary: review.DecisionSummary, DecisionQuestions: review.DecisionQuestions, DecidedByRef: taskFactCompatRefFromAuthorProfile(decidedByProfile, review.DecidedByRef), ReviewTargetType: review.ReviewTargetType, ReviewTargetPayload: review.ReviewTargetPayload, RequestedAt: review.RequestedAt, DecidedAt: review.DecidedAt}
}

func fromTaskboardReviews(reviews []taskboard.TaskReviewRequest) []TaskReviewRequest {
	if len(reviews) == 0 {
		return nil
	}
	out := make([]TaskReviewRequest, 0, len(reviews))
	for _, review := range reviews {
		out = append(out, fromTaskboardReview(review))
	}
	return out
}

func fromTaskboardDiscussionEntry(entry taskboard.TaskDiscussionEntry) TaskDiscussionEntry {
	authorProfile := authorProfileFromTaskboard(entry.AuthorProfile)
	return TaskDiscussionEntry{
		ID:                  entry.ID,
		TaskID:              entry.TaskID,
		Body:                entry.Body,
		AuthorProfile:       authorProfile,
		Source:              contributionSourceFromTaskboard(entry.Source),
		CreatedBy:           taskDiscussionCompatActorFromAuthorProfile(authorProfile, entry.CreatedBy),
		ResolvedMentions:    fromTaskboardResolvedMentions(entry.ResolvedMentions),
		Reactions:           fromTaskboardDiscussionReactions(entry.Reactions),
		Attachments:         fromTaskboardDiscussionAttachments(entry.Attachments),
		CreatedAt:           entry.CreatedAt,
		UpdatedAt:           entry.UpdatedAt,
		EditedAt:            entry.EditedAt,
		EditedByMemberID:    entry.EditedByMemberID,
		EditRevision:        entry.EditRevision,
		MessagePresentation: entry.MessagePresentation,
	}
}

func fromTaskboardResolvedMentions(mentions []message.ResolvedMention) []ResolvedMention {
	if len(mentions) == 0 {
		return nil
	}
	out := make([]ResolvedMention, 0, len(mentions))
	for _, mention := range mentions {
		out = append(out, ResolvedMention{
			Token: mention.Token, Type: mention.Type, ID: mention.ID,
			DisplayName: mention.DisplayName, ResolvedToken: mention.ResolvedToken,
		})
	}
	return out
}

func fromTaskboardDiscussionAttachments(attachments []attachment.AppAttachment) []TaskDiscussionAttachment {
	if len(attachments) == 0 {
		return nil
	}
	out := make([]TaskDiscussionAttachment, 0, len(attachments))
	for _, attachment := range attachments {
		out = append(out, TaskDiscussionAttachment{
			ID:           attachment.ID,
			Filename:     attachment.Filename,
			ContentType:  attachment.ContentType,
			SizeBytes:    attachment.SizeBytes,
			ThumbnailURL: attachment.ThumbnailURL,
		})
	}
	return out
}

func fromTaskboardDiscussionReactionReactor(reactor message.MessageReactionReactor) MessageReactionReactor {
	return MessageReactionReactor{AuthorProfile: authorProfileFromTaskboard(reactor.AuthorProfile)}
}

func fromTaskboardDiscussionReactionReactors(reactors []message.MessageReactionReactor) []MessageReactionReactor {
	if len(reactors) == 0 {
		return nil
	}
	out := make([]MessageReactionReactor, 0, len(reactors))
	for _, reactor := range reactors {
		out = append(out, fromTaskboardDiscussionReactionReactor(reactor))
	}
	return out
}

func fromTaskboardDiscussionReactions(reactions []message.MessageReactionAggregate) []MessageReactionAggregate {
	if len(reactions) == 0 {
		return nil
	}
	out := make([]MessageReactionAggregate, 0, len(reactions))
	for _, reaction := range reactions {
		out = append(out, MessageReactionAggregate{Emoji: reaction.Emoji, Count: reaction.Count, Reactors: fromTaskboardDiscussionReactionReactors(reaction.Reactors)})
	}
	return out
}

func fromTaskboardTaskDetail(detail taskboard.TaskDetail) TaskDetail {
	var parentTask *Task
	if detail.ParentTask != nil {
		convertedParentTask := fromTaskboardTask(*detail.ParentTask)
		parentTask = &convertedParentTask
	}
	return TaskDetail{Task: fromTaskboardTask(detail.Task), ParentTask: parentTask, Checkpoints: fromTaskboardChecklistItems(detail.Checkpoints), Timeline: fromTaskboardTimelineEntries(detail.Timeline), TimelineHasMore: detail.TimelineHasMore, TimelineNextCursor: fromTaskboardTaskTimelineCursor(detail.TimelineNextCursor), AcceptanceCriteria: fromTaskboardChecklistItems(detail.AcceptanceCriteria), ReviewChecklist: fromTaskboardChecklistItems(detail.ReviewChecklist), Subtasks: fromTaskboardTasks(detail.Subtasks), SubtasksHasMore: detail.SubtasksHasMore, SubtasksNextCursor: fromTaskboardSubtaskCursor(detail.SubtasksNextCursor), PinnedMessageRefs: detail.PinnedMessageRefs, RelevantURLs: detail.RelevantURLs, WorkspaceRefs: detail.WorkspaceRefs, ReviewHistory: fromTaskboardReviews(detail.ReviewHistory), Artifacts: fromTaskboardArtifacts(detail.Artifacts)}
}

func fromTaskboardFieldOption(option taskboard.TaskFieldOption) TaskFieldOption {
	return TaskFieldOption{ID: option.ID, FieldKind: option.FieldKind, Key: option.Key, Label: option.Label, Aliases: option.Aliases, Position: option.Position, IsActive: option.IsActive, UsageCount: option.UsageCount}
}

func fromTaskboardFieldOptions(options []taskboard.TaskFieldOption) []TaskFieldOption {
	if len(options) == 0 {
		return nil
	}
	out := make([]TaskFieldOption, 0, len(options))
	for _, option := range options {
		out = append(out, fromTaskboardFieldOption(option))
	}
	return out
}

func fromTaskboardViewState(state taskboard.TaskBoardViewState) TaskBoardViewState {
	return TaskBoardViewState{View: state.View, SearchQuery: state.SearchQuery, QuickFilters: state.QuickFilters, StructuredFilters: state.StructuredFilters, SortMode: state.SortMode, CardPropertyToggles: state.CardPropertyToggles, DoneCollapsed: state.DoneCollapsed}
}

func fromTaskboardSavedView(savedView taskboard.TaskBoardSavedView) TaskBoardSavedView {
	return TaskBoardSavedView{ID: savedView.ID, WorkspaceID: savedView.WorkspaceID, MemberID: savedView.MemberID, Name: savedView.Name, ViewState: fromTaskboardViewState(savedView.ViewState), CreatedAt: savedView.CreatedAt, UpdatedAt: savedView.UpdatedAt}
}

func fromTaskboardSavedViews(savedViews []taskboard.TaskBoardSavedView) []TaskBoardSavedView {
	if len(savedViews) == 0 {
		return nil
	}
	out := make([]TaskBoardSavedView, 0, len(savedViews))
	for _, savedView := range savedViews {
		out = append(out, fromTaskboardSavedView(savedView))
	}
	return out
}

func fromTaskboardTaskBrowseQuery(query taskboard.TaskBrowseQuery) TaskBrowseQuery {
	return TaskBrowseQuery{Limit: query.Limit, SearchQuery: query.SearchQuery, SortMode: query.SortMode, StatusFilter: query.StatusFilter, QuickFilters: query.QuickFilters, StructuredFilters: query.StructuredFilters, IncludeSubtasks: query.IncludeSubtasks, Cursor: fromTaskboardTaskBrowseCursor(query.Cursor), ColumnCursors: fromTaskboardTaskBrowseCursors(query.ColumnCursors)}
}

func fromTaskboardRowBrowsePage(page taskboard.TaskRowBrowsePage) TaskRowBrowsePage {
	return TaskRowBrowsePage{QueryEcho: fromTaskboardTaskBrowseQuery(page.QueryEcho), Rows: fromTaskboardTasks(page.Rows), TotalCount: page.TotalCount, HasMore: page.HasMore, NextCursor: fromTaskboardTaskBrowseCursor(page.NextCursor), ColumnCounts: page.ColumnCounts}
}

func fromTaskboardBoardColumnPage(page taskboard.TaskBoardColumnPage) TaskBoardColumnPage {
	return TaskBoardColumnPage{Tasks: fromTaskboardTasks(page.Tasks), Count: page.Count, HasMore: page.HasMore, NextCursor: fromTaskboardTaskBrowseCursor(page.NextCursor)}
}

func fromTaskboardBoardColumns(columns map[string]taskboard.TaskBoardColumnPage) map[string]TaskBoardColumnPage {
	if len(columns) == 0 {
		return nil
	}
	out := make(map[string]TaskBoardColumnPage, len(columns))
	for key, page := range columns {
		out[key] = fromTaskboardBoardColumnPage(page)
	}
	return out
}

func fromTaskboardBoardColumnDefinitions(definitions []taskboard.TaskBoardColumnDefinition) []TaskBoardColumnDefinition {
	if len(definitions) == 0 {
		return nil
	}
	out := make([]TaskBoardColumnDefinition, 0, len(definitions))
	for _, definition := range definitions {
		out = append(out, TaskBoardColumnDefinition{
			Key:    definition.Key,
			Name:   definition.Name,
			Source: definition.Source,
		})
	}
	return out
}

func fromTaskboardBoardBrowsePage(page taskboard.TaskBoardBrowsePage) TaskBoardBrowsePage {
	return TaskBoardBrowsePage{
		QueryEcho:         fromTaskboardTaskBrowseQuery(page.QueryEcho),
		TotalCount:        page.TotalCount,
		ColumnOrder:       append([]string(nil), page.ColumnOrder...),
		ColumnDefinitions: fromTaskboardBoardColumnDefinitions(page.ColumnDefinitions),
		ColumnCounts:      page.ColumnCounts,
		Columns:           fromTaskboardBoardColumns(page.Columns),
	}
}

func fromTaskboardTaskReviewDecisionResponse(response taskboard.TaskReviewDecisionResponse) TaskReviewDecisionResponse {
	return TaskReviewDecisionResponse{Task: fromTaskboardTask(response.Task), Review: fromTaskboardReview(response.Review)}
}