package dto

import (
	"time"

	"browser.local/platform/domain"
)

type RunJobAssignmentResponse struct {
	JobID            string                   `json:"jobId"`
	ServerInstanceID string                   `json:"serverInstanceId,omitempty"`
	RunEndpointID    string                   `json:"runEndpointId"`
	Capability       string                   `json:"capability"`
	TargetKey        string                   `json:"targetKey,omitempty"`
	InputRef         string                   `json:"inputRef,omitempty"`
	IdempotencyKey   string                   `json:"idempotencyKey"`
	State            domain.JobState          `json:"state"`
	Progress         JobProgressBody          `json:"progress"`
	ResultRef        string                   `json:"resultRef,omitempty"`
	ExecutionInput   RunJobExecutionInputBody `json:"executionInput,omitempty"`
	LeaseToken       string                   `json:"leaseToken"`
	Attempt          int                      `json:"attempt"`
	MaxAttempts      int                      `json:"maxAttempts"`
	AckDeadlineAt    time.Time                `json:"ackDeadlineAt,omitempty"`
	LeaseExpiresAt   time.Time                `json:"leaseExpiresAt,omitempty"`
	NextAttemptAt    time.Time                `json:"nextAttemptAt,omitempty"`
	ProgressSequence uint64                   `json:"progressSequence,omitempty"`
	CreatedAt        time.Time                `json:"createdAt"`
	UpdatedAt        time.Time                `json:"updatedAt"`
}

type RunJobClaimRequest struct {
	RunEndpointID string              `json:"runEndpointId"`
	SessionToken  string              `json:"sessionToken"`
	Capabilities  []string            `json:"capabilities"`
	Capacity      RunCapacityResponse `json:"capacity"`
}

type RunJobClaimResponse struct {
	Accepted        bool                      `json:"accepted"`
	RunEndpointID   string                    `json:"runEndpointId"`
	HasJob          bool                      `json:"hasJob"`
	Job             *RunJobAssignmentResponse `json:"job,omitempty"`
	NextPollSeconds int                       `json:"nextPollSeconds"`
	ServerTime      time.Time                 `json:"serverTime"`
}

type RunJobAckRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	JobID         string `json:"jobId"`
	LeaseToken    string `json:"leaseToken"`
	Attempt       int    `json:"attempt"`
	Message       string `json:"message,omitempty"`
}

type RunJobAckResponse struct {
	Accepted   bool                     `json:"accepted"`
	Job        RunJobAssignmentResponse `json:"job"`
	ServerTime time.Time                `json:"serverTime"`
}

type RunJobProgressRequest struct {
	RunEndpointID string          `json:"runEndpointId"`
	SessionToken  string          `json:"sessionToken"`
	JobID         string          `json:"jobId"`
	LeaseToken    string          `json:"leaseToken"`
	Attempt       int             `json:"attempt"`
	Progress      JobProgressBody `json:"progress"`
	Sequence      uint64          `json:"sequence,omitempty"`
}

type RunJobProgressResponse struct {
	Accepted   bool                     `json:"accepted"`
	Job        RunJobAssignmentResponse `json:"job"`
	ServerTime time.Time                `json:"serverTime"`
}

type RunJobResultRequest struct {
	RunEndpointID   string                    `json:"runEndpointId"`
	SessionToken    string                    `json:"sessionToken"`
	JobID           string                    `json:"jobId"`
	LeaseToken      string                    `json:"leaseToken"`
	Attempt         int                       `json:"attempt"`
	State           domain.JobState           `json:"state"`
	Progress        JobProgressBody           `json:"progress"`
	ResultRef       string                    `json:"resultRef,omitempty"`
	Message         string                    `json:"message,omitempty"`
	ErrorCode       string                    `json:"errorCode,omitempty"`
	Retryable       bool                      `json:"retryable,omitempty"`
	ExecutionResult RunJobExecutionResultBody `json:"executionResult,omitempty"`
}

type RunJobExecutionInputBody struct {
	WorkspaceScope    string `json:"workspaceScope,omitempty"`
	Content           string `json:"content,omitempty"`
	ExpectedVersion   int    `json:"expectedVersion,omitempty"`
	ExpectedChecksum  string `json:"expectedChecksum,omitempty"`
	MaxReadBytes      int    `json:"maxReadBytes,omitempty"`
	RemoteAdapterKey  string `json:"remoteAdapterKey,omitempty"`
	RemoteAdapterKind string `json:"remoteAdapterKind,omitempty"`
	TimeoutSeconds    int    `json:"timeoutSeconds,omitempty"`
}

