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"`
	PluginID             string                         `json:"pluginId,omitempty"`
	LifecycleOperation   string                         `json:"lifecycleOperation,omitempty"`
	TargetVersion        string                         `json:"targetVersion,omitempty"`
	Inputs               map[string]string              `json:"inputs,omitempty"`
	DLLExtensions        []RuntimeDLLExtensionPlanBody  `json:"dllExtensions,omitempty"`
	SourceRCON           *RuntimeSourceRCONPlanBody     `json:"sourceRcon,omitempty"`
	Deployment           *ServerDeploymentExecutionBody `json:"deployment,omitempty"`
	ServerDeploymentPlan *ServerDeploymentPlanBody      `json:"serverDeploymentPlan,omitempty"`
}

type ServerDeploymentPlanBody struct {
	SchemaVersion      string                               `json:"schemaVersion"`
	Operation          string                               `json:"operation"`
	PluginID           string                               `json:"pluginId"`
	TemplateKey        string                               `json:"templateKey"`
	TemplateVersion    string                               `json:"templateVersion"`
	SteamAppID         string                               `json:"steamAppId"`
	ExecutableKey      string                               `json:"executableKey"`
	InstallRootKey     string                               `json:"installRootKey"`
	ConfigKey          string                               `json:"configKey"`
	ConfigFormat       string                               `json:"configFormat"`
	ConfigMappings     []RuntimeServerConfigMappingBody     `json:"configMappings"`
	DiscoveryMarkers   []RuntimeServerDiscoveryMarkerBody   `json:"discoveryMarkers"`
	VerificationChecks []RuntimeServerVerificationCheckBody `json:"verificationChecks"`
}

type ServerDeploymentEvidenceBody struct {
	TemplateKey         string            `json:"templateKey,omitempty"`
	TemplateVersion     string            `json:"templateVersion,omitempty"`
	PreflightState      string            `json:"preflightState,omitempty"`
	DiscoveryState      string            `json:"discoveryState,omitempty"`
	MappingState        string            `json:"mappingState,omitempty"`
	VerificationState   string            `json:"verificationState,omitempty"`
	DiscoveredFacts     map[string]string `json:"discoveredFacts,omitempty"`
	MappingResults      map[string]string `json:"mappingResults,omitempty"`
	VerificationResults map[string]string `json:"verificationResults,omitempty"`
	FailureCode         string            `json:"failureCode,omitempty"`
}

type ServerDeploymentExecutionReceiptBody struct {
	SchemaVersion  string                      `json:"schemaVersion"`
	Revision       int                         `json:"revision"`
	Action         string                      `json:"action"`
	Mode           domain.ServerDeploymentMode `json:"mode"`
	Shell          domain.ServerCommandShell   `json:"shell,omitempty"`
	UsedServerRoot bool                        `json:"usedServerRoot"`
}

// ServerDeploymentExecutionBody is included only in a leased Run assignment.
// It is intentionally absent from all public server and job response DTOs.
type ServerDeploymentExecutionBody struct {
	SchemaVersion    string                      `json:"schemaVersion"`
	Mode             domain.ServerDeploymentMode `json:"mode"`
	ProfileKey       string                      `json:"profileKey,omitempty"`
	RuntimeBindings  map[string]string           `json:"runtimeBindings,omitempty"`
	CreateInputs     map[string]string           `json:"createInputs,omitempty"`
	ServerRoot       string                      `json:"serverRoot,omitempty"`
	WorkingDirectory string                      `json:"workingDirectory,omitempty"`
	InstallCommand   string                      `json:"installCommand,omitempty"`
	StartCommand     string                      `json:"startCommand,omitempty"`
	StopCommand      string                      `json:"stopCommand,omitempty"`
	StatusCommand    string                      `json:"statusCommand,omitempty"`
	Shell            domain.ServerCommandShell   `json:"shell,omitempty"`
	Revision         int                         `json:"revision"`
}

