package host

import (
	"context"
	"errors"
	"github.com/carlosframework/platform/internal/activator"
	"github.com/carlosframework/platform/internal/hostbox"
	"github.com/carlosframework/platform/internal/hostclaim"
	"github.com/carlosframework/platform/internal/registry"
	"time"
)

type filesSeedRuntimeFactory func(context.Context, *filesSeedOperation, *activator.SeedExclusion) (*activator.ClaimRuntime, *ClaimWakeAssembly, error)

func newFilesSeedRuntime(ctx context.Context, a ClaimAssembly, source hostbox.WorkSource, writer hostbox.Writer, op *filesSeedOperation, exclusion *activator.SeedExclusion) (*activator.ClaimRuntime, *ClaimWakeAssembly, error) {
	if a.Wake == nil || op == nil || a.wakeUnavailable != nil {
		return nil, nil, hostbox.ErrUnsupported
	}
	base := a.Wake
	var serving *claimServingOwners
	switch in := base.Inputs.(type) {
	case ClaimOwnerDispatch:
		serving, _ = in.Serving.Inputs.(*claimServingOwners)
	case *claimServingOwners:
		serving = in
	}
	if serving == nil {
		return nil, nil, hostbox.ErrUnsupported
	}
	sources := serving.Sources
	sources.Files = op.files
	private := &claimServingOwners{HomeRegion: serving.HomeRegion, Data: serving.Data, Bucket: serving.Bucket, Region: serving.Region, Box: serving.Box, NewID: serving.NewID, Now: serving.Now, Sources: sources}
	w := &ClaimWakeAssembly{Roles: base.Roles, LeaseRegion: base.LeaseRegion, Producers: base.Producers, Inputs: private, Manager: base.Manager, Retries: base.Retries, BeforeAdmission: base.BeforeAdmission, RetireArtifacts: base.RetireArtifacts, RecoverArtifacts: base.RecoverArtifacts, RequireServingEnrollment: base.RequireServingEnrollment, BeforeLegacyInstall: base.BeforeLegacyInstall, BeforeInstallLocked: base.BeforeInstallLocked, PrepareState: base.PrepareState, Prelaunch: base.Prelaunch, Launch: base.Launch, Ready: base.Ready, ObserveLoss: base.ObserveLoss}
	w.Retain = w.retainCaptured
	w.ServingPrerequisites = op.prerequisites(exclusion)
	w.AfterAdmission = func(ctx context.Context, prior, current hostclaim.Observed) error {
		if err := base.AfterAdmission(ctx, prior, current); err != nil {
			return err
		}
		return op.admitted(ctx, current)
	}
	w.Retries.Inputs = private.launchDigest
	w.Retries.ExactHealth = w.exactHealth
	w.Retries.BeforeReserve = func(ctx context.Context, rt registry.Route, o hostclaim.Observed) error {
		if err := w.ServingPrerequisites(ctx, rt, o); err != nil {
			return err
		}
		return claimServingRoom(op.files.DataDir)
	}
	a.Wake = w
	a.bindClaimWakeStop()
	writer.AdmissionEvidence = private.admissionEvidence
	runtime, err := w.Build(ctx, source, writer)
	return runtime, w, err
}

// The seed follows ordinary cold preparation and spends its one attempt. It
// never calls any launch, publication, replication or health closure.
func prepareFilesSeed(ctx context.Context, rt registry.Route, runtime *activator.ClaimRuntime, o hostclaim.Observed, exclusion *activator.SeedExclusion) (admitted hostclaim.Observed, settled bool, resultErr error) {
	if err := exclusion.Check(rt.Host); err != nil {
		return admitted, false, err
	}
	if runtime == nil || runtime.Read == nil || runtime.Prerequisites == nil || runtime.Admit == nil || runtime.Prepare == nil || runtime.FailedAdmission == nil {
		return admitted, false, hostbox.ErrUnsupported
	}
	policy := activator.StartPolicy{MaxStarts: 5, Window: 30 * time.Second}
	cleanupObservation := o
	var start activator.ClaimStart
	defer func() {
		cleanup, cancel := activator.CleanupContext(ctx, 30*time.Second)
		defer cancel()
		var stopErr error
		if start.Failed != nil {
			stopErr = start.Failed(cleanup, 0)
		}
		closeErr := runtime.FailedAdmission(cleanup, cleanupObservation, hostbox.ErrChanged)
		fresh, readErr := runtime.Read(cleanup, o.Host)
		if readErr == nil {
			if fresh.Claim == nil || fresh.Claim.Holder == nil || o.Claim == nil || o.Claim.Holder == nil || fresh.Claim.Holder.Incarnation != o.Claim.Holder.Incarnation || fresh.Claim.Holder.WakeRetry != nil && fresh.Claim.Holder.WakeRetry.State == "attempting" {
				readErr = hostbox.ErrChanged
			}
		}
		closeErr = errors.Join(closeErr, readErr)
		settled = stopErr == nil && closeErr == nil
		resultErr = errors.Join(resultErr, stopErr, closeErr)
	}()
	if err := runtime.Prerequisites(ctx, rt, o, policy); err != nil {
		return admitted, false, err
	}
	var err error
	admitted, err = runtime.Admit(ctx, rt, o, policy)
	if err != nil {
		return admitted, false, err
	}
	cleanupObservation = admitted
	start, err = runtime.Prepare(ctx, rt, admitted, policy)
	if err != nil {
		return admitted, false, err
	}
	if start.Restore == nil || start.Reserve == nil || start.Materialize == nil || start.Failed == nil {
		return admitted, false, hostbox.ErrUnsupported
	}
	if err = start.Restore(ctx); err != nil {
		return admitted, false, err
	}
	if err = start.Reserve(ctx, 0); err != nil {
		return admitted, false, err
	}
	if err = exclusion.Check(rt.Host); err != nil {
		return admitted, false, err
	}
	resultErr = start.Materialize(ctx)
	return admitted, false, resultErr
}