type RunJobExecutionResultBody struct {
	Kind               string `json:"kind,omitempty"`
	ProcessState       string `json:"processState,omitempty"`
	ExitClassification string `json:"exitClassification,omitempty"`
	ExitCode           int    `json:"exitCode,omitempty"`
	Version            int    `json:"version,omitempty"`
	Checksum           string `json:"checksum,omitempty"`
	SizeBytes          int64  `json:"sizeBytes,omitempty"`
	AuditSummary       string `json:"auditSummary,omitempty"`
	Content            string `json:"content,omitempty"`
}

type RunJobResultResponse struct {
	Accepted   bool                     `json:"accepted"`
	Job        RunJobAssignmentResponse `json:"job"`
	ServerTime time.Time                `json:"serverTime"`
}

type DistributionBuildInputRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	JobID         string `json:"jobId"`
	LeaseToken    string `json:"leaseToken"`
	Attempt       int    `json:"attempt"`
}

type DistributionBuildInputResponse struct {
	JobID            string `json:"jobId"`
	ComponentKind    string `json:"componentKind"`
	ServerInstanceID string `json:"serverInstanceId"`
	PluginID         string `json:"pluginId"`
	RunEndpointID    string `json:"runEndpointId"`
	ProfileKey       string `json:"profileKey,omitempty"`
	TargetOS         string `json:"targetOs"`
	TargetArch       string `json:"targetArch"`
	TargetRelease    string `json:"targetRelease"`
	PackageFormat    string `json:"packageFormat"`
	RepositoryURL    string `json:"repositoryUrl,omitempty"`
	SourceRevision   string `json:"sourceRevision,omitempty"`
	ArtifactID       string `json:"artifactId"`
	OutputFilename   string `json:"outputFilename"`
	SecretRef        string `json:"secretRef"`
	KeyGeneration    int    `json:"keyGeneration"`
	AuthKey          string `json:"authKey"`
}

type DependencyExecutionInputRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	JobID         string `json:"jobId"`
	LeaseToken    string `json:"leaseToken"`
	Attempt       int    `json:"attempt"`
}

type DependencyExecutionInputResponse struct {
	JobID            string                     `json:"jobId"`
	ServerInstanceID string                     `json:"serverInstanceId"`
	RunEndpointID    string                     `json:"runEndpointId"`
	PluginID         string                     `json:"pluginId"`
	PluginVersion    string                     `json:"pluginVersion"`
	ProfileKey       string                     `json:"profileKey"`
	TargetOS         string                     `json:"targetOs"`
	TargetArch       string                     `json:"targetArch"`
	PlanDigest       string                     `json:"planDigest"`
	Probe            RuntimeDependencyProbeBody `json:"probe,omitempty"`
	Plan             RuntimeInstallPlanBody     `json:"plan,omitempty"`
	Bindings         map[string]string          `json:"bindings"`
}

type RunUpdateInputRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	JobID         string `json:"jobId"`
	LeaseToken    string `json:"leaseToken"`
	Attempt       int    `json:"attempt"`
}

type RunUpdateInputResponse struct {
	JobID            string `json:"jobId"`
	ServerInstanceID string `json:"serverInstanceId"`
	RunEndpointID    string `json:"runEndpointId"`
	ArtifactID       string `json:"artifactId"`
	Checksum         string `json:"checksum"`
	SizeBytes        int64  `json:"sizeBytes"`
	TargetOS         string `json:"targetOs"`
	TargetArch       string `json:"targetArch"`
	PackageFormat    string `json:"packageFormat"`
	ExecutableName   string `json:"executableName"`
	TargetRelease    string `json:"targetRelease"`
	ChunkSizeBytes   int    `json:"chunkSizeBytes"`
}

type RunUpdateChunkRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	JobID         string `json:"jobId"`
	LeaseToken    string `json:"leaseToken"`
	Attempt       int    `json:"attempt"`
	Offset        int64  `json:"offset"`
	Length        int    `json:"length"`
}

