package contract

type RunStatus string

const (
	RunProducing             RunStatus = "producing"
	RunRunning               RunStatus = "running"
	RunCompleted             RunStatus = "completed"
	RunCompletedWithFailures RunStatus = "completed_with_failures"
)

func (s RunStatus) Valid() bool {
	return s == RunProducing || s == RunRunning || s.Terminal()
}

func (s RunStatus) Terminal() bool { return s == RunCompleted || s == RunCompletedWithFailures }

type SyncType string

const (
	SyncNormal SyncType = "normal"
	SyncReplay SyncType = "replay"
)

func (s SyncType) Valid() bool { return s == SyncNormal || s == SyncReplay }

type SyncKind string

const (
	SyncKindTrafficUsage        SyncKind = "traffic_usage"
	SyncKindSimStatus           SyncKind = "sim_status"
	SyncKindTrafficUsageDaily   SyncKind = "traffic_usage_daily"
	SyncKindTrafficUsageMonthly SyncKind = "traffic_usage_monthly"
	SyncKindImei                SyncKind = "imei"
)

func (s SyncKind) Valid() bool {
	return s == SyncKindTrafficUsage || s == SyncKindSimStatus || s == SyncKindTrafficUsageDaily || s == SyncKindTrafficUsageMonthly || s == SyncKindImei
}

func SyncKindForOperation(operation string) SyncKind {
	switch operation {
	case "current_month_usage_full_sync":
		return SyncKindTrafficUsage
	case "sim_status_queue_full_sync":
		return SyncKindSimStatus
	case "previous_day_usage_full_sync":
		return SyncKindTrafficUsageDaily
	case "previous_month_usage_full_sync":
		return SyncKindTrafficUsageMonthly
	case "imei_full_sync":
		return SyncKindImei
	default:
		return ""
	}
}

type ArchiveStatus string

const (
	ArchiveDisabled   ArchiveStatus = "disabled"
	ArchivePending    ArchiveStatus = "pending"
	ArchiveProcessing ArchiveStatus = "processing"
	ArchiveSucceeded  ArchiveStatus = "succeeded"
	ArchiveFailed     ArchiveStatus = "failed"
)

func (s ArchiveStatus) Valid() bool {
	switch s {
	case ArchiveDisabled, ArchivePending, ArchiveProcessing, ArchiveSucceeded, ArchiveFailed:
		return true
	}
	return false
}

// ReplayDisposition describes a source run, not an individual replay action.
type ReplayDisposition string

const (
	ReplayNone           ReplayDisposition = "none"
	ReplayPending        ReplayDisposition = "pending"
	ReplayProcessing     ReplayDisposition = "processing"
	ReplayCompleted      ReplayDisposition = "completed"
	ReplayNeedsAttention ReplayDisposition = "needs_attention"
)

func (s ReplayDisposition) Valid() bool {
	switch s {
	case ReplayNone, ReplayPending, ReplayProcessing, ReplayCompleted, ReplayNeedsAttention:
		return true
	}
	return false
}

type ActionStatus string

const (
	ActionAccepted       ActionStatus = "accepted"
	ActionProcessing     ActionStatus = "processing"
	ActionCleanupPending ActionStatus = "cleanup_pending"
	ActionReceiptPending ActionStatus = "receipt_pending"
	ActionCompleted      ActionStatus = "completed"
	ActionNeedsAttention ActionStatus = "needs_attention"
)

func (s ActionStatus) Valid() bool {
	switch s {
	case ActionAccepted, ActionProcessing, ActionCleanupPending, ActionReceiptPending, ActionCompleted, ActionNeedsAttention:
		return true
	}
	return false
}

// Terminal means automatic work has stopped; needs_attention may be resumed
// only by an explicit recovery policy, never by assuming it succeeded.
func (s ActionStatus) Terminal() bool { return s == ActionCompleted || s == ActionNeedsAttention }

type RunSource string

const (
	SourceLive    RunSource = "live"
	SourceArchive RunSource = "archive"
)

func (s RunSource) Valid() bool { return s == SourceLive || s == SourceArchive }

// These values are already persisted by the queue protocol.
const (
	TaskQueued              = "queued"
	TaskClaimed             = "claimed"
	TaskWaitingNextRound    = "waiting_next_round"
	TaskSucceeded           = "succeeded"
	TaskCovered             = "covered"
	TaskFailedPendingReview = "failed_pending_review"
	TaskChannelBlocked      = "channel_blocked"
	ReviewPending           = "pending"
)