package activator

import (
	"context"
	"time"

	"github.com/carlosframework/platform/internal/registry"
	"github.com/carlosframework/platform/internal/release"
)

// Plan 5 of the zero-downtime deploys work consumes these names. The index
// fixes the first block; plans 1 to 4 fix the rest in their own documents
// (the index's "Cross-plan interface ledger"). If this file does not
// compile, a plan merged a different name, and plan 5 stops until it is
// reconciled with that plan's owner.
var (
	_ func(*Service, string) (string, bool)                                    = (*Service).AppSocket
	_ func(*Service, context.Context, Attempt, func(string) uint64) SwapResult = (*Service).Swap
	_                                                                          = Gen{N: 1, Socket: "", Control: "", Build: "", StagedPath: "", Digest: "", Demand: ""}
	_                                                                          = Attempt{Host: "", Cause: CauseRelease, Build: "", StagedPath: "", Digest: "", Demand: "", Mode: ModeOverlap, ConfigRev: "", RestartID: "", SchedRev: 0, Canary: false}
	_                                                                          = SwapResult{Outcome: SwapDone, Gen: Gen{}, Reason: "", Drain: time.Second}
	_                                                                          = []SwapOutcome{SwapDone, SwapFailed, SwapAbandoned, SwapDown}
	_                                                                          = []Cause{CauseRelease, CauseInstall, CauseRetry, CauseRestart, CauseConfig}
	_                                                                          = []SwapMode{ModeOverlap, ModeHold}

	_ func(bool)                                                                      = SetGenerations              // plan 1
	_ func(*ExecBackend, context.Context, registry.Route, uint64) error               = (*ExecBackend).KillGen      // plan 2
	_ func(*SplitBackend, context.Context, registry.Route, uint64) error              = (*SplitBackend).KillGen     // plan 2
	_ SwapBackend                                                                     = (*SplitBackend)(nil)        // plan 3
	_ genKiller                                                                       = (*SplitBackend)(nil)        // plan 3 Task 2 declares genKiller; plan 5 declares none
	_ func(*Service, *actEntry, Attempt, func(string) uint64) error                   = (*Service).swapChecksLocked // plan 3
	_ func(*Service, context.Context, registry.Route, Gen) (Proc, string, Gen, error) = (*Service).startPinned      // plan 3
	_ func(context.Context, Proc, time.Duration) settleResult                         = observeSettle               // plan 3
	_                                                                                 = []settleResult{settleOK, settleExited, settleCancelled}
	_                                                                                 = []error{errSwapNotAwake, errSwapBusy, errSwapStopped}             // plan 3
	_                                                                                 = StartPolicy{Pin: &Gen{}, Fallback: &Gen{}, HealthBy: time.Time{}} // plan 3

	// Adapted: the plan pinned startWorker as returning (Proc,
	// release.StagedIdentity, error) with no gate. Main
	// (workerbuild.go:77) takes a gate and also returns a pendingGeneration.
	_ func(*Service, context.Context, registry.Route, map[string]string, *release.StagedIdentity, func() error) (Proc, release.StagedIdentity, pendingGeneration, error) = (*Service).startWorker         // plan 4
	_ func(*Service, *actEntry, Proc, string, *release.StagedIdentity)                                                                                                   = (*Service).respawnWorkerLocked // plan 4

	// Added by the controller: later tasks build on these merged names.
	_ func(*Service, context.Context, registry.Route, Gen, func() error, time.Time) (Proc, string, Gen, error) = (*Service).startPinnedAt      // swaphold.go; plan 5 Task 9 added the health deadline
	_ func(*Service, context.Context, *actEntry, registry.Route, Gen, Lease) (Proc, string, Gen, error)        = (*Service).startPinnedChecked // swaphold.go
	_ error                                                                                                    = ErrBuildNotPublished          // workerbuild.go
	_ func(*Service) error                                                                                     = (*Service).persistGenerations // generations_file.go
)

// Fields plan 5 reads or sets.
func _(a *Service, e *actEntry, w *wokenInstance, m *genMember, eb *ExecBackend) {
	a.gens = true                                                 // plan 1
	eb.GenContainment = true                                      // plan 2
	a.genHealth = func(context.Context, Gen) error { return nil } // plan 3, test seam
	a.CoalesceRecycle = func(string) bool { return false }        // plan 4
	var _ Gen = e.gen                                             // plan 1
	var _ Gen = w.gen                                             // plan 1
	var _ *Gen = e.pin                                            // plan 3
	var _ *Gen = e.pinFailed                                      // plan 3
	var _ string = e.pinFailReason                                // plan 3
	var _ map[uint64]*genMember = e.ops.members                   // plan 3
	var _ Gen = m.gen                                             // plan 3
	var _ release.StagedIdentity = e.workerServing                // plan 4
	var _ chan struct{} = e.respawnDone                           // main
	var _ string = a.GenerationsFile                              // generations_file.go
}