type RunUpdateChunkResponse struct {
	JobID      string `json:"jobId"`
	ArtifactID string `json:"artifactId"`
	Offset     int64  `json:"offset"`
	TotalBytes int64  `json:"totalBytes"`
	Checksum   string `json:"checksum"`
	Payload    []byte `json:"payload"`
	Complete   bool   `json:"complete"`
}

type RunUpdateHealthRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	JobID         string `json:"jobId"`
	LeaseToken    string `json:"leaseToken"`
	Attempt       int    `json:"attempt"`
	Outcome       string `json:"outcome"`
	Version       string `json:"version"`
}

type RunUpdateHealthResponse struct {
	Accepted   bool                  `json:"accepted"`
	JobID      string                `json:"jobId"`
	Phase      domain.RunUpdatePhase `json:"phase"`
	ServerTime time.Time             `json:"serverTime"`
}

type RunJobCancelRequestBody struct {
	JobID  string `json:"jobId"`
	Reason string `json:"reason"`
}

type RunJobCancelRequestResponse struct {
	Accepted    bool            `json:"accepted"`
	JobID       string          `json:"jobId"`
	Reason      string          `json:"reason"`
	RequestedAt time.Time       `json:"requestedAt"`
	CompletedAt time.Time       `json:"completedAt,omitempty"`
	State       domain.JobState `json:"state"`
}

type RunJobCancelPollRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	JobID         string `json:"jobId,omitempty"`
	LeaseToken    string `json:"leaseToken,omitempty"`
	Attempt       int    `json:"attempt"`
}

type RunJobCancelPollResponse struct {
	Accepted      bool      `json:"accepted"`
	RunEndpointID string    `json:"runEndpointId"`
	HasCancel     bool      `json:"hasCancel"`
	JobID         string    `json:"jobId,omitempty"`
	Reason        string    `json:"reason,omitempty"`
	RequestedAt   time.Time `json:"requestedAt,omitempty"`
	ServerTime    time.Time `json:"serverTime"`
}

type RunJobReconcileEntry struct {
	JobID      string `json:"jobId"`
	LeaseToken string `json:"leaseToken"`
	Attempt    int    `json:"attempt"`
}

type RunJobReconcileRequest struct {
	RunEndpointID string                 `json:"runEndpointId"`
	SessionToken  string                 `json:"sessionToken"`
	ActiveJobs    []RunJobReconcileEntry `json:"activeJobs"`
}

type RunJobReconcileResponse struct {
	Accepted      bool                       `json:"accepted"`
	RunEndpointID string                     `json:"runEndpointId"`
	ConfirmedJobs []RunJobAssignmentResponse `json:"confirmedJobs"`
	DiscardJobIDs []string                   `json:"discardJobIds"`
	ServerTime    time.Time                  `json:"serverTime"`
}

func (request RunJobClaimRequest) ToDomain() domain.RunJobClaim {
	return domain.RunJobClaim{
		RunEndpointID: request.RunEndpointID,
		SessionToken:  request.SessionToken,
		Capabilities:  domain.CopyStringSlice(request.Capabilities),
		Capacity:      capacityToDomain(request.Capacity),
	}
}

func (request RunJobAckRequest) ToDomain() domain.RunJobAck {
	return domain.RunJobAck{
		RunEndpointID: request.RunEndpointID,
		SessionToken:  request.SessionToken,
		JobID:         request.JobID,
		LeaseToken:    request.LeaseToken,
		Attempt:       request.Attempt,
		Message:       request.Message,
	}
}

func (request RunJobProgressRequest) ToDomain() domain.RunJobProgress {
	return domain.RunJobProgress{
		RunEndpointID: request.RunEndpointID,
		SessionToken:  request.SessionToken,
		JobID:         request.JobID,
		LeaseToken:    request.LeaseToken,
		Attempt:       request.Attempt,
		Progress:      progressReportToDomain(request.Progress),
		Sequence:      request.Sequence,
	}
}

