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"`
	LeaseToken       string          `json:"leaseToken"`
	Attempt          int             `json:"attempt"`
	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"`
}

type RunJobResultResponse struct {
	Accepted   bool                     `json:"accepted"`
	Job        RunJobAssignmentResponse `json:"job"`
	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"`
}

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

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 RunJobReconcileRequest struct {
	RunEndpointID string   `json:"runEndpointId"`
	SessionToken  string   `json:"sessionToken"`
	ActiveJobIDs  []string `json:"activeJobIds"`
}

type RunJobReconcileResponse struct {
	Accepted      bool                       `json:"accepted"`
	RunEndpointID string                     `json:"runEndpointId"`
	ActiveJobs    []RunJobAssignmentResponse `json:"activeJobs"`
	UnknownJobIDs []string                   `json:"unknownJobIds"`
	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,
	}
}

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,
	}
}

func (request RunJobReconcileRequest) ToDomain() domain.RunJobReconcile {
	return domain.RunJobReconcile{
		RunEndpointID: request.RunEndpointID,
		SessionToken:  request.SessionToken,
		ActiveJobIDs:  domain.CopyStringSlice(request.ActiveJobIDs),
	}
}

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 RunJobCancelRequestFromDomain(result domain.RunJobCancelRequestResult) RunJobCancelRequestResponse {
	return RunJobCancelRequestResponse{
		Accepted:    result.Accepted,
		JobID:       result.JobID,
		Reason:      result.Reason,
		RequestedAt: result.RequestedAt,
	}
}

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.ActiveJobs))
	for i, assignment := range result.ActiveJobs {
		items[i] = RunJobAssignmentFromDomain(assignment)
	}
	return RunJobReconcileResponse{
		Accepted:      result.Accepted,
		RunEndpointID: result.RunEndpointID,
		ActiveJobs:    items,
		UnknownJobIDs: result.UnknownJobIDs,
		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,
		LeaseToken:       assignment.LeaseToken,
		Attempt:          assignment.Attempt,
		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,
	}
}