type RuntimeSourceRCONPlanBody struct {
	Protocol           string `json:"protocol"`
	ExtensionKey       string `json:"extensionKey"`
	ModKey             string `json:"modKey"`
	ConfigRef          string `json:"configRef"`
	DeploymentStateRef string `json:"deploymentStateRef"`
	Port               int    `json:"port"`
}

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"`
	ServerDeploymentEvidence *ServerDeploymentEvidenceBody         `json:"serverDeploymentEvidence,omitempty"`
	DeploymentReceipt        *ServerDeploymentExecutionReceiptBody `json:"deploymentReceipt,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"`
	PlatformURL      string `json:"platformUrl,omitempty"`
	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 SourceRCONExecutionInputRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	JobID         string `json:"jobId"`
	LeaseToken    string `json:"leaseToken"`
	Attempt       int    `json:"attempt"`
}

type SourceRCONExecutionInputResponse struct {
	JobID            string `json:"jobId"`
	ServerInstanceID string `json:"serverInstanceId"`
	RunEndpointID    string `json:"runEndpointId"`
	Command          string `json:"command"`
}

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, ServerDeploymentEvidence: serverDeploymentEvidenceToDomain(request.ExecutionResult.ServerDeploymentEvidence), DeploymentReceipt: deploymentReceiptToDomain(request.ExecutionResult.DeploymentReceipt)},
	}
}

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 SourceRCONExecutionInputRequest) ToDomain() domain.SourceRCONExecutionInputRequest {
	return domain.SourceRCONExecutionInputRequest{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,
		PlatformURL:      input.PlatformURL,
		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 SourceRCONExecutionInputFromDomain(input domain.SourceRCONExecutionInput) SourceRCONExecutionInputResponse {
	return SourceRCONExecutionInputResponse{JobID: input.JobID, ServerInstanceID: input.ServerInstanceID, RunEndpointID: input.RunEndpointID, Command: input.Command}
}

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, PluginID: assignment.ExecutionInput.PluginID, LifecycleOperation: assignment.ExecutionInput.LifecycleOperation, TargetVersion: assignment.ExecutionInput.TargetVersion, Inputs: domain.CopyStringMap(assignment.ExecutionInput.Inputs), DLLExtensions: dllExtensionPlansFromDomain(assignment.ExecutionInput.DLLExtensions), SourceRCON: runtimeSourceRCONPlanFromDomain(assignment.ExecutionInput.SourceRCON), Deployment: deploymentExecutionFromDomain(assignment.ExecutionInput.Deployment), ServerDeploymentPlan: serverDeploymentPlanFromDomain(assignment.ExecutionInput.ServerDeploymentPlan)},
		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 serverDeploymentPlanFromDomain(plan *domain.ServerDeploymentPlan) *ServerDeploymentPlanBody {
	if plan == nil {
		return nil
	}
	body := &ServerDeploymentPlanBody{SchemaVersion: plan.SchemaVersion, Operation: plan.Operation, PluginID: plan.PluginID, TemplateKey: plan.TemplateKey, TemplateVersion: plan.TemplateVersion, SteamAppID: plan.SteamAppID, ExecutableKey: plan.ExecutableKey, InstallRootKey: plan.InstallRootKey, ConfigKey: plan.ConfigKey, ConfigFormat: plan.ConfigFormat}
	for _, mapping := range plan.ConfigMappings {
		body.ConfigMappings = append(body.ConfigMappings, RuntimeServerConfigMappingBody{FieldKey: mapping.FieldKey, ConfigKey: mapping.ConfigKey, ValueType: mapping.ValueType, Required: mapping.Required})
	}
	for _, marker := range plan.DiscoveryMarkers {
		body.DiscoveryMarkers = append(body.DiscoveryMarkers, RuntimeServerDiscoveryMarkerBody{Key: marker.Key, Kind: marker.Kind, TargetKey: marker.TargetKey, Expected: marker.Expected, Required: marker.Required})
	}
	for _, check := range plan.VerificationChecks {
		body.VerificationChecks = append(body.VerificationChecks, RuntimeServerVerificationCheckBody{Key: check.Key, Kind: check.Kind, TargetKey: check.TargetKey, Required: check.Required})
	}
	return body
}

func serverDeploymentEvidenceToDomain(body *ServerDeploymentEvidenceBody) *domain.ServerDeploymentEvidence {
	if body == nil {
		return nil
	}
	return &domain.ServerDeploymentEvidence{TemplateKey: body.TemplateKey, TemplateVersion: body.TemplateVersion, PreflightState: body.PreflightState, DiscoveryState: body.DiscoveryState, MappingState: body.MappingState, VerificationState: body.VerificationState, DiscoveredFacts: domain.CopyStringMap(body.DiscoveredFacts), MappingResults: domain.CopyStringMap(body.MappingResults), VerificationResults: domain.CopyStringMap(body.VerificationResults), FailureCode: body.FailureCode}
}

func serverDeploymentEvidenceFromDomain(evidence *domain.ServerDeploymentEvidence) *ServerDeploymentEvidenceBody {
	if evidence == nil {
		return nil
	}
	return &ServerDeploymentEvidenceBody{TemplateKey: evidence.TemplateKey, TemplateVersion: evidence.TemplateVersion, PreflightState: evidence.PreflightState, DiscoveryState: evidence.DiscoveryState, MappingState: evidence.MappingState, VerificationState: evidence.VerificationState, DiscoveredFacts: domain.CopyStringMap(evidence.DiscoveredFacts), MappingResults: domain.CopyStringMap(evidence.MappingResults), VerificationResults: domain.CopyStringMap(evidence.VerificationResults), FailureCode: evidence.FailureCode}
}
func deploymentReceiptToDomain(body *ServerDeploymentExecutionReceiptBody) *domain.ServerDeploymentExecutionReceipt {
	if body == nil {
		return nil
	}
	return &domain.ServerDeploymentExecutionReceipt{SchemaVersion: body.SchemaVersion, Revision: body.Revision, Action: body.Action, Mode: body.Mode, Shell: body.Shell, UsedServerRoot: body.UsedServerRoot}
}
func deploymentReceiptFromDomain(value *domain.ServerDeploymentExecutionReceipt) *ServerDeploymentExecutionReceiptBody {
	if value == nil {
		return nil
	}
	return &ServerDeploymentExecutionReceiptBody{SchemaVersion: value.SchemaVersion, Revision: value.Revision, Action: value.Action, Mode: value.Mode, Shell: value.Shell, UsedServerRoot: value.UsedServerRoot}
}

func deploymentExecutionFromDomain(definition *domain.ServerDeploymentDefinition) *ServerDeploymentExecutionBody {
	if definition == nil {
		return nil
	}
	copy := domain.CopyServerDeploymentDefinition(*definition)
	return &ServerDeploymentExecutionBody{SchemaVersion: "1", Mode: copy.Mode, ProfileKey: copy.ProfileKey, RuntimeBindings: copy.RuntimeBindings, CreateInputs: copy.CreateInputs, ServerRoot: copy.ServerRoot, WorkingDirectory: copy.WorkingDirectory, InstallCommand: copy.InstallCommand, StartCommand: copy.StartCommand, StopCommand: copy.StopCommand, StatusCommand: copy.StatusCommand, Shell: copy.Shell, Revision: copy.Revision}
}

func runtimeSourceRCONPlanFromDomain(plan *domain.RuntimeSourceRCONPlan) *RuntimeSourceRCONPlanBody {
	if plan == nil {
		return nil
	}
	return &RuntimeSourceRCONPlanBody{Protocol: plan.Protocol, ExtensionKey: plan.ExtensionKey, ModKey: plan.ModKey, ConfigRef: plan.ConfigRef, DeploymentStateRef: plan.DeploymentStateRef, Port: plan.Port}
}

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

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