func (request RunJobResultRequest) ToDomain() domain.RunJobResult {
	return domain.RunJobResult{
		RunEndpointID:   request.RunEndpointID,
		SessionToken:    request.SessionToken,
		JobID:           request.JobID,
		LeaseToken:      request.LeaseToken,
		Attempt:         request.Attempt,
		State:           request.State,
		Progress:        progressReportToDomain(request.Progress),
		ResultRef:       request.ResultRef,
		Message:         request.Message,
		ErrorCode:       request.ErrorCode,
		Retryable:       request.Retryable,
		ExecutionResult: domain.JobExecutionResult{Kind: request.ExecutionResult.Kind, ProcessState: request.ExecutionResult.ProcessState, ExitClassification: request.ExecutionResult.ExitClassification, ExitCode: request.ExecutionResult.ExitCode, Version: request.ExecutionResult.Version, Checksum: request.ExecutionResult.Checksum, SizeBytes: request.ExecutionResult.SizeBytes, AuditSummary: request.ExecutionResult.AuditSummary, Content: request.ExecutionResult.Content},
	}
}

func (request DistributionBuildInputRequest) ToDomain() domain.DistributionBuildInputRequest {
	return domain.DistributionBuildInputRequest{
		RunEndpointID: request.RunEndpointID,
		SessionToken:  request.SessionToken,
		JobID:         request.JobID,
		LeaseToken:    request.LeaseToken,
		Attempt:       request.Attempt,
	}
}

func (request DependencyExecutionInputRequest) ToDomain() domain.DependencyExecutionInputRequest {
	return domain.DependencyExecutionInputRequest{RunEndpointID: request.RunEndpointID, SessionToken: request.SessionToken, JobID: request.JobID, LeaseToken: request.LeaseToken, Attempt: request.Attempt}
}

func (request RunUpdateInputRequest) ToDomain() domain.RunUpdateInputRequest {
	return domain.RunUpdateInputRequest{RunEndpointID: request.RunEndpointID, SessionToken: request.SessionToken, JobID: request.JobID, LeaseToken: request.LeaseToken, Attempt: request.Attempt}
}

func (request RunUpdateChunkRequest) ToDomain() domain.RunUpdateChunkRequest {
	return domain.RunUpdateChunkRequest{RunEndpointID: request.RunEndpointID, SessionToken: request.SessionToken, JobID: request.JobID, LeaseToken: request.LeaseToken, Attempt: request.Attempt, Offset: request.Offset, Length: request.Length}
}

func (request RunUpdateHealthRequest) ToDomain() domain.RunUpdateHealthReport {
	return domain.RunUpdateHealthReport{RunEndpointID: request.RunEndpointID, SessionToken: request.SessionToken, JobID: request.JobID, LeaseToken: request.LeaseToken, Attempt: request.Attempt, Outcome: request.Outcome, Version: request.Version}
}

func (request RunJobCancelRequestBody) ToDomain() domain.RunJobCancelRequest {
	return domain.RunJobCancelRequest{
		JobID:  request.JobID,
		Reason: request.Reason,
	}
}

func (request RunJobCancelPollRequest) ToDomain() domain.RunJobCancelPoll {
	return domain.RunJobCancelPoll{
		RunEndpointID: request.RunEndpointID,
		SessionToken:  request.SessionToken,
		JobID:         request.JobID,
		LeaseToken:    request.LeaseToken,
		Attempt:       request.Attempt,
	}
}

func (request RunJobReconcileRequest) ToDomain() domain.RunJobReconcile {
	active := make([]domain.RunJobReconcileEntry, len(request.ActiveJobs))
	for i, entry := range request.ActiveJobs {
		active[i] = domain.RunJobReconcileEntry{JobID: entry.JobID, LeaseToken: entry.LeaseToken, Attempt: entry.Attempt}
	}
	return domain.RunJobReconcile{
		RunEndpointID: request.RunEndpointID,
		SessionToken:  request.SessionToken,
		ActiveJobs:    active,
	}
}

func RunJobClaimFromDomain(result domain.RunJobClaimResult) RunJobClaimResponse {
	result = domain.CopyRunJobClaimResult(result)
	return RunJobClaimResponse{
		Accepted:        result.Accepted,
		RunEndpointID:   result.RunEndpointID,
		HasJob:          result.HasJob,
		Job:             RunJobAssignmentPtrFromDomain(result.Job),
		NextPollSeconds: result.NextPollSeconds,
		ServerTime:      result.ServerTime,
	}
}

func RunJobAckFromDomain(result domain.RunJobAckResult) RunJobAckResponse {
	return RunJobAckResponse{
		Accepted:   result.Accepted,
		Job:        RunJobAssignmentFromDomain(result.Job),
		ServerTime: result.ServerTime,
	}
}

func RunJobProgressFromDomain(result domain.RunJobProgressResult) RunJobProgressResponse {
	return RunJobProgressResponse{
		Accepted:   result.Accepted,
		Job:        RunJobAssignmentFromDomain(result.Job),
		ServerTime: result.ServerTime,
	}
}

func RunJobResultFromDomain(result domain.RunJobResultResult) RunJobResultResponse {
	return RunJobResultResponse{
		Accepted:   result.Accepted,
		Job:        RunJobAssignmentFromDomain(result.Job),
		ServerTime: result.ServerTime,
	}
}

func DistributionBuildInputFromDomain(input domain.DistributionBuildInput) DistributionBuildInputResponse {
	return DistributionBuildInputResponse{
		JobID:            input.JobID,
		ComponentKind:    string(input.ComponentKind),
		ServerInstanceID: input.ServerInstanceID,
		PluginID:         input.PluginID,
		RunEndpointID:    input.RunEndpointID,
		ProfileKey:       input.ProfileKey,
		TargetOS:         input.TargetOS,
		TargetArch:       input.TargetArch,
		TargetRelease:    input.TargetRelease,
		PackageFormat:    input.PackageFormat,
		RepositoryURL:    input.RepositoryURL,
		SourceRevision:   input.SourceRevision,
		ArtifactID:       input.ArtifactID,
		OutputFilename:   input.OutputFilename,
		SecretRef:        input.SecretRef,
		KeyGeneration:    input.KeyGeneration,
		AuthKey:          input.AuthKey,
	}
}

func DependencyExecutionInputFromDomain(input domain.DependencyExecutionInput) DependencyExecutionInputResponse {
	input = domain.CopyDependencyExecutionInput(input)
	steps := make([]RuntimeInstallStepBody, len(input.Plan.Steps))
	for i, step := range input.Plan.Steps {
		steps[i] = RuntimeInstallStepBody{Type: step.Type, TargetKey: step.TargetKey, PackageManager: step.PackageManager, PackageName: step.PackageName, Version: step.Version, DownloadRef: step.DownloadRef, Checksum: step.Checksum}
	}
	return DependencyExecutionInputResponse{JobID: input.JobID, ServerInstanceID: input.ServerInstanceID, RunEndpointID: input.RunEndpointID, PluginID: input.PluginID, PluginVersion: input.PluginVersion, ProfileKey: input.ProfileKey, TargetOS: input.TargetOS, TargetArch: input.TargetArch, PlanDigest: input.PlanDigest, Probe: RuntimeDependencyProbeBody{Key: input.Probe.Key, Kind: input.Probe.Kind, TargetKey: input.Probe.TargetKey, Required: input.Probe.Required, MinimumVersion: input.Probe.MinimumVersion, Platforms: input.Probe.Platforms}, Plan: RuntimeInstallPlanBody{Key: input.Plan.Key, Title: input.Plan.Title, Platforms: input.Plan.Platforms, Steps: steps}, Bindings: input.Bindings}
}

func RunUpdateInputFromDomain(input domain.RunUpdateInput) RunUpdateInputResponse {
	return RunUpdateInputResponse{JobID: input.JobID, ServerInstanceID: input.ServerInstanceID, RunEndpointID: input.RunEndpointID, ArtifactID: input.ArtifactID, Checksum: input.Checksum, SizeBytes: input.SizeBytes, TargetOS: input.TargetOS, TargetArch: input.TargetArch, PackageFormat: input.PackageFormat, ExecutableName: input.ExecutableName, TargetRelease: input.TargetRelease, ChunkSizeBytes: input.ChunkSizeBytes}
}

func RunUpdateChunkFromDomain(chunk domain.RunUpdateChunk) RunUpdateChunkResponse {
	chunk = domain.CopyRunUpdateChunk(chunk)
	return RunUpdateChunkResponse{JobID: chunk.JobID, ArtifactID: chunk.ArtifactID, Offset: chunk.Offset, TotalBytes: chunk.TotalBytes, Checksum: chunk.Checksum, Payload: chunk.Payload, Complete: chunk.Complete}
}

func RunUpdateHealthFromDomain(result domain.RunUpdateHealthResult) RunUpdateHealthResponse {
	return RunUpdateHealthResponse{Accepted: result.Accepted, JobID: result.JobID, Phase: result.Phase, ServerTime: result.ServerTime}
}

func RunJobCancelRequestFromDomain(result domain.RunJobCancelRequestResult) RunJobCancelRequestResponse {
	return RunJobCancelRequestResponse{
		Accepted:    result.Accepted,
		JobID:       result.JobID,
		Reason:      result.Reason,
		RequestedAt: result.RequestedAt,
		CompletedAt: result.CompletedAt,
		State:       result.State,
	}
}

func RunJobCancelPollFromDomain(result domain.RunJobCancelPollResult) RunJobCancelPollResponse {
	return RunJobCancelPollResponse{
		Accepted:      result.Accepted,
		RunEndpointID: result.RunEndpointID,
		HasCancel:     result.HasCancel,
		JobID:         result.JobID,
		Reason:        result.Reason,
		RequestedAt:   result.RequestedAt,
		ServerTime:    result.ServerTime,
	}
}

func RunJobReconcileFromDomain(result domain.RunJobReconcileResult) RunJobReconcileResponse {
	result = domain.CopyRunJobReconcileResult(result)
	items := make([]RunJobAssignmentResponse, len(result.ConfirmedJobs))
	for i, assignment := range result.ConfirmedJobs {
		items[i] = RunJobAssignmentFromDomain(assignment)
	}
	return RunJobReconcileResponse{
		Accepted:      result.Accepted,
		RunEndpointID: result.RunEndpointID,
		ConfirmedJobs: items,
		DiscardJobIDs: result.DiscardJobIDs,
		ServerTime:    result.ServerTime,
	}
}

func RunJobAssignmentPtrFromDomain(assignment *domain.RunJobAssignment) *RunJobAssignmentResponse {
	if assignment == nil {
		return nil
	}
	response := RunJobAssignmentFromDomain(*assignment)
	return &response
}

func RunJobAssignmentFromDomain(assignment domain.RunJobAssignment) RunJobAssignmentResponse {
	return RunJobAssignmentResponse{
		JobID:            assignment.JobID,
		ServerInstanceID: assignment.ServerInstanceID,
		RunEndpointID:    assignment.RunEndpointID,
		Capability:       assignment.Capability,
		TargetKey:        assignment.TargetKey,
		InputRef:         assignment.InputRef,
		IdempotencyKey:   assignment.IdempotencyKey,
		State:            assignment.State,
		Progress:         progressReportFromDomain(assignment.Progress),
		ResultRef:        assignment.ResultRef,
		ExecutionInput:   RunJobExecutionInputBody{WorkspaceScope: assignment.ExecutionInput.WorkspaceScope, Content: assignment.ExecutionInput.Content, ExpectedVersion: assignment.ExecutionInput.ExpectedVersion, ExpectedChecksum: assignment.ExecutionInput.ExpectedChecksum, MaxReadBytes: assignment.ExecutionInput.MaxReadBytes, RemoteAdapterKey: assignment.ExecutionInput.RemoteAdapterKey, RemoteAdapterKind: assignment.ExecutionInput.RemoteAdapterKind, TimeoutSeconds: assignment.ExecutionInput.TimeoutSeconds},
		LeaseToken:       assignment.LeaseToken,
		Attempt:          assignment.Attempt,
		MaxAttempts:      assignment.MaxAttempts,
		AckDeadlineAt:    assignment.AckDeadlineAt,
		LeaseExpiresAt:   assignment.LeaseExpiresAt,
		NextAttemptAt:    assignment.NextAttemptAt,
		ProgressSequence: assignment.ProgressSequence,
		CreatedAt:        assignment.CreatedAt,
		UpdatedAt:        assignment.UpdatedAt,
	}
}

func progressReportToDomain(progress JobProgressBody) domain.RunJobProgressReport {
	return domain.RunJobProgressReport{
		Percent: progress.Percent,
		Message: progress.Message,
	}
}

func progressReportFromDomain(progress domain.RunJobProgressReport) JobProgressBody {
	return JobProgressBody{
		Percent: progress.Percent,
		Message: progress.Message,
	}
}